From 83c4b6a6427cf3c008d3ecedf2d84ef2ab1f97c7 Mon Sep 17 00:00:00 2001 From: aothms Date: Mon, 30 Nov 2015 22:34:48 +0100 Subject: [PATCH] More serialization options for HDF5 --- src/ifcconvert/IfcConvert.cpp | 17 +- src/ifcexpressparser/bootstrap.py | 2 +- src/ifcexpressparser/nodes.py | 2 +- src/ifcexpressparser/schema_class.py | 35 +- src/ifcparse/Ifc2x3-schema.cpp | 374 +- src/ifcparse/Ifc4.cpp | 16997 +++++++++++++------------ src/ifcparse/Ifc4.h | 6925 ++-------- src/ifcparse/IfcFile.h | 5 +- src/ifcparse/IfcHdf5File.cpp | 237 +- src/ifcparse/IfcHdf5File.h | 11 +- src/ifcparse/IfcParse.cpp | 163 +- src/ifcparse/IfcParse.h | 94 + src/ifcparse/IfcSchema.h | 94 +- 13 files changed, 11012 insertions(+), 13944 deletions(-) diff --git a/src/ifcconvert/IfcConvert.cpp b/src/ifcconvert/IfcConvert.cpp index 4e7652e7af..e704006023 100644 --- a/src/ifcconvert/IfcConvert.cpp +++ b/src/ifcconvert/IfcConvert.cpp @@ -33,6 +33,8 @@ #include +#include "../ifcparse/Hdf5Settings.h" + #include "../ifcgeom/IfcGeomIterator.h" #include "../ifcconvert/ColladaSerializer.h" @@ -132,8 +134,11 @@ int main(int argc, char** argv) { ("bounds", boost::program_options::value(&bounds), "Specifies the bounding rectangle, for example 512x512, to which the " "output will be scaled. Only used when converting to SVG.") - ("compress", - "Compress HDF5.") + ("hdf5-compress", "") + ("hdf5-fix-cartesian-point", "") + ("hdf5-fix-global-id", "") + ("hdf5-instantiate-inverse", "") + ("hdf5-instantiate-select", "") ("include", "Specifies that the entities listed after --entities are to be included") ("exclude", @@ -260,7 +265,13 @@ int main(int argc, char** argv) { if (!f.Init(input_filename)) { Logger::Message(Logger::LOG_ERROR, "Unable to parse .ifc file"); } else { - f.write_hdf5(output_filename, vmap.count("compress") != 0); + IfcParse::Hdf5Settings settings; + settings.compress() = vmap.count("hdf5-compress") != 0; + settings.fix_cartesian_point() = vmap.count("hdf5-fix-cartesian-point") != 0; + settings.fix_global_id() = vmap.count("hdf5-fix-global-id") != 0; + settings.instantiate_inverse() = vmap.count("hdf5-instantiate-inverse") != 0; + settings.instantiate_select() = vmap.count("hdf5-instantiate-select") != 0; + f.write_hdf5(output_filename, settings); exit_code = 0; } // } catch (...) {} diff --git a/src/ifcexpressparser/bootstrap.py b/src/ifcexpressparser/bootstrap.py index c994bd4515..c9557c769d 100644 --- a/src/ifcexpressparser/bootstrap.py +++ b/src/ifcexpressparser/bootstrap.py @@ -115,7 +115,7 @@ actions = { 'general_aggregation_types' : "lambda t: AggregationType(t)", 'select_type' : "lambda t: SelectType(t)", 'binary_type' : "lambda t: BinaryType(t)", - 'subtype_declaration' : "lambda t: SubtypeExpression(t)", + 'subtype_declaration' : "lambda t: SubTypeExpression(t)", 'derive_clause' : "lambda t: AttributeList('derive', t)", 'derived_attr' : "lambda t: DerivedAttribute(t)", 'inverse_clause' : "lambda t: AttributeList('inverse', t)", diff --git a/src/ifcexpressparser/nodes.py b/src/ifcexpressparser/nodes.py index 31359d46c5..7913f4e8db 100644 --- a/src/ifcexpressparser/nodes.py +++ b/src/ifcexpressparser/nodes.py @@ -137,7 +137,7 @@ class AttributeList(Node): class InverseAttribute(Node): name = property(lambda self: self.tokens[0]) - type = property(lambda self: self.tokens[2]) + type = property(lambda self: None if len(self.tokens) == 6 else self.tokens[2]) bounds = property(lambda self: None if len(self.tokens) == 6 else self.tokens[3]) entity = property(lambda self: self.tokens[-4]) attribute = property(lambda self: self.tokens[-2]) diff --git a/src/ifcexpressparser/schema_class.py b/src/ifcexpressparser/schema_class.py index 899e313fbf..94e43bea53 100644 --- a/src/ifcexpressparser/schema_class.py +++ b/src/ifcexpressparser/schema_class.py @@ -34,7 +34,7 @@ class SchemaClass: 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)) + 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): @@ -46,7 +46,21 @@ class SchemaClass: else: raise UnmetDependenciesException(type) else: - return "new simple_type(simple_type::%s_type)" % type + return "new simple_type(simple_type::%s_type)" % type + + def find_inverse_name_and_index(entity_name, attribute_name): + attributes_per_subtype = [] + while True: + entity = mapping.schema.entities[entity_name] + attr_names = list(map(operator.attrgetter('name'), entity.attributes)) + if len(attr_names): + attributes_per_subtype.append((entity_name, attr_names)) + if len(entity.supertypes) != 1: break + entity_name = entity.supertypes[0] + index = 0 + for et, attrs in attributes_per_subtype[::-1]: + try: return et, attrs.index(attribute_name) + except: pass self.schema_name = mapping.schema.name.capitalize() @@ -140,6 +154,23 @@ class SchemaClass: statements.append(' %(name)s_type->set_attributes(attributes, derived);' % locals()) statements.append(' }') + for name, type in mapping.schema.entities.items(): + if type.inverse: + statements.append(' {') + statements.append(' std::vector attributes; attributes.reserve(%d);' % len(type.inverse.elements)) + for attr in type.inverse.elements: + if attr.bounds: + make_bound = lambda b: -1 if b == '?' else int(b) + bound1, bound2 = map(make_bound, (attr.bounds.lower, attr.bounds.upper)) + else: + bound1, bound2 = -1, -1 + attr_name, aggr_type, entity_ref = attr.name, attr.type, attr.entity + if aggr_type is None: aggr_type = 'unspecified' + attribute_entity, attribute_entity_index = find_inverse_name_and_index(entity_ref, attr.attribute) + statements.append(' attributes.push_back(new entity::inverse_attribute("%(attr_name)s", entity::inverse_attribute::%(aggr_type)s_type, %(bound1)d, %(bound2)d, %(entity_ref)s_type, %(attribute_entity)s_type->attributes()[%(attribute_entity_index)d]));' % locals()) + statements.append(' %(name)s_type->set_inverse_attributes(attributes);' % locals()) + statements.append(' }') + statements.append('') statements.append(' std::vector declarations; declarations.reserve(%(num_declarations)d);' % locals()) for type_name in declared_types: diff --git a/src/ifcparse/Ifc2x3-schema.cpp b/src/ifcparse/Ifc2x3-schema.cpp index c07c4d960d..c5e14c87f5 100644 --- a/src/ifcparse/Ifc2x3-schema.cpp +++ b/src/ifcparse/Ifc2x3-schema.cpp @@ -1009,11 +1009,9 @@ enumeration_type* IfcWindowPanelPositionEnum_type = 0; enumeration_type* IfcWindowStyleConstructionEnum_type = 0; enumeration_type* IfcWindowStyleOperationEnum_type = 0; enumeration_type* IfcWorkControlTypeEnum_type = 0; - #ifdef _MSC_VER -# pragma optimize( "", off ) +#pragma optimize("", off) #endif - 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)); @@ -9394,6 +9392,373 @@ schema_definition* populate_schema() { 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 attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("IsActingUpon", entity::inverse_attribute::set_type, 0, -1, IfcRelAssignsToActor_type, IfcRelAssignsToActor_type->attributes()[0])); + IfcActor_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("OfPerson", entity::inverse_attribute::set_type, 0, -1, IfcPerson_type, IfcPerson_type->attributes()[7])); + attributes.push_back(new entity::inverse_attribute("OfOrganization", entity::inverse_attribute::set_type, 0, -1, IfcOrganization_type, IfcOrganization_type->attributes()[4])); + IfcAddress_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ContainedInStructure", entity::inverse_attribute::set_type, 0, 1, IfcRelContainedInSpatialStructure_type, IfcRelContainedInSpatialStructure_type->attributes()[0])); + IfcAnnotation_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("ValuesReferenced", entity::inverse_attribute::set_type, 0, -1, IfcReferencesValueDocument_type, IfcReferencesValueDocument_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ValueOfComponents", entity::inverse_attribute::set_type, 0, -1, IfcAppliedValueRelationship_type, IfcAppliedValueRelationship_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("IsComponentIn", entity::inverse_attribute::set_type, 0, -1, IfcAppliedValueRelationship_type, IfcAppliedValueRelationship_type->attributes()[1])); + IfcAppliedValue_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("Actors", entity::inverse_attribute::set_type, 0, -1, IfcApprovalActorRelationship_type, IfcApprovalActorRelationship_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("IsRelatedWith", entity::inverse_attribute::set_type, 0, -1, IfcApprovalRelationship_type, IfcApprovalRelationship_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("Relates", entity::inverse_attribute::set_type, 0, -1, IfcApprovalRelationship_type, IfcApprovalRelationship_type->attributes()[1])); + IfcApproval_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("Contains", entity::inverse_attribute::set_type, 0, -1, IfcClassificationItem_type, IfcClassificationItem_type->attributes()[1])); + IfcClassification_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("IsClassifiedItemIn", entity::inverse_attribute::set_type, 0, 1, IfcClassificationItemRelationship_type, IfcClassificationItemRelationship_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("IsClassifyingItemIn", entity::inverse_attribute::set_type, 0, 1, IfcClassificationItemRelationship_type, IfcClassificationItemRelationship_type->attributes()[0])); + IfcClassificationItem_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("UsingCurves", entity::inverse_attribute::set_type, 1, -1, IfcCompositeCurve_type, IfcCompositeCurve_type->attributes()[0])); + IfcCompositeCurveSegment_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(6); + attributes.push_back(new entity::inverse_attribute("ClassifiedAs", entity::inverse_attribute::set_type, 0, -1, IfcConstraintClassificationRelationship_type, IfcConstraintClassificationRelationship_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("RelatesConstraints", entity::inverse_attribute::set_type, 0, -1, IfcConstraintRelationship_type, IfcConstraintRelationship_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("IsRelatedWith", entity::inverse_attribute::set_type, 0, -1, IfcConstraintRelationship_type, IfcConstraintRelationship_type->attributes()[3])); + attributes.push_back(new entity::inverse_attribute("PropertiesForConstraint", entity::inverse_attribute::set_type, 0, -1, IfcPropertyConstraintRelationship_type, IfcPropertyConstraintRelationship_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("Aggregates", entity::inverse_attribute::set_type, 0, -1, IfcConstraintAggregationRelationship_type, IfcConstraintAggregationRelationship_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("IsAggregatedIn", entity::inverse_attribute::set_type, 0, -1, IfcConstraintAggregationRelationship_type, IfcConstraintAggregationRelationship_type->attributes()[3])); + IfcConstraint_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("Controls", entity::inverse_attribute::set_type, 0, -1, IfcRelAssignsToControl_type, IfcRelAssignsToControl_type->attributes()[0])); + IfcControl_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("CoversSpaces", entity::inverse_attribute::set_type, 0, 1, IfcRelCoversSpaces_type, IfcRelCoversSpaces_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("Covers", entity::inverse_attribute::set_type, 0, 1, IfcRelCoversBldgElements_type, IfcRelCoversBldgElements_type->attributes()[1])); + IfcCovering_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("AnnotatedBySymbols", entity::inverse_attribute::set_type, 0, 2, IfcTerminatorSymbol_type, IfcTerminatorSymbol_type->attributes()[0])); + IfcDimensionCurve_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("AssignedToFlowElement", entity::inverse_attribute::set_type, 0, 1, IfcRelFlowControlElements_type, IfcRelFlowControlElements_type->attributes()[0])); + IfcDistributionControlElement_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("HasControlElements", entity::inverse_attribute::set_type, 0, 1, IfcRelFlowControlElements_type, IfcRelFlowControlElements_type->attributes()[1])); + IfcDistributionFlowElement_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("IsPointedTo", entity::inverse_attribute::set_type, 0, -1, IfcDocumentInformationRelationship_type, IfcDocumentInformationRelationship_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("IsPointer", entity::inverse_attribute::set_type, 0, 1, IfcDocumentInformationRelationship_type, IfcDocumentInformationRelationship_type->attributes()[0])); + IfcDocumentInformation_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ReferenceToDocument", entity::inverse_attribute::set_type, 0, 1, IfcDocumentInformation_type, IfcDocumentInformation_type->attributes()[3])); + IfcDocumentReference_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("IsRelatedFromCallout", entity::inverse_attribute::set_type, 0, -1, IfcDraughtingCalloutRelationship_type, IfcDraughtingCalloutRelationship_type->attributes()[3])); + attributes.push_back(new entity::inverse_attribute("IsRelatedToCallout", entity::inverse_attribute::set_type, 0, -1, IfcDraughtingCalloutRelationship_type, IfcDraughtingCalloutRelationship_type->attributes()[2])); + IfcDraughtingCallout_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(12); + attributes.push_back(new entity::inverse_attribute("HasStructuralMember", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsStructuralElement_type, IfcRelConnectsStructuralElement_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("FillsVoids", entity::inverse_attribute::set_type, 0, 1, IfcRelFillsElement_type, IfcRelFillsElement_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ConnectedTo", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsElements_type, IfcRelConnectsElements_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("HasCoverings", entity::inverse_attribute::set_type, 0, -1, IfcRelCoversBldgElements_type, IfcRelCoversBldgElements_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("HasProjections", entity::inverse_attribute::set_type, 0, -1, IfcRelProjectsElement_type, IfcRelProjectsElement_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("ReferencedInStructures", entity::inverse_attribute::set_type, 0, -1, IfcRelReferencedInSpatialStructure_type, IfcRelReferencedInSpatialStructure_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("HasPorts", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsPortToElement_type, IfcRelConnectsPortToElement_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("HasOpenings", entity::inverse_attribute::set_type, 0, -1, IfcRelVoidsElement_type, IfcRelVoidsElement_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("IsConnectionRealization", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsWithRealizingElements_type, IfcRelConnectsWithRealizingElements_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("ProvidesBoundaries", entity::inverse_attribute::set_type, 0, -1, IfcRelSpaceBoundary_type, IfcRelSpaceBoundary_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ConnectedFrom", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsElements_type, IfcRelConnectsElements_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("ContainedInStructure", entity::inverse_attribute::set_type, 0, 1, IfcRelContainedInSpatialStructure_type, IfcRelContainedInSpatialStructure_type->attributes()[0])); + IfcElement_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ProjectsElements", entity::inverse_attribute::unspecified_type, -1, -1, IfcRelProjectsElement_type, IfcRelProjectsElement_type->attributes()[1])); + IfcFeatureElementAddition_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("VoidsElements", entity::inverse_attribute::unspecified_type, -1, -1, IfcRelVoidsElement_type, IfcRelVoidsElement_type->attributes()[1])); + IfcFeatureElementSubtraction_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("HasSubContexts", entity::inverse_attribute::set_type, 0, -1, IfcGeometricRepresentationSubContext_type, IfcGeometricRepresentationSubContext_type->attributes()[0])); + IfcGeometricRepresentationContext_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ContainedInStructure", entity::inverse_attribute::set_type, 0, 1, IfcRelContainedInSpatialStructure_type, IfcRelContainedInSpatialStructure_type->attributes()[0])); + IfcGrid_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::inverse_attribute("PartOfW", entity::inverse_attribute::set_type, 0, 1, IfcGrid_type, IfcGrid_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("PartOfV", entity::inverse_attribute::set_type, 0, 1, IfcGrid_type, IfcGrid_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("PartOfU", entity::inverse_attribute::set_type, 0, 1, IfcGrid_type, IfcGrid_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("HasIntersections", entity::inverse_attribute::set_type, 0, -1, IfcVirtualGridIntersection_type, IfcVirtualGridIntersection_type->attributes()[0])); + IfcGridAxis_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("IsGroupedBy", entity::inverse_attribute::unspecified_type, -1, -1, IfcRelAssignsToGroup_type, IfcRelAssignsToGroup_type->attributes()[0])); + IfcGroup_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ReferenceIntoLibrary", entity::inverse_attribute::set_type, 0, 1, IfcLibraryInformation_type, IfcLibraryInformation_type->attributes()[4])); + IfcLibraryReference_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("HasRepresentation", entity::inverse_attribute::set_type, 0, 1, IfcMaterialDefinitionRepresentation_type, IfcMaterialDefinitionRepresentation_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("ClassifiedAs", entity::inverse_attribute::set_type, 0, 1, IfcMaterialClassificationRelationship_type, IfcMaterialClassificationRelationship_type->attributes()[1])); + IfcMaterial_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ToMaterialLayerSet", entity::inverse_attribute::unspecified_type, -1, -1, IfcMaterialLayerSet_type, IfcMaterialLayerSet_type->attributes()[0])); + IfcMaterialLayer_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("IsDefinedBy", entity::inverse_attribute::set_type, 0, -1, IfcRelDefines_type, IfcRelDefines_type->attributes()[0])); + IfcObject_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(4); + attributes.push_back(new entity::inverse_attribute("HasAssignments", entity::inverse_attribute::set_type, 0, -1, IfcRelAssigns_type, IfcRelAssigns_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("IsDecomposedBy", entity::inverse_attribute::set_type, 0, -1, IfcRelDecomposes_type, IfcRelDecomposes_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("Decomposes", entity::inverse_attribute::set_type, 0, 1, IfcRelDecomposes_type, IfcRelDecomposes_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("HasAssociations", entity::inverse_attribute::set_type, 0, -1, IfcRelAssociates_type, IfcRelAssociates_type->attributes()[0])); + IfcObjectDefinition_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("PlacesObject", entity::inverse_attribute::set_type, 1, 1, IfcProduct_type, IfcProduct_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("ReferencedByPlacements", entity::inverse_attribute::set_type, 0, -1, IfcLocalPlacement_type, IfcLocalPlacement_type->attributes()[0])); + IfcObjectPlacement_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("HasFillings", entity::inverse_attribute::set_type, 0, -1, IfcRelFillsElement_type, IfcRelFillsElement_type->attributes()[0])); + IfcOpeningElement_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("IsRelatedBy", entity::inverse_attribute::set_type, 0, -1, IfcOrganizationRelationship_type, IfcOrganizationRelationship_type->attributes()[3])); + attributes.push_back(new entity::inverse_attribute("Relates", entity::inverse_attribute::set_type, 0, -1, IfcOrganizationRelationship_type, IfcOrganizationRelationship_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("Engages", entity::inverse_attribute::set_type, 0, -1, IfcPersonAndOrganization_type, IfcPersonAndOrganization_type->attributes()[1])); + IfcOrganization_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("EngagedIn", entity::inverse_attribute::set_type, 0, -1, IfcPersonAndOrganization_type, IfcPersonAndOrganization_type->attributes()[0])); + IfcPerson_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("PartOfComplex", entity::inverse_attribute::set_type, 0, 1, IfcPhysicalComplexQuantity_type, IfcPhysicalComplexQuantity_type->attributes()[0])); + IfcPhysicalQuantity_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("ContainedIn", entity::inverse_attribute::unspecified_type, -1, -1, IfcRelConnectsPortToElement_type, IfcRelConnectsPortToElement_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("ConnectedFrom", entity::inverse_attribute::set_type, 0, 1, IfcRelConnectsPorts_type, IfcRelConnectsPorts_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ConnectedTo", entity::inverse_attribute::set_type, 0, 1, IfcRelConnectsPorts_type, IfcRelConnectsPorts_type->attributes()[0])); + IfcPort_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("OperatesOn", entity::inverse_attribute::set_type, 0, -1, IfcRelAssignsToProcess_type, IfcRelAssignsToProcess_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("IsSuccessorFrom", entity::inverse_attribute::set_type, 0, -1, IfcRelSequence_type, IfcRelSequence_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("IsPredecessorTo", entity::inverse_attribute::set_type, 0, -1, IfcRelSequence_type, IfcRelSequence_type->attributes()[0])); + IfcProcess_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ReferencedBy", entity::inverse_attribute::set_type, 0, -1, IfcRelAssignsToProduct_type, IfcRelAssignsToProduct_type->attributes()[0])); + IfcProduct_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("ShapeOfProduct", entity::inverse_attribute::set_type, 1, 1, IfcProduct_type, IfcProduct_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("HasShapeAspects", entity::inverse_attribute::set_type, 0, -1, IfcShapeAspect_type, IfcShapeAspect_type->attributes()[4])); + IfcProductDefinitionShape_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("PropertyForDependance", entity::inverse_attribute::set_type, 0, -1, IfcPropertyDependencyRelationship_type, IfcPropertyDependencyRelationship_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("PropertyDependsOn", entity::inverse_attribute::set_type, 0, -1, IfcPropertyDependencyRelationship_type, IfcPropertyDependencyRelationship_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("PartOfComplex", entity::inverse_attribute::set_type, 0, 1, IfcComplexProperty_type, IfcComplexProperty_type->attributes()[1])); + IfcProperty_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("HasAssociations", entity::inverse_attribute::set_type, 0, -1, IfcRelAssociates_type, IfcRelAssociates_type->attributes()[0])); + IfcPropertyDefinition_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("PropertyDefinitionOf", entity::inverse_attribute::set_type, 0, 1, IfcRelDefinesByProperties_type, IfcRelDefinesByProperties_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("DefinesType", entity::inverse_attribute::set_type, 0, 1, IfcTypeObject_type, IfcTypeObject_type->attributes()[1])); + IfcPropertySetDefinition_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("RepresentationMap", entity::inverse_attribute::set_type, 0, 1, IfcRepresentationMap_type, IfcRepresentationMap_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("LayerAssignments", entity::inverse_attribute::set_type, 0, -1, IfcPresentationLayerAssignment_type, IfcPresentationLayerAssignment_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("OfProductRepresentation", entity::inverse_attribute::set_type, 0, 1, IfcProductRepresentation_type, IfcProductRepresentation_type->attributes()[2])); + IfcRepresentation_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("RepresentationsInContext", entity::inverse_attribute::set_type, 0, -1, IfcRepresentation_type, IfcRepresentation_type->attributes()[0])); + IfcRepresentationContext_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("LayerAssignments", entity::inverse_attribute::set_type, 0, -1, IfcPresentationLayerAssignment_type, IfcPresentationLayerAssignment_type->attributes()[2])); + attributes.push_back(new entity::inverse_attribute("StyledByItem", entity::inverse_attribute::set_type, 0, 1, IfcStyledItem_type, IfcStyledItem_type->attributes()[0])); + IfcRepresentationItem_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("MapUsage", entity::inverse_attribute::set_type, 0, -1, IfcMappedItem_type, IfcMappedItem_type->attributes()[0])); + IfcRepresentationMap_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ResourceOf", entity::inverse_attribute::set_type, 0, -1, IfcRelAssignsToResource_type, IfcRelAssignsToResource_type->attributes()[0])); + IfcResource_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ScheduleTimeControlAssigned", entity::inverse_attribute::unspecified_type, -1, -1, IfcRelAssignsTasks_type, IfcRelAssignsTasks_type->attributes()[0])); + IfcScheduleTimeControl_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("OfShapeAspect", entity::inverse_attribute::set_type, 0, 1, IfcShapeAspect_type, IfcShapeAspect_type->attributes()[0])); + IfcShapeModel_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("HasCoverings", entity::inverse_attribute::set_type, 0, -1, IfcRelCoversSpaces_type, IfcRelCoversSpaces_type->attributes()[0])); + attributes.push_back(new entity::inverse_attribute("BoundedBy", entity::inverse_attribute::set_type, 0, -1, IfcRelSpaceBoundary_type, IfcRelSpaceBoundary_type->attributes()[0])); + IfcSpace_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("HasInteractionReqsFrom", entity::inverse_attribute::set_type, 0, -1, IfcRelInteractionRequirements_type, IfcRelInteractionRequirements_type->attributes()[3])); + attributes.push_back(new entity::inverse_attribute("HasInteractionReqsTo", entity::inverse_attribute::set_type, 0, -1, IfcRelInteractionRequirements_type, IfcRelInteractionRequirements_type->attributes()[4])); + IfcSpaceProgram_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(3); + attributes.push_back(new entity::inverse_attribute("ReferencesElements", entity::inverse_attribute::set_type, 0, -1, IfcRelReferencedInSpatialStructure_type, IfcRelReferencedInSpatialStructure_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ServicedBySystems", entity::inverse_attribute::set_type, 0, -1, IfcRelServicesBuildings_type, IfcRelServicesBuildings_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ContainsElements", entity::inverse_attribute::set_type, 0, -1, IfcRelContainedInSpatialStructure_type, IfcRelContainedInSpatialStructure_type->attributes()[1])); + IfcSpatialStructureElement_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("AssignedToStructuralItem", entity::inverse_attribute::unspecified_type, -1, -1, IfcRelConnectsStructuralActivity_type, IfcRelConnectsStructuralActivity_type->attributes()[1])); + IfcStructuralActivity_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ConnectsStructuralMembers", entity::inverse_attribute::set_type, 1, -1, IfcRelConnectsStructuralMember_type, IfcRelConnectsStructuralMember_type->attributes()[1])); + IfcStructuralConnection_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("AssignedStructuralActivity", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsStructuralActivity_type, IfcRelConnectsStructuralActivity_type->attributes()[0])); + IfcStructuralItem_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("SourceOfResultGroup", entity::inverse_attribute::set_type, 0, 1, IfcStructuralResultGroup_type, IfcStructuralResultGroup_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("LoadGroupFor", entity::inverse_attribute::set_type, 0, -1, IfcStructuralAnalysisModel_type, IfcStructuralAnalysisModel_type->attributes()[2])); + IfcStructuralLoadGroup_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(2); + attributes.push_back(new entity::inverse_attribute("ReferencesElement", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsStructuralElement_type, IfcRelConnectsStructuralElement_type->attributes()[1])); + attributes.push_back(new entity::inverse_attribute("ConnectedBy", entity::inverse_attribute::set_type, 0, -1, IfcRelConnectsStructuralMember_type, IfcRelConnectsStructuralMember_type->attributes()[0])); + IfcStructuralMember_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("Causes", entity::inverse_attribute::set_type, 0, -1, IfcStructuralAction_type, IfcStructuralAction_type->attributes()[1])); + IfcStructuralReaction_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ResultGroupFor", entity::inverse_attribute::set_type, 0, 1, IfcStructuralAnalysisModel_type, IfcStructuralAnalysisModel_type->attributes()[3])); + IfcStructuralResultGroup_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ServicesBuildings", entity::inverse_attribute::set_type, 0, 1, IfcRelServicesBuildings_type, IfcRelServicesBuildings_type->attributes()[0])); + IfcSystem_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("OfTable", entity::inverse_attribute::unspecified_type, -1, -1, IfcTable_type, IfcTable_type->attributes()[1])); + IfcTableRow_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("AnnotatedSurface", entity::inverse_attribute::set_type, 1, 1, IfcAnnotationSurface_type, IfcAnnotationSurface_type->attributes()[1])); + IfcTextureCoordinate_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("DocumentedBy", entity::inverse_attribute::set_type, 0, 1, IfcTimeSeriesReferenceRelationship_type, IfcTimeSeriesReferenceRelationship_type->attributes()[0])); + IfcTimeSeries_type->set_inverse_attributes(attributes); + } + { + std::vector attributes; attributes.reserve(1); + attributes.push_back(new entity::inverse_attribute("ObjectTypeOf", entity::inverse_attribute::set_type, 0, 1, IfcRelDefinesByType_type, IfcRelDefinesByType_type->attributes()[0])); + IfcTypeObject_type->set_inverse_attributes(attributes); + } std::vector declarations; declarations.reserve(980); declarations.push_back(IfcAbsorbedDoseMeasure_type); @@ -10380,9 +10745,8 @@ schema_definition* populate_schema() { } #ifdef _MSC_VER -# pragma optimize( "", on ) +#pragma optimize("", on) #endif - const schema_definition& get_schema() { static const schema_definition* s = populate_schema(); diff --git a/src/ifcparse/Ifc4.cpp b/src/ifcparse/Ifc4.cpp index d599ac25b8..dd3a4b39b1 100644 --- a/src/ifcparse/Ifc4.cpp +++ b/src/ifcparse/Ifc4.cpp @@ -27,6 +27,7 @@ #ifdef USE_IFC4 #include "../ifcparse/Ifc4.h" +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/IfcException.h" #include "../ifcparse/IfcWrite.h" #include "../ifcparse/IfcWritableEntity.h" @@ -35,6 +36,900 @@ using namespace Ifc4; using namespace IfcParse; using namespace IfcWrite; +// External definitions +extern entity* IfcActionRequest_type; +extern entity* IfcActor_type; +extern entity* IfcActorRole_type; +extern entity* IfcActuator_type; +extern entity* IfcActuatorType_type; +extern entity* IfcAddress_type; +extern entity* IfcAdvancedBrep_type; +extern entity* IfcAdvancedBrepWithVoids_type; +extern entity* IfcAdvancedFace_type; +extern entity* IfcAirTerminal_type; +extern entity* IfcAirTerminalBox_type; +extern entity* IfcAirTerminalBoxType_type; +extern entity* IfcAirTerminalType_type; +extern entity* IfcAirToAirHeatRecovery_type; +extern entity* IfcAirToAirHeatRecoveryType_type; +extern entity* IfcAlarm_type; +extern entity* IfcAlarmType_type; +extern entity* IfcAnnotation_type; +extern entity* IfcAnnotationFillArea_type; +extern entity* IfcApplication_type; +extern entity* IfcAppliedValue_type; +extern entity* IfcApproval_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* IfcAudioVisualAppliance_type; +extern entity* IfcAudioVisualApplianceType_type; +extern entity* IfcAxis1Placement_type; +extern entity* IfcAxis2Placement2D_type; +extern entity* IfcAxis2Placement3D_type; +extern entity* IfcBSplineCurve_type; +extern entity* IfcBSplineCurveWithKnots_type; +extern entity* IfcBSplineSurface_type; +extern entity* IfcBSplineSurfaceWithKnots_type; +extern entity* IfcBeam_type; +extern entity* IfcBeamStandardCase_type; +extern entity* IfcBeamType_type; +extern entity* IfcBlobTexture_type; +extern entity* IfcBlock_type; +extern entity* IfcBoiler_type; +extern entity* IfcBoilerType_type; +extern entity* IfcBooleanClippingResult_type; +extern entity* IfcBooleanResult_type; +extern entity* IfcBoundaryCondition_type; +extern entity* IfcBoundaryCurve_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* IfcBuildingElementPart_type; +extern entity* IfcBuildingElementPartType_type; +extern entity* IfcBuildingElementProxy_type; +extern entity* IfcBuildingElementProxyType_type; +extern entity* IfcBuildingElementType_type; +extern entity* IfcBuildingStorey_type; +extern entity* IfcBuildingSystem_type; +extern entity* IfcBurner_type; +extern entity* IfcBurnerType_type; +extern entity* IfcCShapeProfileDef_type; +extern entity* IfcCableCarrierFitting_type; +extern entity* IfcCableCarrierFittingType_type; +extern entity* IfcCableCarrierSegment_type; +extern entity* IfcCableCarrierSegmentType_type; +extern entity* IfcCableFitting_type; +extern entity* IfcCableFittingType_type; +extern entity* IfcCableSegment_type; +extern entity* IfcCableSegmentType_type; +extern entity* IfcCartesianPoint_type; +extern entity* IfcCartesianPointList_type; +extern entity* IfcCartesianPointList3D_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* IfcChiller_type; +extern entity* IfcChillerType_type; +extern entity* IfcChimney_type; +extern entity* IfcChimneyType_type; +extern entity* IfcCircle_type; +extern entity* IfcCircleHollowProfileDef_type; +extern entity* IfcCircleProfileDef_type; +extern entity* IfcCivilElement_type; +extern entity* IfcCivilElementType_type; +extern entity* IfcClassification_type; +extern entity* IfcClassificationReference_type; +extern entity* IfcClosedShell_type; +extern entity* IfcCoil_type; +extern entity* IfcCoilType_type; +extern entity* IfcColourRgb_type; +extern entity* IfcColourRgbList_type; +extern entity* IfcColourSpecification_type; +extern entity* IfcColumn_type; +extern entity* IfcColumnStandardCase_type; +extern entity* IfcColumnType_type; +extern entity* IfcCommunicationsAppliance_type; +extern entity* IfcCommunicationsApplianceType_type; +extern entity* IfcComplexProperty_type; +extern entity* IfcComplexPropertyTemplate_type; +extern entity* IfcCompositeCurve_type; +extern entity* IfcCompositeCurveOnSurface_type; +extern entity* IfcCompositeCurveSegment_type; +extern entity* IfcCompositeProfileDef_type; +extern entity* IfcCompressor_type; +extern entity* IfcCompressorType_type; +extern entity* IfcCondenser_type; +extern entity* IfcCondenserType_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* IfcConnectionSurfaceGeometry_type; +extern entity* IfcConnectionVolumeGeometry_type; +extern entity* IfcConstraint_type; +extern entity* IfcConstructionEquipmentResource_type; +extern entity* IfcConstructionEquipmentResourceType_type; +extern entity* IfcConstructionMaterialResource_type; +extern entity* IfcConstructionMaterialResourceType_type; +extern entity* IfcConstructionProductResource_type; +extern entity* IfcConstructionProductResourceType_type; +extern entity* IfcConstructionResource_type; +extern entity* IfcConstructionResourceType_type; +extern entity* IfcContext_type; +extern entity* IfcContextDependentUnit_type; +extern entity* IfcControl_type; +extern entity* IfcController_type; +extern entity* IfcControllerType_type; +extern entity* IfcConversionBasedUnit_type; +extern entity* IfcConversionBasedUnitWithOffset_type; +extern entity* IfcCooledBeam_type; +extern entity* IfcCooledBeamType_type; +extern entity* IfcCoolingTower_type; +extern entity* IfcCoolingTowerType_type; +extern entity* IfcCoordinateOperation_type; +extern entity* IfcCoordinateReferenceSystem_type; +extern entity* IfcCostItem_type; +extern entity* IfcCostSchedule_type; +extern entity* IfcCostValue_type; +extern entity* IfcCovering_type; +extern entity* IfcCoveringType_type; +extern entity* IfcCrewResource_type; +extern entity* IfcCrewResourceType_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* IfcCurveBoundedSurface_type; +extern entity* IfcCurveStyle_type; +extern entity* IfcCurveStyleFont_type; +extern entity* IfcCurveStyleFontAndScaling_type; +extern entity* IfcCurveStyleFontPattern_type; +extern entity* IfcCylindricalSurface_type; +extern entity* IfcDamper_type; +extern entity* IfcDamperType_type; +extern entity* IfcDerivedProfileDef_type; +extern entity* IfcDerivedUnit_type; +extern entity* IfcDerivedUnitElement_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* IfcDistributionCircuit_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* IfcDistributionSystem_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* IfcDoorStandardCase_type; +extern entity* IfcDoorStyle_type; +extern entity* IfcDoorType_type; +extern entity* IfcDraughtingPreDefinedColour_type; +extern entity* IfcDraughtingPreDefinedCurveFont_type; +extern entity* IfcDuctFitting_type; +extern entity* IfcDuctFittingType_type; +extern entity* IfcDuctSegment_type; +extern entity* IfcDuctSegmentType_type; +extern entity* IfcDuctSilencer_type; +extern entity* IfcDuctSilencerType_type; +extern entity* IfcEdge_type; +extern entity* IfcEdgeCurve_type; +extern entity* IfcEdgeLoop_type; +extern entity* IfcElectricAppliance_type; +extern entity* IfcElectricApplianceType_type; +extern entity* IfcElectricDistributionBoard_type; +extern entity* IfcElectricDistributionBoardType_type; +extern entity* IfcElectricFlowStorageDevice_type; +extern entity* IfcElectricFlowStorageDeviceType_type; +extern entity* IfcElectricGenerator_type; +extern entity* IfcElectricGeneratorType_type; +extern entity* IfcElectricMotor_type; +extern entity* IfcElectricMotorType_type; +extern entity* IfcElectricTimeControl_type; +extern entity* IfcElectricTimeControlType_type; +extern entity* IfcElement_type; +extern entity* IfcElementAssembly_type; +extern entity* IfcElementAssemblyType_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* IfcEngine_type; +extern entity* IfcEngineType_type; +extern entity* IfcEvaporativeCooler_type; +extern entity* IfcEvaporativeCoolerType_type; +extern entity* IfcEvaporator_type; +extern entity* IfcEvaporatorType_type; +extern entity* IfcEvent_type; +extern entity* IfcEventTime_type; +extern entity* IfcEventType_type; +extern entity* IfcExtendedProperties_type; +extern entity* IfcExternalInformation_type; +extern entity* IfcExternalReference_type; +extern entity* IfcExternalReferenceRelationship_type; +extern entity* IfcExternalSpatialElement_type; +extern entity* IfcExternalSpatialStructureElement_type; +extern entity* IfcExternallyDefinedHatchStyle_type; +extern entity* IfcExternallyDefinedSurfaceStyle_type; +extern entity* IfcExternallyDefinedTextFont_type; +extern entity* IfcExtrudedAreaSolid_type; +extern entity* IfcExtrudedAreaSolidTapered_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* IfcFan_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* IfcFillAreaStyleTiles_type; +extern entity* IfcFilter_type; +extern entity* IfcFilterType_type; +extern entity* IfcFireSuppressionTerminal_type; +extern entity* IfcFireSuppressionTerminalType_type; +extern entity* IfcFixedReferenceSweptAreaSolid_type; +extern entity* IfcFlowController_type; +extern entity* IfcFlowControllerType_type; +extern entity* IfcFlowFitting_type; +extern entity* IfcFlowFittingType_type; +extern entity* IfcFlowInstrument_type; +extern entity* IfcFlowInstrumentType_type; +extern entity* IfcFlowMeter_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* IfcFooting_type; +extern entity* IfcFootingType_type; +extern entity* IfcFurnishingElement_type; +extern entity* IfcFurnishingElementType_type; +extern entity* IfcFurniture_type; +extern entity* IfcFurnitureType_type; +extern entity* IfcGeographicElement_type; +extern entity* IfcGeographicElementType_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* IfcHeatExchanger_type; +extern entity* IfcHeatExchangerType_type; +extern entity* IfcHumidifier_type; +extern entity* IfcHumidifierType_type; +extern entity* IfcIShapeProfileDef_type; +extern entity* IfcImageTexture_type; +extern entity* IfcIndexedColourMap_type; +extern entity* IfcIndexedTextureMap_type; +extern entity* IfcIndexedTriangleTextureMap_type; +extern entity* IfcInterceptor_type; +extern entity* IfcInterceptorType_type; +extern entity* IfcInventory_type; +extern entity* IfcIrregularTimeSeries_type; +extern entity* IfcIrregularTimeSeriesValue_type; +extern entity* IfcJunctionBox_type; +extern entity* IfcJunctionBoxType_type; +extern entity* IfcLShapeProfileDef_type; +extern entity* IfcLaborResource_type; +extern entity* IfcLaborResourceType_type; +extern entity* IfcLagTime_type; +extern entity* IfcLamp_type; +extern entity* IfcLampType_type; +extern entity* IfcLibraryInformation_type; +extern entity* IfcLibraryReference_type; +extern entity* IfcLightDistributionData_type; +extern entity* IfcLightFixture_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* IfcLocalPlacement_type; +extern entity* IfcLoop_type; +extern entity* IfcManifoldSolidBrep_type; +extern entity* IfcMapConversion_type; +extern entity* IfcMappedItem_type; +extern entity* IfcMaterial_type; +extern entity* IfcMaterialClassificationRelationship_type; +extern entity* IfcMaterialConstituent_type; +extern entity* IfcMaterialConstituentSet_type; +extern entity* IfcMaterialDefinition_type; +extern entity* IfcMaterialDefinitionRepresentation_type; +extern entity* IfcMaterialLayer_type; +extern entity* IfcMaterialLayerSet_type; +extern entity* IfcMaterialLayerSetUsage_type; +extern entity* IfcMaterialLayerWithOffsets_type; +extern entity* IfcMaterialList_type; +extern entity* IfcMaterialProfile_type; +extern entity* IfcMaterialProfileSet_type; +extern entity* IfcMaterialProfileSetUsage_type; +extern entity* IfcMaterialProfileSetUsageTapering_type; +extern entity* IfcMaterialProfileWithOffsets_type; +extern entity* IfcMaterialProperties_type; +extern entity* IfcMaterialRelationship_type; +extern entity* IfcMaterialUsageDefinition_type; +extern entity* IfcMeasureWithUnit_type; +extern entity* IfcMechanicalFastener_type; +extern entity* IfcMechanicalFastenerType_type; +extern entity* IfcMedicalDevice_type; +extern entity* IfcMedicalDeviceType_type; +extern entity* IfcMember_type; +extern entity* IfcMemberStandardCase_type; +extern entity* IfcMemberType_type; +extern entity* IfcMetric_type; +extern entity* IfcMirroredProfileDef_type; +extern entity* IfcMonetaryUnit_type; +extern entity* IfcMotorConnection_type; +extern entity* IfcMotorConnectionType_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* IfcOpenShell_type; +extern entity* IfcOpeningElement_type; +extern entity* IfcOpeningStandardCase_type; +extern entity* IfcOrganization_type; +extern entity* IfcOrganizationRelationship_type; +extern entity* IfcOrientedEdge_type; +extern entity* IfcOuterBoundaryCurve_type; +extern entity* IfcOutlet_type; +extern entity* IfcOutletType_type; +extern entity* IfcOwnerHistory_type; +extern entity* IfcParameterizedProfileDef_type; +extern entity* IfcPath_type; +extern entity* IfcPcurve_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* IfcPileType_type; +extern entity* IfcPipeFitting_type; +extern entity* IfcPipeFittingType_type; +extern entity* IfcPipeSegment_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* IfcPlateStandardCase_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* IfcPreDefinedItem_type; +extern entity* IfcPreDefinedProperties_type; +extern entity* IfcPreDefinedPropertySet_type; +extern entity* IfcPreDefinedTextFont_type; +extern entity* IfcPresentationItem_type; +extern entity* IfcPresentationLayerAssignment_type; +extern entity* IfcPresentationLayerWithStyle_type; +extern entity* IfcPresentationStyle_type; +extern entity* IfcPresentationStyleAssignment_type; +extern entity* IfcProcedure_type; +extern entity* IfcProcedureType_type; +extern entity* IfcProcess_type; +extern entity* IfcProduct_type; +extern entity* IfcProductDefinitionShape_type; +extern entity* IfcProductRepresentation_type; +extern entity* IfcProfileDef_type; +extern entity* IfcProfileProperties_type; +extern entity* IfcProject_type; +extern entity* IfcProjectLibrary_type; +extern entity* IfcProjectOrder_type; +extern entity* IfcProjectedCRS_type; +extern entity* IfcProjectionElement_type; +extern entity* IfcProperty_type; +extern entity* IfcPropertyAbstraction_type; +extern entity* IfcPropertyBoundedValue_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* IfcPropertySetTemplate_type; +extern entity* IfcPropertySingleValue_type; +extern entity* IfcPropertyTableValue_type; +extern entity* IfcPropertyTemplate_type; +extern entity* IfcPropertyTemplateDefinition_type; +extern entity* IfcProtectiveDevice_type; +extern entity* IfcProtectiveDeviceTrippingUnit_type; +extern entity* IfcProtectiveDeviceTrippingUnitType_type; +extern entity* IfcProtectiveDeviceType_type; +extern entity* IfcProxy_type; +extern entity* IfcPump_type; +extern entity* IfcPumpType_type; +extern entity* IfcQuantityArea_type; +extern entity* IfcQuantityCount_type; +extern entity* IfcQuantityLength_type; +extern entity* IfcQuantitySet_type; +extern entity* IfcQuantityTime_type; +extern entity* IfcQuantityVolume_type; +extern entity* IfcQuantityWeight_type; +extern entity* IfcRailing_type; +extern entity* IfcRailingType_type; +extern entity* IfcRamp_type; +extern entity* IfcRampFlight_type; +extern entity* IfcRampFlightType_type; +extern entity* IfcRampType_type; +extern entity* IfcRationalBSplineCurveWithKnots_type; +extern entity* IfcRationalBSplineSurfaceWithKnots_type; +extern entity* IfcRectangleHollowProfileDef_type; +extern entity* IfcRectangleProfileDef_type; +extern entity* IfcRectangularPyramid_type; +extern entity* IfcRectangularTrimmedSurface_type; +extern entity* IfcRecurrencePattern_type; +extern entity* IfcReference_type; +extern entity* IfcRegularTimeSeries_type; +extern entity* IfcReinforcementBarProperties_type; +extern entity* IfcReinforcementDefinitionProperties_type; +extern entity* IfcReinforcingBar_type; +extern entity* IfcReinforcingBarType_type; +extern entity* IfcReinforcingElement_type; +extern entity* IfcReinforcingElementType_type; +extern entity* IfcReinforcingMesh_type; +extern entity* IfcReinforcingMeshType_type; +extern entity* IfcRelAggregates_type; +extern entity* IfcRelAssigns_type; +extern entity* IfcRelAssignsToActor_type; +extern entity* IfcRelAssignsToControl_type; +extern entity* IfcRelAssignsToGroup_type; +extern entity* IfcRelAssignsToGroupByFactor_type; +extern entity* IfcRelAssignsToProcess_type; +extern entity* IfcRelAssignsToProduct_type; +extern entity* IfcRelAssignsToResource_type; +extern entity* IfcRelAssociates_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* IfcRelConnects_type; +extern entity* IfcRelConnectsElements_type; +extern entity* IfcRelConnectsPathElements_type; +extern entity* IfcRelConnectsPortToElement_type; +extern entity* IfcRelConnectsPorts_type; +extern entity* IfcRelConnectsStructuralActivity_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* IfcRelDeclares_type; +extern entity* IfcRelDecomposes_type; +extern entity* IfcRelDefines_type; +extern entity* IfcRelDefinesByObject_type; +extern entity* IfcRelDefinesByProperties_type; +extern entity* IfcRelDefinesByTemplate_type; +extern entity* IfcRelDefinesByType_type; +extern entity* IfcRelFillsElement_type; +extern entity* IfcRelFlowControlElements_type; +extern entity* IfcRelInterferesElements_type; +extern entity* IfcRelNests_type; +extern entity* IfcRelProjectsElement_type; +extern entity* IfcRelReferencedInSpatialStructure_type; +extern entity* IfcRelSequence_type; +extern entity* IfcRelServicesBuildings_type; +extern entity* IfcRelSpaceBoundary_type; +extern entity* IfcRelSpaceBoundary1stLevel_type; +extern entity* IfcRelSpaceBoundary2ndLevel_type; +extern entity* IfcRelVoidsElement_type; +extern entity* IfcRelationship_type; +extern entity* IfcReparametrisedCompositeCurveSegment_type; +extern entity* IfcRepresentation_type; +extern entity* IfcRepresentationContext_type; +extern entity* IfcRepresentationItem_type; +extern entity* IfcRepresentationMap_type; +extern entity* IfcResource_type; +extern entity* IfcResourceApprovalRelationship_type; +extern entity* IfcResourceConstraintRelationship_type; +extern entity* IfcResourceLevelRelationship_type; +extern entity* IfcResourceTime_type; +extern entity* IfcRevolvedAreaSolid_type; +extern entity* IfcRevolvedAreaSolidTapered_type; +extern entity* IfcRightCircularCone_type; +extern entity* IfcRightCircularCylinder_type; +extern entity* IfcRoof_type; +extern entity* IfcRoofType_type; +extern entity* IfcRoot_type; +extern entity* IfcRoundedRectangleProfileDef_type; +extern entity* IfcSIUnit_type; +extern entity* IfcSanitaryTerminal_type; +extern entity* IfcSanitaryTerminalType_type; +extern entity* IfcSchedulingTime_type; +extern entity* IfcSectionProperties_type; +extern entity* IfcSectionReinforcementProperties_type; +extern entity* IfcSectionedSpine_type; +extern entity* IfcSensor_type; +extern entity* IfcSensorType_type; +extern entity* IfcShadingDevice_type; +extern entity* IfcShadingDeviceType_type; +extern entity* IfcShapeAspect_type; +extern entity* IfcShapeModel_type; +extern entity* IfcShapeRepresentation_type; +extern entity* IfcShellBasedSurfaceModel_type; +extern entity* IfcSimpleProperty_type; +extern entity* IfcSimplePropertyTemplate_type; +extern entity* IfcSite_type; +extern entity* IfcSlab_type; +extern entity* IfcSlabElementedCase_type; +extern entity* IfcSlabStandardCase_type; +extern entity* IfcSlabType_type; +extern entity* IfcSlippageConnectionCondition_type; +extern entity* IfcSolarDevice_type; +extern entity* IfcSolarDeviceType_type; +extern entity* IfcSolidModel_type; +extern entity* IfcSpace_type; +extern entity* IfcSpaceHeater_type; +extern entity* IfcSpaceHeaterType_type; +extern entity* IfcSpaceType_type; +extern entity* IfcSpatialElement_type; +extern entity* IfcSpatialElementType_type; +extern entity* IfcSpatialStructureElement_type; +extern entity* IfcSpatialStructureElementType_type; +extern entity* IfcSpatialZone_type; +extern entity* IfcSpatialZoneType_type; +extern entity* IfcSphere_type; +extern entity* IfcStackTerminal_type; +extern entity* IfcStackTerminalType_type; +extern entity* IfcStair_type; +extern entity* IfcStairFlight_type; +extern entity* IfcStairFlightType_type; +extern entity* IfcStairType_type; +extern entity* IfcStructuralAction_type; +extern entity* IfcStructuralActivity_type; +extern entity* IfcStructuralAnalysisModel_type; +extern entity* IfcStructuralConnection_type; +extern entity* IfcStructuralConnectionCondition_type; +extern entity* IfcStructuralCurveAction_type; +extern entity* IfcStructuralCurveConnection_type; +extern entity* IfcStructuralCurveMember_type; +extern entity* IfcStructuralCurveMemberVarying_type; +extern entity* IfcStructuralCurveReaction_type; +extern entity* IfcStructuralItem_type; +extern entity* IfcStructuralLinearAction_type; +extern entity* IfcStructuralLoad_type; +extern entity* IfcStructuralLoadCase_type; +extern entity* IfcStructuralLoadConfiguration_type; +extern entity* IfcStructuralLoadGroup_type; +extern entity* IfcStructuralLoadLinearForce_type; +extern entity* IfcStructuralLoadOrResult_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* IfcStructuralPointAction_type; +extern entity* IfcStructuralPointConnection_type; +extern entity* IfcStructuralPointReaction_type; +extern entity* IfcStructuralReaction_type; +extern entity* IfcStructuralResultGroup_type; +extern entity* IfcStructuralSurfaceAction_type; +extern entity* IfcStructuralSurfaceConnection_type; +extern entity* IfcStructuralSurfaceMember_type; +extern entity* IfcStructuralSurfaceMemberVarying_type; +extern entity* IfcStructuralSurfaceReaction_type; +extern entity* IfcStyleModel_type; +extern entity* IfcStyledItem_type; +extern entity* IfcStyledRepresentation_type; +extern entity* IfcSubContractResource_type; +extern entity* IfcSubContractResourceType_type; +extern entity* IfcSubedge_type; +extern entity* IfcSurface_type; +extern entity* IfcSurfaceCurveSweptAreaSolid_type; +extern entity* IfcSurfaceFeature_type; +extern entity* IfcSurfaceOfLinearExtrusion_type; +extern entity* IfcSurfaceOfRevolution_type; +extern entity* IfcSurfaceReinforcementArea_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* IfcSweptDiskSolidPolygonal_type; +extern entity* IfcSweptSurface_type; +extern entity* IfcSwitchingDevice_type; +extern entity* IfcSwitchingDeviceType_type; +extern entity* IfcSystem_type; +extern entity* IfcSystemFurnitureElement_type; +extern entity* IfcSystemFurnitureElementType_type; +extern entity* IfcTShapeProfileDef_type; +extern entity* IfcTable_type; +extern entity* IfcTableColumn_type; +extern entity* IfcTableRow_type; +extern entity* IfcTank_type; +extern entity* IfcTankType_type; +extern entity* IfcTask_type; +extern entity* IfcTaskTime_type; +extern entity* IfcTaskTimeRecurring_type; +extern entity* IfcTaskType_type; +extern entity* IfcTelecomAddress_type; +extern entity* IfcTendon_type; +extern entity* IfcTendonAnchor_type; +extern entity* IfcTendonAnchorType_type; +extern entity* IfcTendonType_type; +extern entity* IfcTessellatedFaceSet_type; +extern entity* IfcTessellatedItem_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* IfcTextureCoordinate_type; +extern entity* IfcTextureCoordinateGenerator_type; +extern entity* IfcTextureMap_type; +extern entity* IfcTextureVertex_type; +extern entity* IfcTextureVertexList_type; +extern entity* IfcTimePeriod_type; +extern entity* IfcTimeSeries_type; +extern entity* IfcTimeSeriesValue_type; +extern entity* IfcTopologicalRepresentationItem_type; +extern entity* IfcTopologyRepresentation_type; +extern entity* IfcTransformer_type; +extern entity* IfcTransformerType_type; +extern entity* IfcTransportElement_type; +extern entity* IfcTransportElementType_type; +extern entity* IfcTrapeziumProfileDef_type; +extern entity* IfcTriangulatedFaceSet_type; +extern entity* IfcTrimmedCurve_type; +extern entity* IfcTubeBundle_type; +extern entity* IfcTubeBundleType_type; +extern entity* IfcTypeObject_type; +extern entity* IfcTypeProcess_type; +extern entity* IfcTypeProduct_type; +extern entity* IfcTypeResource_type; +extern entity* IfcUShapeProfileDef_type; +extern entity* IfcUnitAssignment_type; +extern entity* IfcUnitaryControlElement_type; +extern entity* IfcUnitaryControlElementType_type; +extern entity* IfcUnitaryEquipment_type; +extern entity* IfcUnitaryEquipmentType_type; +extern entity* IfcValve_type; +extern entity* IfcValveType_type; +extern entity* IfcVector_type; +extern entity* IfcVertex_type; +extern entity* IfcVertexLoop_type; +extern entity* IfcVertexPoint_type; +extern entity* IfcVibrationIsolator_type; +extern entity* IfcVibrationIsolatorType_type; +extern entity* IfcVirtualElement_type; +extern entity* IfcVirtualGridIntersection_type; +extern entity* IfcVoidingFeature_type; +extern entity* IfcWall_type; +extern entity* IfcWallElementedCase_type; +extern entity* IfcWallStandardCase_type; +extern entity* IfcWallType_type; +extern entity* IfcWasteTerminal_type; +extern entity* IfcWasteTerminalType_type; +extern entity* IfcWindow_type; +extern entity* IfcWindowLiningProperties_type; +extern entity* IfcWindowPanelProperties_type; +extern entity* IfcWindowStandardCase_type; +extern entity* IfcWindowStyle_type; +extern entity* IfcWindowType_type; +extern entity* IfcWorkCalendar_type; +extern entity* IfcWorkControl_type; +extern entity* IfcWorkPlan_type; +extern entity* IfcWorkSchedule_type; +extern entity* IfcWorkTime_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* IfcAreaDensityMeasure_type; +extern type_declaration* IfcAreaMeasure_type; +extern type_declaration* IfcBoolean_type; +extern type_declaration* IfcBoxAlignment_type; +extern type_declaration* IfcCardinalPointReference_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* IfcDate_type; +extern type_declaration* IfcDateTime_type; +extern type_declaration* IfcDayInMonthNumber_type; +extern type_declaration* IfcDayInWeekNumber_type; +extern type_declaration* IfcDescriptiveMeasure_type; +extern type_declaration* IfcDimensionCount_type; +extern type_declaration* IfcDoseEquivalentMeasure_type; +extern type_declaration* IfcDuration_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* 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* IfcLanguageId_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* 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* IfcNonNegativeLengthMeasure_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* IfcPropertySetDefinitionSet_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* IfcSectionModulusMeasure_type; +extern type_declaration* IfcSectionalAreaIntegralMeasure_type; +extern type_declaration* IfcShearModulusMeasure_type; +extern type_declaration* IfcSolidAngleMeasure_type; +extern type_declaration* IfcSoundPowerLevelMeasure_type; +extern type_declaration* IfcSoundPowerMeasure_type; +extern type_declaration* IfcSoundPressureLevelMeasure_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* IfcTemperatureRateOfChangeMeasure_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* IfcTime_type; +extern type_declaration* IfcTimeMeasure_type; +extern type_declaration* IfcTimeStamp_type; +extern type_declaration* IfcTorqueMeasure_type; +extern type_declaration* IfcURIReference_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; + IfcUtil::IfcBaseClass* Ifc4::SchemaEntity(IfcAbstractEntity* e) { switch(e->type()) { case Type::IfcAbsorbedDoseMeasure: return new IfcAbsorbedDoseMeasure(e); break; @@ -6510,10537 +7405,10925 @@ IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum IfcWorkScheduleTypeEnum::FromSt // Function implementations for IfcAbsorbedDoseMeasure -IfcUtil::ArgumentType IfcAbsorbedDoseMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::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 IfcAreaDensityMeasure -IfcUtil::ArgumentType IfcAreaDensityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcAreaDensityMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcAreaDensityMeasure::is(Type::Enum v) const { return v == IfcAreaDensityMeasure::Class(); } -Type::Enum IfcAreaDensityMeasure::type() const { return Type::IfcAreaDensityMeasure; } Type::Enum IfcAreaDensityMeasure::Class() { return Type::IfcAreaDensityMeasure; } -IfcAreaDensityMeasure::IfcAreaDensityMeasure(IfcAbstractEntity* e) { entity = e; } -IfcAreaDensityMeasure::IfcAreaDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAreaDensityMeasure); e->setArgument(0, v); entity = e; } -IfcAreaDensityMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcAreaDensityMeasure::declaration() const { return *IfcAreaDensityMeasure_type; } +IfcAreaDensityMeasure::IfcAreaDensityMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcAreaDensityMeasure::IfcAreaDensityMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcAreaDensityMeasure); e->setArgument(0, v); data_ = e; } +IfcAreaDensityMeasure::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 IfcCardinalPointReference -IfcUtil::ArgumentType IfcCardinalPointReference::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcCardinalPointReference::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcCardinalPointReference::is(Type::Enum v) const { return v == IfcCardinalPointReference::Class(); } -Type::Enum IfcCardinalPointReference::type() const { return Type::IfcCardinalPointReference; } Type::Enum IfcCardinalPointReference::Class() { return Type::IfcCardinalPointReference; } -IfcCardinalPointReference::IfcCardinalPointReference(IfcAbstractEntity* e) { entity = e; } -IfcCardinalPointReference::IfcCardinalPointReference(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCardinalPointReference); e->setArgument(0, v); entity = e; } -IfcCardinalPointReference::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcCardinalPointReference::declaration() const { return *IfcCardinalPointReference_type; } +IfcCardinalPointReference::IfcCardinalPointReference(IfcAbstractEntity* e) { data_ = e; } +IfcCardinalPointReference::IfcCardinalPointReference(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcCardinalPointReference); e->setArgument(0, v); data_ = e; } +IfcCardinalPointReference::operator int() 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 IfcDate -IfcUtil::ArgumentType IfcDate::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDate::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDate::is(Type::Enum v) const { return v == IfcDate::Class(); } -Type::Enum IfcDate::type() const { return Type::IfcDate; } Type::Enum IfcDate::Class() { return Type::IfcDate; } -IfcDate::IfcDate(IfcAbstractEntity* e) { entity = e; } -IfcDate::IfcDate(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDate); e->setArgument(0, v); entity = e; } -IfcDate::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDate::declaration() const { return *IfcDate_type; } +IfcDate::IfcDate(IfcAbstractEntity* e) { data_ = e; } +IfcDate::IfcDate(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDate); e->setArgument(0, v); data_ = e; } +IfcDate::operator std::string() const { return *data_->getArgument(0); } // Function implementations for IfcDateTime -IfcUtil::ArgumentType IfcDateTime::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDateTime::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDateTime::is(Type::Enum v) const { return v == IfcDateTime::Class(); } -Type::Enum IfcDateTime::type() const { return Type::IfcDateTime; } Type::Enum IfcDateTime::Class() { return Type::IfcDateTime; } -IfcDateTime::IfcDateTime(IfcAbstractEntity* e) { entity = e; } -IfcDateTime::IfcDateTime(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDateTime); e->setArgument(0, v); entity = e; } -IfcDateTime::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDateTime::declaration() const { return *IfcDateTime_type; } +IfcDateTime::IfcDateTime(IfcAbstractEntity* e) { data_ = e; } +IfcDateTime::IfcDateTime(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDateTime); e->setArgument(0, v); data_ = e; } +IfcDateTime::operator std::string() 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 IfcDayInWeekNumber -IfcUtil::ArgumentType IfcDayInWeekNumber::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_INT; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDayInWeekNumber::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDayInWeekNumber::is(Type::Enum v) const { return v == IfcDayInWeekNumber::Class(); } -Type::Enum IfcDayInWeekNumber::type() const { return Type::IfcDayInWeekNumber; } Type::Enum IfcDayInWeekNumber::Class() { return Type::IfcDayInWeekNumber; } -IfcDayInWeekNumber::IfcDayInWeekNumber(IfcAbstractEntity* e) { entity = e; } -IfcDayInWeekNumber::IfcDayInWeekNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDayInWeekNumber); e->setArgument(0, v); entity = e; } -IfcDayInWeekNumber::operator int() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDayInWeekNumber::declaration() const { return *IfcDayInWeekNumber_type; } +IfcDayInWeekNumber::IfcDayInWeekNumber(IfcAbstractEntity* e) { data_ = e; } +IfcDayInWeekNumber::IfcDayInWeekNumber(int v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDayInWeekNumber); e->setArgument(0, v); data_ = e; } +IfcDayInWeekNumber::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 IfcDuration -IfcUtil::ArgumentType IfcDuration::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcDuration::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcDuration::is(Type::Enum v) const { return v == IfcDuration::Class(); } -Type::Enum IfcDuration::type() const { return Type::IfcDuration; } Type::Enum IfcDuration::Class() { return Type::IfcDuration; } -IfcDuration::IfcDuration(IfcAbstractEntity* e) { entity = e; } -IfcDuration::IfcDuration(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDuration); e->setArgument(0, v); entity = e; } -IfcDuration::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcDuration::declaration() const { return *IfcDuration_type; } +IfcDuration::IfcDuration(IfcAbstractEntity* e) { data_ = e; } +IfcDuration::IfcDuration(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcDuration); e->setArgument(0, v); data_ = e; } +IfcDuration::operator std::string() 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 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 IfcLanguageId -IfcUtil::ArgumentType IfcLanguageId::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcLanguageId::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcLanguageId::is(Type::Enum v) const { return v == Type::IfcLanguageId || IfcIdentifier::is(v); } -Type::Enum IfcLanguageId::type() const { return Type::IfcLanguageId; } Type::Enum IfcLanguageId::Class() { return Type::IfcLanguageId; } -IfcLanguageId::IfcLanguageId(IfcAbstractEntity* e) : IfcIdentifier((IfcAbstractEntity*)0) { entity = e; } -IfcLanguageId::IfcLanguageId(std::string v) : IfcIdentifier((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLanguageId); e->setArgument(0, v); entity = e; } -IfcLanguageId::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcLanguageId::declaration() const { return *IfcLanguageId_type; } +IfcLanguageId::IfcLanguageId(IfcAbstractEntity* e) : IfcIdentifier((IfcAbstractEntity*)0) { data_ = e; } +IfcLanguageId::IfcLanguageId(std::string v) : IfcIdentifier((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcLanguageId); e->setArgument(0, v); data_ = e; } +IfcLanguageId::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 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 IfcNonNegativeLengthMeasure -IfcUtil::ArgumentType IfcNonNegativeLengthMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcNonNegativeLengthMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcNonNegativeLengthMeasure::is(Type::Enum v) const { return v == Type::IfcNonNegativeLengthMeasure || IfcLengthMeasure::is(v); } -Type::Enum IfcNonNegativeLengthMeasure::type() const { return Type::IfcNonNegativeLengthMeasure; } Type::Enum IfcNonNegativeLengthMeasure::Class() { return Type::IfcNonNegativeLengthMeasure; } -IfcNonNegativeLengthMeasure::IfcNonNegativeLengthMeasure(IfcAbstractEntity* e) : IfcLengthMeasure((IfcAbstractEntity*)0) { entity = e; } -IfcNonNegativeLengthMeasure::IfcNonNegativeLengthMeasure(double v) : IfcLengthMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcNonNegativeLengthMeasure); e->setArgument(0, v); entity = e; } -IfcNonNegativeLengthMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcNonNegativeLengthMeasure::declaration() const { return *IfcNonNegativeLengthMeasure_type; } +IfcNonNegativeLengthMeasure::IfcNonNegativeLengthMeasure(IfcAbstractEntity* e) : IfcLengthMeasure((IfcAbstractEntity*)0) { data_ = e; } +IfcNonNegativeLengthMeasure::IfcNonNegativeLengthMeasure(double v) : IfcLengthMeasure((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcNonNegativeLengthMeasure); e->setArgument(0, v); data_ = e; } +IfcNonNegativeLengthMeasure::operator double() 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 IfcPropertySetDefinitionSet -IfcUtil::ArgumentType IfcPropertySetDefinitionSet::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_ENTITY_INSTANCE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcPropertySetDefinitionSet::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcPropertySetDefinitionSet::is(Type::Enum v) const { return v == IfcPropertySetDefinitionSet::Class(); } -Type::Enum IfcPropertySetDefinitionSet::type() const { return Type::IfcPropertySetDefinitionSet; } Type::Enum IfcPropertySetDefinitionSet::Class() { return Type::IfcPropertySetDefinitionSet; } -IfcPropertySetDefinitionSet::IfcPropertySetDefinitionSet(IfcAbstractEntity* e) { entity = e; } -IfcPropertySetDefinitionSet::IfcPropertySetDefinitionSet(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPropertySetDefinitionSet); e->setArgument(0, v->generalize()); entity = e; } -IfcPropertySetDefinitionSet::operator IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } +const IfcParse::type_declaration& IfcPropertySetDefinitionSet::declaration() const { return *IfcPropertySetDefinitionSet_type; } +IfcPropertySetDefinitionSet::IfcPropertySetDefinitionSet(IfcAbstractEntity* e) { data_ = e; } +IfcPropertySetDefinitionSet::IfcPropertySetDefinitionSet(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcPropertySetDefinitionSet); e->setArgument(0, v->generalize()); data_ = e; } +IfcPropertySetDefinitionSet::operator IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } // Function implementations for IfcRadioActivityMeasure -IfcUtil::ArgumentType IfcRadioActivityMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::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 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 IfcSoundPowerLevelMeasure -IfcUtil::ArgumentType IfcSoundPowerLevelMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSoundPowerLevelMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSoundPowerLevelMeasure::is(Type::Enum v) const { return v == IfcSoundPowerLevelMeasure::Class(); } -Type::Enum IfcSoundPowerLevelMeasure::type() const { return Type::IfcSoundPowerLevelMeasure; } Type::Enum IfcSoundPowerLevelMeasure::Class() { return Type::IfcSoundPowerLevelMeasure; } -IfcSoundPowerLevelMeasure::IfcSoundPowerLevelMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSoundPowerLevelMeasure::IfcSoundPowerLevelMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPowerLevelMeasure); e->setArgument(0, v); entity = e; } -IfcSoundPowerLevelMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSoundPowerLevelMeasure::declaration() const { return *IfcSoundPowerLevelMeasure_type; } +IfcSoundPowerLevelMeasure::IfcSoundPowerLevelMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSoundPowerLevelMeasure::IfcSoundPowerLevelMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPowerLevelMeasure); e->setArgument(0, v); data_ = e; } +IfcSoundPowerLevelMeasure::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 IfcSoundPressureLevelMeasure -IfcUtil::ArgumentType IfcSoundPressureLevelMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcSoundPressureLevelMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcSoundPressureLevelMeasure::is(Type::Enum v) const { return v == IfcSoundPressureLevelMeasure::Class(); } -Type::Enum IfcSoundPressureLevelMeasure::type() const { return Type::IfcSoundPressureLevelMeasure; } Type::Enum IfcSoundPressureLevelMeasure::Class() { return Type::IfcSoundPressureLevelMeasure; } -IfcSoundPressureLevelMeasure::IfcSoundPressureLevelMeasure(IfcAbstractEntity* e) { entity = e; } -IfcSoundPressureLevelMeasure::IfcSoundPressureLevelMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPressureLevelMeasure); e->setArgument(0, v); entity = e; } -IfcSoundPressureLevelMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcSoundPressureLevelMeasure::declaration() const { return *IfcSoundPressureLevelMeasure_type; } +IfcSoundPressureLevelMeasure::IfcSoundPressureLevelMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcSoundPressureLevelMeasure::IfcSoundPressureLevelMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcSoundPressureLevelMeasure); e->setArgument(0, v); data_ = e; } +IfcSoundPressureLevelMeasure::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 IfcTemperatureRateOfChangeMeasure -IfcUtil::ArgumentType IfcTemperatureRateOfChangeMeasure::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_DOUBLE; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTemperatureRateOfChangeMeasure::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTemperatureRateOfChangeMeasure::is(Type::Enum v) const { return v == IfcTemperatureRateOfChangeMeasure::Class(); } -Type::Enum IfcTemperatureRateOfChangeMeasure::type() const { return Type::IfcTemperatureRateOfChangeMeasure; } Type::Enum IfcTemperatureRateOfChangeMeasure::Class() { return Type::IfcTemperatureRateOfChangeMeasure; } -IfcTemperatureRateOfChangeMeasure::IfcTemperatureRateOfChangeMeasure(IfcAbstractEntity* e) { entity = e; } -IfcTemperatureRateOfChangeMeasure::IfcTemperatureRateOfChangeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTemperatureRateOfChangeMeasure); e->setArgument(0, v); entity = e; } -IfcTemperatureRateOfChangeMeasure::operator double() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTemperatureRateOfChangeMeasure::declaration() const { return *IfcTemperatureRateOfChangeMeasure_type; } +IfcTemperatureRateOfChangeMeasure::IfcTemperatureRateOfChangeMeasure(IfcAbstractEntity* e) { data_ = e; } +IfcTemperatureRateOfChangeMeasure::IfcTemperatureRateOfChangeMeasure(double v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTemperatureRateOfChangeMeasure); e->setArgument(0, v); data_ = e; } +IfcTemperatureRateOfChangeMeasure::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 IfcTime -IfcUtil::ArgumentType IfcTime::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcTime::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcTime::is(Type::Enum v) const { return v == IfcTime::Class(); } -Type::Enum IfcTime::type() const { return Type::IfcTime; } Type::Enum IfcTime::Class() { return Type::IfcTime; } -IfcTime::IfcTime(IfcAbstractEntity* e) { entity = e; } -IfcTime::IfcTime(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTime); e->setArgument(0, v); entity = e; } -IfcTime::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcTime::declaration() const { return *IfcTime_type; } +IfcTime::IfcTime(IfcAbstractEntity* e) { data_ = e; } +IfcTime::IfcTime(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcTime); e->setArgument(0, v); data_ = e; } +IfcTime::operator std::string() 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 IfcURIReference -IfcUtil::ArgumentType IfcURIReference::getArgumentType(unsigned int i) const { if (i == 0) { return IfcUtil::Argument_STRING; } else { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } } -Argument* IfcURIReference::getArgument(unsigned int i) const { return entity->getArgument(i); } -bool IfcURIReference::is(Type::Enum v) const { return v == IfcURIReference::Class(); } -Type::Enum IfcURIReference::type() const { return Type::IfcURIReference; } Type::Enum IfcURIReference::Class() { return Type::IfcURIReference; } -IfcURIReference::IfcURIReference(IfcAbstractEntity* e) { entity = e; } -IfcURIReference::IfcURIReference(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcURIReference); e->setArgument(0, v); entity = e; } -IfcURIReference::operator std::string() const { return *entity->getArgument(0); } +const IfcParse::type_declaration& IfcURIReference::declaration() const { return *IfcURIReference_type; } +IfcURIReference::IfcURIReference(IfcAbstractEntity* e) { data_ = e; } +IfcURIReference::IfcURIReference(std::string v) { IfcWritableEntity* e = new IfcWritableEntity(Type::IfcURIReference); e->setArgument(0, v); data_ = e; } +IfcURIReference::operator std::string() 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 IfcActionRequest -bool IfcActionRequest::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -IfcActionRequestTypeEnum::IfcActionRequestTypeEnum IfcActionRequest::PredefinedType() const { return IfcActionRequestTypeEnum::FromString(*entity->getArgument(6)); } -void IfcActionRequest::setPredefinedType(IfcActionRequestTypeEnum::IfcActionRequestTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcActionRequestTypeEnum::ToString(v)); } -bool IfcActionRequest::hasStatus() const { return !entity->getArgument(7)->isNull(); } -std::string IfcActionRequest::Status() const { return *entity->getArgument(7); } -void IfcActionRequest::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcActionRequest::hasLongDescription() const { return !entity->getArgument(8)->isNull(); } -std::string IfcActionRequest::LongDescription() const { return *entity->getArgument(8); } -void IfcActionRequest::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcActionRequest::is(Type::Enum v) const { return v == Type::IfcActionRequest || IfcControl::is(v); } -Type::Enum IfcActionRequest::type() const { return Type::IfcActionRequest; } +bool IfcActionRequest::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +IfcActionRequestTypeEnum::IfcActionRequestTypeEnum IfcActionRequest::PredefinedType() const { return IfcActionRequestTypeEnum::FromString(*data_->getArgument(6)); } +void IfcActionRequest::setPredefinedType(IfcActionRequestTypeEnum::IfcActionRequestTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcActionRequestTypeEnum::ToString(v)); } +bool IfcActionRequest::hasStatus() const { return !data_->getArgument(7)->isNull(); } +std::string IfcActionRequest::Status() const { return *data_->getArgument(7); } +void IfcActionRequest::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcActionRequest::hasLongDescription() const { return !data_->getArgument(8)->isNull(); } +std::string IfcActionRequest::LongDescription() const { return *data_->getArgument(8); } +void IfcActionRequest::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, boost::optional< std::string > v6_Identification, boost::optional< IfcActionRequestTypeEnum::IfcActionRequestTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcActionRequestTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_LongDescription) { e->setArgument(8,(*v9_LongDescription)); } else { e->setArgument(8); } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcActionRequestTypeEnum::IfcActionRequestTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcActionRequestTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_LongDescription) { e->setArgument(8,(*v9_LongDescription)); } else { e->setArgument(8); } 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); } -IfcExternalReferenceRelationship::list::ptr IfcActorRole::HasExternalReference() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -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); } + +IfcExternalReferenceRelationship::list::ptr IfcActorRole::HasExternalReference() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } + +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 IfcActuator -bool IfcActuator::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuator::PredefinedType() const { return IfcActuatorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcActuator::setPredefinedType(IfcActuatorTypeEnum::IfcActuatorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcActuatorTypeEnum::ToString(v)); } -bool IfcActuator::is(Type::Enum v) const { return v == Type::IfcActuator || IfcDistributionControlElement::is(v); } -Type::Enum IfcActuator::type() const { return Type::IfcActuator; } +bool IfcActuator::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuator::PredefinedType() const { return IfcActuatorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcActuator::setPredefinedType(IfcActuatorTypeEnum::IfcActuatorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcActuatorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcActuator::declaration() const { return *IfcActuator_type; } Type::Enum IfcActuator::Class() { return Type::IfcActuator; } -IfcActuator::IfcActuator(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActuator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcActuator::IfcActuator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcActuatorTypeEnum::IfcActuatorTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcActuatorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcActuator::IfcActuator(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcActuator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcActuator::IfcActuator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcActuatorTypeEnum::IfcActuatorTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcActuatorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcAdvancedBrep -bool IfcAdvancedBrep::is(Type::Enum v) const { return v == Type::IfcAdvancedBrep || IfcManifoldSolidBrep::is(v); } -Type::Enum IfcAdvancedBrep::type() const { return Type::IfcAdvancedBrep; } + + +const IfcParse::entity& IfcAdvancedBrep::declaration() const { return *IfcAdvancedBrep_type; } Type::Enum IfcAdvancedBrep::Class() { return Type::IfcAdvancedBrep; } -IfcAdvancedBrep::IfcAdvancedBrep(IfcAbstractEntity* e) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAdvancedBrep)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAdvancedBrep::IfcAdvancedBrep(IfcClosedShell* v1_Outer) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); entity = e; EntityBuffer::Add(this); } +IfcAdvancedBrep::IfcAdvancedBrep(IfcAbstractEntity* e) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAdvancedBrep)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAdvancedBrep::IfcAdvancedBrep(IfcClosedShell* v1_Outer) : IfcManifoldSolidBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAdvancedBrepWithVoids -IfcTemplatedEntityList< IfcClosedShell >::ptr IfcAdvancedBrepWithVoids::Voids() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcAdvancedBrepWithVoids::setVoids(IfcTemplatedEntityList< IfcClosedShell >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcAdvancedBrepWithVoids::is(Type::Enum v) const { return v == Type::IfcAdvancedBrepWithVoids || IfcAdvancedBrep::is(v); } -Type::Enum IfcAdvancedBrepWithVoids::type() const { return Type::IfcAdvancedBrepWithVoids; } +IfcTemplatedEntityList< IfcClosedShell >::ptr IfcAdvancedBrepWithVoids::Voids() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcAdvancedBrepWithVoids::setVoids(IfcTemplatedEntityList< IfcClosedShell >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } + + +const IfcParse::entity& IfcAdvancedBrepWithVoids::declaration() const { return *IfcAdvancedBrepWithVoids_type; } Type::Enum IfcAdvancedBrepWithVoids::Class() { return Type::IfcAdvancedBrepWithVoids; } -IfcAdvancedBrepWithVoids::IfcAdvancedBrepWithVoids(IfcAbstractEntity* e) : IfcAdvancedBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAdvancedBrepWithVoids)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAdvancedBrepWithVoids::IfcAdvancedBrepWithVoids(IfcClosedShell* v1_Outer, IfcTemplatedEntityList< IfcClosedShell >::ptr v2_Voids) : IfcAdvancedBrep((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Outer)); e->setArgument(1,(v2_Voids)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcAdvancedBrepWithVoids::IfcAdvancedBrepWithVoids(IfcAbstractEntity* e) : IfcAdvancedBrep((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAdvancedBrepWithVoids)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAdvancedBrepWithVoids::IfcAdvancedBrepWithVoids(IfcClosedShell* v1_Outer, IfcTemplatedEntityList< IfcClosedShell >::ptr v2_Voids) : IfcAdvancedBrep((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 IfcAdvancedFace -bool IfcAdvancedFace::is(Type::Enum v) const { return v == Type::IfcAdvancedFace || IfcFaceSurface::is(v); } -Type::Enum IfcAdvancedFace::type() const { return Type::IfcAdvancedFace; } + + +const IfcParse::entity& IfcAdvancedFace::declaration() const { return *IfcAdvancedFace_type; } Type::Enum IfcAdvancedFace::Class() { return Type::IfcAdvancedFace; } -IfcAdvancedFace::IfcAdvancedFace(IfcAbstractEntity* e) : IfcFaceSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAdvancedFace)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAdvancedFace::IfcAdvancedFace(IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds, IfcSurface* v2_FaceSurface, bool v3_SameSense) : IfcFaceSurface((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); } +IfcAdvancedFace::IfcAdvancedFace(IfcAbstractEntity* e) : IfcFaceSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAdvancedFace)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAdvancedFace::IfcAdvancedFace(IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds, IfcSurface* v2_FaceSurface, bool v3_SameSense) : IfcFaceSurface((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 IfcAirTerminal -bool IfcAirTerminal::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminal::PredefinedType() const { return IfcAirTerminalTypeEnum::FromString(*entity->getArgument(8)); } -void IfcAirTerminal::setPredefinedType(IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcAirTerminalTypeEnum::ToString(v)); } -bool IfcAirTerminal::is(Type::Enum v) const { return v == Type::IfcAirTerminal || IfcFlowTerminal::is(v); } -Type::Enum IfcAirTerminal::type() const { return Type::IfcAirTerminal; } +bool IfcAirTerminal::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminal::PredefinedType() const { return IfcAirTerminalTypeEnum::FromString(*data_->getArgument(8)); } +void IfcAirTerminal::setPredefinedType(IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcAirTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAirTerminal::declaration() const { return *IfcAirTerminal_type; } Type::Enum IfcAirTerminal::Class() { return Type::IfcAirTerminal; } -IfcAirTerminal::IfcAirTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAirTerminal::IfcAirTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAirTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcAirTerminal::IfcAirTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAirTerminal::IfcAirTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAirTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAirTerminalBox -bool IfcAirTerminalBox::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBox::PredefinedType() const { return IfcAirTerminalBoxTypeEnum::FromString(*entity->getArgument(8)); } -void IfcAirTerminalBox::setPredefinedType(IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcAirTerminalBoxTypeEnum::ToString(v)); } -bool IfcAirTerminalBox::is(Type::Enum v) const { return v == Type::IfcAirTerminalBox || IfcFlowController::is(v); } -Type::Enum IfcAirTerminalBox::type() const { return Type::IfcAirTerminalBox; } +bool IfcAirTerminalBox::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBox::PredefinedType() const { return IfcAirTerminalBoxTypeEnum::FromString(*data_->getArgument(8)); } +void IfcAirTerminalBox::setPredefinedType(IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcAirTerminalBoxTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAirTerminalBox::declaration() const { return *IfcAirTerminalBox_type; } Type::Enum IfcAirTerminalBox::Class() { return Type::IfcAirTerminalBox; } -IfcAirTerminalBox::IfcAirTerminalBox(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminalBox)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAirTerminalBox::IfcAirTerminalBox(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcAirTerminalBoxTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcAirTerminalBox::IfcAirTerminalBox(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirTerminalBox)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAirTerminalBox::IfcAirTerminalBox(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcAirTerminalBoxTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcAirToAirHeatRecovery -bool IfcAirToAirHeatRecovery::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecovery::PredefinedType() const { return IfcAirToAirHeatRecoveryTypeEnum::FromString(*entity->getArgument(8)); } -void IfcAirToAirHeatRecovery::setPredefinedType(IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcAirToAirHeatRecoveryTypeEnum::ToString(v)); } -bool IfcAirToAirHeatRecovery::is(Type::Enum v) const { return v == Type::IfcAirToAirHeatRecovery || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcAirToAirHeatRecovery::type() const { return Type::IfcAirToAirHeatRecovery; } +bool IfcAirToAirHeatRecovery::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecovery::PredefinedType() const { return IfcAirToAirHeatRecoveryTypeEnum::FromString(*data_->getArgument(8)); } +void IfcAirToAirHeatRecovery::setPredefinedType(IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcAirToAirHeatRecoveryTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAirToAirHeatRecovery::declaration() const { return *IfcAirToAirHeatRecovery_type; } Type::Enum IfcAirToAirHeatRecovery::Class() { return Type::IfcAirToAirHeatRecovery; } -IfcAirToAirHeatRecovery::IfcAirToAirHeatRecovery(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirToAirHeatRecovery)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAirToAirHeatRecovery::IfcAirToAirHeatRecovery(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAirToAirHeatRecoveryTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcAirToAirHeatRecovery::IfcAirToAirHeatRecovery(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAirToAirHeatRecovery)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAirToAirHeatRecovery::IfcAirToAirHeatRecovery(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAirToAirHeatRecoveryTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcAlarm -bool IfcAlarm::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarm::PredefinedType() const { return IfcAlarmTypeEnum::FromString(*entity->getArgument(8)); } -void IfcAlarm::setPredefinedType(IfcAlarmTypeEnum::IfcAlarmTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcAlarmTypeEnum::ToString(v)); } -bool IfcAlarm::is(Type::Enum v) const { return v == Type::IfcAlarm || IfcDistributionControlElement::is(v); } -Type::Enum IfcAlarm::type() const { return Type::IfcAlarm; } +bool IfcAlarm::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarm::PredefinedType() const { return IfcAlarmTypeEnum::FromString(*data_->getArgument(8)); } +void IfcAlarm::setPredefinedType(IfcAlarmTypeEnum::IfcAlarmTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcAlarmTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAlarm::declaration() const { return *IfcAlarm_type; } Type::Enum IfcAlarm::Class() { return Type::IfcAlarm; } -IfcAlarm::IfcAlarm(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAlarm)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAlarm::IfcAlarm(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAlarmTypeEnum::IfcAlarmTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAlarmTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcAlarm::IfcAlarm(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAlarm)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAlarm::IfcAlarm(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAlarmTypeEnum::IfcAlarmTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAlarmTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 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 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(); } -std::string IfcAppliedValue::ApplicableDate() const { return *entity->getArgument(4); } -void IfcAppliedValue::setApplicableDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcAppliedValue::hasFixedUntilDate() const { return !entity->getArgument(5)->isNull(); } -std::string IfcAppliedValue::FixedUntilDate() const { return *entity->getArgument(5); } -void IfcAppliedValue::setFixedUntilDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcAppliedValue::hasCategory() const { return !entity->getArgument(6)->isNull(); } -std::string IfcAppliedValue::Category() const { return *entity->getArgument(6); } -void IfcAppliedValue::setCategory(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcAppliedValue::hasCondition() const { return !entity->getArgument(7)->isNull(); } -std::string IfcAppliedValue::Condition() const { return *entity->getArgument(7); } -void IfcAppliedValue::setCondition(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcAppliedValue::hasArithmeticOperator() const { return !entity->getArgument(8)->isNull(); } -IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcAppliedValue::ArithmeticOperator() const { return IfcArithmeticOperatorEnum::FromString(*entity->getArgument(8)); } -void IfcAppliedValue::setArithmeticOperator(IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcArithmeticOperatorEnum::ToString(v)); } -bool IfcAppliedValue::hasComponents() const { return !entity->getArgument(9)->isNull(); } -IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcAppliedValue::Components() const { IfcEntityList::ptr es = *entity->getArgument(9); return es->as(); } -void IfcAppliedValue::setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v->generalize()); } -IfcExternalReferenceRelationship::list::ptr IfcAppliedValue::HasExternalReference() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->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(); } +std::string IfcAppliedValue::ApplicableDate() const { return *data_->getArgument(4); } +void IfcAppliedValue::setApplicableDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcAppliedValue::hasFixedUntilDate() const { return !data_->getArgument(5)->isNull(); } +std::string IfcAppliedValue::FixedUntilDate() const { return *data_->getArgument(5); } +void IfcAppliedValue::setFixedUntilDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcAppliedValue::hasCategory() const { return !data_->getArgument(6)->isNull(); } +std::string IfcAppliedValue::Category() const { return *data_->getArgument(6); } +void IfcAppliedValue::setCategory(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcAppliedValue::hasCondition() const { return !data_->getArgument(7)->isNull(); } +std::string IfcAppliedValue::Condition() const { return *data_->getArgument(7); } +void IfcAppliedValue::setCondition(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcAppliedValue::hasArithmeticOperator() const { return !data_->getArgument(8)->isNull(); } +IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcAppliedValue::ArithmeticOperator() const { return IfcArithmeticOperatorEnum::FromString(*data_->getArgument(8)); } +void IfcAppliedValue::setArithmeticOperator(IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcArithmeticOperatorEnum::ToString(v)); } +bool IfcAppliedValue::hasComponents() const { return !data_->getArgument(9)->isNull(); } +IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcAppliedValue::Components() const { IfcEntityList::ptr es = *data_->getArgument(9); return es->as(); } +void IfcAppliedValue::setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v->generalize()); } + +IfcExternalReferenceRelationship::list::ptr IfcAppliedValue::HasExternalReference() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->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, boost::optional< std::string > v5_ApplicableDate, boost::optional< std::string > v6_FixedUntilDate, boost::optional< std::string > v7_Category, boost::optional< std::string > v8_Condition, boost::optional< IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum > v9_ArithmeticOperator, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_Components) : 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)); if (v5_ApplicableDate) { e->setArgument(4,(*v5_ApplicableDate)); } else { e->setArgument(4); } if (v6_FixedUntilDate) { e->setArgument(5,(*v6_FixedUntilDate)); } else { e->setArgument(5); } if (v7_Category) { e->setArgument(6,(*v7_Category)); } else { e->setArgument(6); } if (v8_Condition) { e->setArgument(7,(*v8_Condition)); } else { e->setArgument(7); } if (v9_ArithmeticOperator) { e->setArgument(8,*v9_ArithmeticOperator,IfcArithmeticOperatorEnum::ToString(*v9_ArithmeticOperator)); } else { e->setArgument(8); } if (v10_Components) { e->setArgument(9,(*v10_Components)->generalize()); } else { e->setArgument(9); } 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, boost::optional< std::string > v5_ApplicableDate, boost::optional< std::string > v6_FixedUntilDate, boost::optional< std::string > v7_Category, boost::optional< std::string > v8_Condition, boost::optional< IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum > v9_ArithmeticOperator, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_Components) : 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)); if (v5_ApplicableDate) { e->setArgument(4,(*v5_ApplicableDate)); } else { e->setArgument(4); } if (v6_FixedUntilDate) { e->setArgument(5,(*v6_FixedUntilDate)); } else { e->setArgument(5); } if (v7_Category) { e->setArgument(6,(*v7_Category)); } else { e->setArgument(6); } if (v8_Condition) { e->setArgument(7,(*v8_Condition)); } else { e->setArgument(7); } if (v9_ArithmeticOperator) { e->setArgument(8,*v9_ArithmeticOperator,IfcArithmeticOperatorEnum::ToString(*v9_ArithmeticOperator)); } else { e->setArgument(8); } if (v10_Components) { e->setArgument(9,(*v10_Components)->generalize()); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApproval -bool IfcApproval::hasIdentifier() const { return !entity->getArgument(0)->isNull(); } -std::string IfcApproval::Identifier() const { return *entity->getArgument(0); } -void IfcApproval::setIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcApproval::hasName() const { return !entity->getArgument(1)->isNull(); } -std::string IfcApproval::Name() const { return *entity->getArgument(1); } -void IfcApproval::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcApproval::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcApproval::Description() const { return *entity->getArgument(2); } -void IfcApproval::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcApproval::hasTimeOfApproval() const { return !entity->getArgument(3)->isNull(); } -std::string IfcApproval::TimeOfApproval() const { return *entity->getArgument(3); } -void IfcApproval::setTimeOfApproval(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcApproval::hasStatus() const { return !entity->getArgument(4)->isNull(); } -std::string IfcApproval::Status() const { return *entity->getArgument(4); } -void IfcApproval::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcApproval::hasLevel() const { return !entity->getArgument(5)->isNull(); } -std::string IfcApproval::Level() const { return *entity->getArgument(5); } -void IfcApproval::setLevel(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcApproval::hasQualifier() const { return !entity->getArgument(6)->isNull(); } -std::string IfcApproval::Qualifier() const { return *entity->getArgument(6); } -void IfcApproval::setQualifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcApproval::hasRequestingApproval() const { return !entity->getArgument(7)->isNull(); } -IfcActorSelect* IfcApproval::RequestingApproval() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcApproval::setRequestingApproval(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcApproval::hasGivingApproval() const { return !entity->getArgument(8)->isNull(); } -IfcActorSelect* IfcApproval::GivingApproval() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcApproval::setGivingApproval(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcExternalReferenceRelationship::list::ptr IfcApproval::HasExternalReferences() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -IfcRelAssociatesApproval::list::ptr IfcApproval::ApprovedObjects() const { return entity->getInverse(Type::IfcRelAssociatesApproval, 5)->as(); } -IfcResourceApprovalRelationship::list::ptr IfcApproval::ApprovedResources() const { return entity->getInverse(Type::IfcResourceApprovalRelationship, 3)->as(); } -IfcApprovalRelationship::list::ptr IfcApproval::IsRelatedWith() const { return entity->getInverse(Type::IfcApprovalRelationship, 3)->as(); } -IfcApprovalRelationship::list::ptr IfcApproval::Relates() const { return entity->getInverse(Type::IfcApprovalRelationship, 2)->as(); } -bool IfcApproval::is(Type::Enum v) const { return v == Type::IfcApproval; } -Type::Enum IfcApproval::type() const { return Type::IfcApproval; } +bool IfcApproval::hasIdentifier() const { return !data_->getArgument(0)->isNull(); } +std::string IfcApproval::Identifier() const { return *data_->getArgument(0); } +void IfcApproval::setIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcApproval::hasName() const { return !data_->getArgument(1)->isNull(); } +std::string IfcApproval::Name() const { return *data_->getArgument(1); } +void IfcApproval::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcApproval::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcApproval::Description() const { return *data_->getArgument(2); } +void IfcApproval::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcApproval::hasTimeOfApproval() const { return !data_->getArgument(3)->isNull(); } +std::string IfcApproval::TimeOfApproval() const { return *data_->getArgument(3); } +void IfcApproval::setTimeOfApproval(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcApproval::hasStatus() const { return !data_->getArgument(4)->isNull(); } +std::string IfcApproval::Status() const { return *data_->getArgument(4); } +void IfcApproval::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcApproval::hasLevel() const { return !data_->getArgument(5)->isNull(); } +std::string IfcApproval::Level() const { return *data_->getArgument(5); } +void IfcApproval::setLevel(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcApproval::hasQualifier() const { return !data_->getArgument(6)->isNull(); } +std::string IfcApproval::Qualifier() const { return *data_->getArgument(6); } +void IfcApproval::setQualifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcApproval::hasRequestingApproval() const { return !data_->getArgument(7)->isNull(); } +IfcActorSelect* IfcApproval::RequestingApproval() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcApproval::setRequestingApproval(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcApproval::hasGivingApproval() const { return !data_->getArgument(8)->isNull(); } +IfcActorSelect* IfcApproval::GivingApproval() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcApproval::setGivingApproval(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + +IfcExternalReferenceRelationship::list::ptr IfcApproval::HasExternalReferences() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } +IfcRelAssociatesApproval::list::ptr IfcApproval::ApprovedObjects() const { return data_->getInverse(Type::IfcRelAssociatesApproval, 5)->as(); } +IfcResourceApprovalRelationship::list::ptr IfcApproval::ApprovedResources() const { return data_->getInverse(Type::IfcResourceApprovalRelationship, 3)->as(); } +IfcApprovalRelationship::list::ptr IfcApproval::IsRelatedWith() const { return data_->getInverse(Type::IfcApprovalRelationship, 3)->as(); } +IfcApprovalRelationship::list::ptr IfcApproval::Relates() const { return data_->getInverse(Type::IfcApprovalRelationship, 2)->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_Identifier, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, boost::optional< std::string > v4_TimeOfApproval, boost::optional< std::string > v5_Status, boost::optional< std::string > v6_Level, boost::optional< std::string > v7_Qualifier, IfcActorSelect* v8_RequestingApproval, IfcActorSelect* v9_GivingApproval) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Identifier) { e->setArgument(0,(*v1_Identifier)); } else { e->setArgument(0); } if (v2_Name) { e->setArgument(1,(*v2_Name)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_TimeOfApproval) { e->setArgument(3,(*v4_TimeOfApproval)); } else { e->setArgument(3); } if (v5_Status) { e->setArgument(4,(*v5_Status)); } else { e->setArgument(4); } if (v6_Level) { e->setArgument(5,(*v6_Level)); } else { e->setArgument(5); } if (v7_Qualifier) { e->setArgument(6,(*v7_Qualifier)); } else { e->setArgument(6); } e->setArgument(7,(v8_RequestingApproval)); e->setArgument(8,(v9_GivingApproval)); 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_Identifier, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, boost::optional< std::string > v4_TimeOfApproval, boost::optional< std::string > v5_Status, boost::optional< std::string > v6_Level, boost::optional< std::string > v7_Qualifier, IfcActorSelect* v8_RequestingApproval, IfcActorSelect* v9_GivingApproval) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Identifier) { e->setArgument(0,(*v1_Identifier)); } else { e->setArgument(0); } if (v2_Name) { e->setArgument(1,(*v2_Name)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_TimeOfApproval) { e->setArgument(3,(*v4_TimeOfApproval)); } else { e->setArgument(3); } if (v5_Status) { e->setArgument(4,(*v5_Status)); } else { e->setArgument(4); } if (v6_Level) { e->setArgument(5,(*v6_Level)); } else { e->setArgument(5); } if (v7_Qualifier) { e->setArgument(6,(*v7_Qualifier)); } else { e->setArgument(6); } e->setArgument(7,(v8_RequestingApproval)); e->setArgument(8,(v9_GivingApproval)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcApprovalRelationship -IfcApproval* IfcApprovalRelationship::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcApprovalRelationship::setRelatingApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcApproval >::ptr IfcApprovalRelationship::RelatedApprovals() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcApprovalRelationship::setRelatedApprovals(IfcTemplatedEntityList< IfcApproval >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcApprovalRelationship::is(Type::Enum v) const { return v == Type::IfcApprovalRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcApprovalRelationship::type() const { return Type::IfcApprovalRelationship; } +IfcApproval* IfcApprovalRelationship::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcApprovalRelationship::setRelatingApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcApproval >::ptr IfcApprovalRelationship::RelatedApprovals() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcApprovalRelationship::setRelatedApprovals(IfcTemplatedEntityList< IfcApproval >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } + + +const IfcParse::entity& IfcApprovalRelationship::declaration() const { return *IfcApprovalRelationship_type; } Type::Enum IfcApprovalRelationship::Class() { return Type::IfcApprovalRelationship; } -IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcApprovalRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcApprovalRelationship::IfcApprovalRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcApproval* v3_RelatingApproval, IfcTemplatedEntityList< IfcApproval >::ptr v4_RelatedApprovals) : IfcResourceLevelRelationship((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_RelatingApproval)); e->setArgument(3,(v4_RelatedApprovals)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcApprovalRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcApprovalRelationship::IfcApprovalRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcApproval* v3_RelatingApproval, IfcTemplatedEntityList< IfcApproval >::ptr v4_RelatedApprovals) : IfcResourceLevelRelationship((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_RelatingApproval)); e->setArgument(3,(v4_RelatedApprovals)->generalize()); 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 -bool IfcAsset::hasIdentification() const { return !entity->getArgument(5)->isNull(); } -std::string IfcAsset::Identification() const { return *entity->getArgument(5); } -void IfcAsset::setIdentification(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcAsset::hasOriginalValue() const { return !entity->getArgument(6)->isNull(); } -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); } -bool IfcAsset::hasCurrentValue() const { return !entity->getArgument(7)->isNull(); } -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); } -bool IfcAsset::hasTotalReplacementCost() const { return !entity->getArgument(8)->isNull(); } -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); } -bool IfcAsset::hasOwner() const { return !entity->getArgument(9)->isNull(); } -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); } -bool IfcAsset::hasUser() const { return !entity->getArgument(10)->isNull(); } -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); } -bool IfcAsset::hasResponsiblePerson() const { return !entity->getArgument(11)->isNull(); } -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); } -bool IfcAsset::hasIncorporationDate() const { return !entity->getArgument(12)->isNull(); } -std::string IfcAsset::IncorporationDate() const { return *entity->getArgument(12); } -void IfcAsset::setIncorporationDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcAsset::hasDepreciatedValue() const { return !entity->getArgument(13)->isNull(); } -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; } +bool IfcAsset::hasIdentification() const { return !data_->getArgument(5)->isNull(); } +std::string IfcAsset::Identification() const { return *data_->getArgument(5); } +void IfcAsset::setIdentification(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcAsset::hasOriginalValue() const { return !data_->getArgument(6)->isNull(); } +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); } +bool IfcAsset::hasCurrentValue() const { return !data_->getArgument(7)->isNull(); } +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); } +bool IfcAsset::hasTotalReplacementCost() const { return !data_->getArgument(8)->isNull(); } +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); } +bool IfcAsset::hasOwner() const { return !data_->getArgument(9)->isNull(); } +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); } +bool IfcAsset::hasUser() const { return !data_->getArgument(10)->isNull(); } +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); } +bool IfcAsset::hasResponsiblePerson() const { return !data_->getArgument(11)->isNull(); } +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); } +bool IfcAsset::hasIncorporationDate() const { return !data_->getArgument(12)->isNull(); } +std::string IfcAsset::IncorporationDate() const { return *data_->getArgument(12); } +void IfcAsset::setIncorporationDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcAsset::hasDepreciatedValue() const { return !data_->getArgument(13)->isNull(); } +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, boost::optional< std::string > v6_Identification, IfcCostValue* v7_OriginalValue, IfcCostValue* v8_CurrentValue, IfcCostValue* v9_TotalReplacementCost, IfcActorSelect* v10_Owner, IfcActorSelect* v11_User, IfcPerson* v12_ResponsiblePerson, boost::optional< std::string > 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_IncorporationDate) { e->setArgument(12,(*v13_IncorporationDate)); } else { e->setArgument(12); } 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, boost::optional< std::string > v6_Identification, IfcCostValue* v7_OriginalValue, IfcCostValue* v8_CurrentValue, IfcCostValue* v9_TotalReplacementCost, IfcActorSelect* v10_Owner, IfcActorSelect* v11_User, IfcPerson* v12_ResponsiblePerson, boost::optional< std::string > 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_IncorporationDate) { e->setArgument(12,(*v13_IncorporationDate)); } else { e->setArgument(12); } e->setArgument(13,(v14_DepreciatedValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAsymmetricIShapeProfileDef -double IfcAsymmetricIShapeProfileDef::BottomFlangeWidth() const { return *entity->getArgument(3); } -void IfcAsymmetricIShapeProfileDef::setBottomFlangeWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcAsymmetricIShapeProfileDef::OverallDepth() const { return *entity->getArgument(4); } -void IfcAsymmetricIShapeProfileDef::setOverallDepth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -double IfcAsymmetricIShapeProfileDef::WebThickness() const { return *entity->getArgument(5); } -void IfcAsymmetricIShapeProfileDef::setWebThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -double IfcAsymmetricIShapeProfileDef::BottomFlangeThickness() const { return *entity->getArgument(6); } -void IfcAsymmetricIShapeProfileDef::setBottomFlangeThickness(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcAsymmetricIShapeProfileDef::hasBottomFlangeFilletRadius() const { return !entity->getArgument(7)->isNull(); } -double IfcAsymmetricIShapeProfileDef::BottomFlangeFilletRadius() const { return *entity->getArgument(7); } -void IfcAsymmetricIShapeProfileDef::setBottomFlangeFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -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::hasBottomFlangeEdgeRadius() const { return !entity->getArgument(11)->isNull(); } -double IfcAsymmetricIShapeProfileDef::BottomFlangeEdgeRadius() const { return *entity->getArgument(11); } -void IfcAsymmetricIShapeProfileDef::setBottomFlangeEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcAsymmetricIShapeProfileDef::hasBottomFlangeSlope() const { return !entity->getArgument(12)->isNull(); } -double IfcAsymmetricIShapeProfileDef::BottomFlangeSlope() const { return *entity->getArgument(12); } -void IfcAsymmetricIShapeProfileDef::setBottomFlangeSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcAsymmetricIShapeProfileDef::hasTopFlangeEdgeRadius() const { return !entity->getArgument(13)->isNull(); } -double IfcAsymmetricIShapeProfileDef::TopFlangeEdgeRadius() const { return *entity->getArgument(13); } -void IfcAsymmetricIShapeProfileDef::setTopFlangeEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcAsymmetricIShapeProfileDef::hasTopFlangeSlope() const { return !entity->getArgument(14)->isNull(); } -double IfcAsymmetricIShapeProfileDef::TopFlangeSlope() const { return *entity->getArgument(14); } -void IfcAsymmetricIShapeProfileDef::setTopFlangeSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcAsymmetricIShapeProfileDef::is(Type::Enum v) const { return v == Type::IfcAsymmetricIShapeProfileDef || IfcParameterizedProfileDef::is(v); } -Type::Enum IfcAsymmetricIShapeProfileDef::type() const { return Type::IfcAsymmetricIShapeProfileDef; } +double IfcAsymmetricIShapeProfileDef::BottomFlangeWidth() const { return *data_->getArgument(3); } +void IfcAsymmetricIShapeProfileDef::setBottomFlangeWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcAsymmetricIShapeProfileDef::OverallDepth() const { return *data_->getArgument(4); } +void IfcAsymmetricIShapeProfileDef::setOverallDepth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +double IfcAsymmetricIShapeProfileDef::WebThickness() const { return *data_->getArgument(5); } +void IfcAsymmetricIShapeProfileDef::setWebThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +double IfcAsymmetricIShapeProfileDef::BottomFlangeThickness() const { return *data_->getArgument(6); } +void IfcAsymmetricIShapeProfileDef::setBottomFlangeThickness(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcAsymmetricIShapeProfileDef::hasBottomFlangeFilletRadius() const { return !data_->getArgument(7)->isNull(); } +double IfcAsymmetricIShapeProfileDef::BottomFlangeFilletRadius() const { return *data_->getArgument(7); } +void IfcAsymmetricIShapeProfileDef::setBottomFlangeFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +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::hasBottomFlangeEdgeRadius() const { return !data_->getArgument(11)->isNull(); } +double IfcAsymmetricIShapeProfileDef::BottomFlangeEdgeRadius() const { return *data_->getArgument(11); } +void IfcAsymmetricIShapeProfileDef::setBottomFlangeEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcAsymmetricIShapeProfileDef::hasBottomFlangeSlope() const { return !data_->getArgument(12)->isNull(); } +double IfcAsymmetricIShapeProfileDef::BottomFlangeSlope() const { return *data_->getArgument(12); } +void IfcAsymmetricIShapeProfileDef::setBottomFlangeSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcAsymmetricIShapeProfileDef::hasTopFlangeEdgeRadius() const { return !data_->getArgument(13)->isNull(); } +double IfcAsymmetricIShapeProfileDef::TopFlangeEdgeRadius() const { return *data_->getArgument(13); } +void IfcAsymmetricIShapeProfileDef::setTopFlangeEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcAsymmetricIShapeProfileDef::hasTopFlangeSlope() const { return !data_->getArgument(14)->isNull(); } +double IfcAsymmetricIShapeProfileDef::TopFlangeSlope() const { return *data_->getArgument(14); } +void IfcAsymmetricIShapeProfileDef::setTopFlangeSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } + + +const IfcParse::entity& IfcAsymmetricIShapeProfileDef::declaration() const { return *IfcAsymmetricIShapeProfileDef_type; } Type::Enum IfcAsymmetricIShapeProfileDef::Class() { return Type::IfcAsymmetricIShapeProfileDef; } -IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((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_BottomFlangeWidth, double v5_OverallDepth, double v6_WebThickness, double v7_BottomFlangeThickness, boost::optional< double > v8_BottomFlangeFilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_BottomFlangeEdgeRadius, boost::optional< double > v13_BottomFlangeSlope, boost::optional< double > v14_TopFlangeEdgeRadius, boost::optional< double > v15_TopFlangeSlope) : 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_BottomFlangeWidth)); e->setArgument(4,(v5_OverallDepth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_BottomFlangeThickness)); if (v8_BottomFlangeFilletRadius) { e->setArgument(7,(*v8_BottomFlangeFilletRadius)); } 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_BottomFlangeEdgeRadius) { e->setArgument(11,(*v12_BottomFlangeEdgeRadius)); } else { e->setArgument(11); } if (v13_BottomFlangeSlope) { e->setArgument(12,(*v13_BottomFlangeSlope)); } else { e->setArgument(12); } if (v14_TopFlangeEdgeRadius) { e->setArgument(13,(*v14_TopFlangeEdgeRadius)); } else { e->setArgument(13); } if (v15_TopFlangeSlope) { e->setArgument(14,(*v15_TopFlangeSlope)); } else { e->setArgument(14); } entity = e; EntityBuffer::Add(this); } +IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntity* e) : IfcParameterizedProfileDef((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_BottomFlangeWidth, double v5_OverallDepth, double v6_WebThickness, double v7_BottomFlangeThickness, boost::optional< double > v8_BottomFlangeFilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_BottomFlangeEdgeRadius, boost::optional< double > v13_BottomFlangeSlope, boost::optional< double > v14_TopFlangeEdgeRadius, boost::optional< double > v15_TopFlangeSlope) : 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_BottomFlangeWidth)); e->setArgument(4,(v5_OverallDepth)); e->setArgument(5,(v6_WebThickness)); e->setArgument(6,(v7_BottomFlangeThickness)); if (v8_BottomFlangeFilletRadius) { e->setArgument(7,(*v8_BottomFlangeFilletRadius)); } 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_BottomFlangeEdgeRadius) { e->setArgument(11,(*v12_BottomFlangeEdgeRadius)); } else { e->setArgument(11); } if (v13_BottomFlangeSlope) { e->setArgument(12,(*v13_BottomFlangeSlope)); } else { e->setArgument(12); } if (v14_TopFlangeEdgeRadius) { e->setArgument(13,(*v14_TopFlangeEdgeRadius)); } else { e->setArgument(13); } if (v15_TopFlangeSlope) { e->setArgument(14,(*v15_TopFlangeSlope)); } else { e->setArgument(14); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAudioVisualAppliance -bool IfcAudioVisualAppliance::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum IfcAudioVisualAppliance::PredefinedType() const { return IfcAudioVisualApplianceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcAudioVisualAppliance::setPredefinedType(IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcAudioVisualApplianceTypeEnum::ToString(v)); } -bool IfcAudioVisualAppliance::is(Type::Enum v) const { return v == Type::IfcAudioVisualAppliance || IfcFlowTerminal::is(v); } -Type::Enum IfcAudioVisualAppliance::type() const { return Type::IfcAudioVisualAppliance; } +bool IfcAudioVisualAppliance::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum IfcAudioVisualAppliance::PredefinedType() const { return IfcAudioVisualApplianceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcAudioVisualAppliance::setPredefinedType(IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcAudioVisualApplianceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAudioVisualAppliance::declaration() const { return *IfcAudioVisualAppliance_type; } Type::Enum IfcAudioVisualAppliance::Class() { return Type::IfcAudioVisualAppliance; } -IfcAudioVisualAppliance::IfcAudioVisualAppliance(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAudioVisualAppliance)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAudioVisualAppliance::IfcAudioVisualAppliance(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAudioVisualApplianceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcAudioVisualAppliance::IfcAudioVisualAppliance(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAudioVisualAppliance)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAudioVisualAppliance::IfcAudioVisualAppliance(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcAudioVisualApplianceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcAudioVisualApplianceType -IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum IfcAudioVisualApplianceType::PredefinedType() const { return IfcAudioVisualApplianceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcAudioVisualApplianceType::setPredefinedType(IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcAudioVisualApplianceTypeEnum::ToString(v)); } -bool IfcAudioVisualApplianceType::is(Type::Enum v) const { return v == Type::IfcAudioVisualApplianceType || IfcFlowTerminalType::is(v); } -Type::Enum IfcAudioVisualApplianceType::type() const { return Type::IfcAudioVisualApplianceType; } +IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum IfcAudioVisualApplianceType::PredefinedType() const { return IfcAudioVisualApplianceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcAudioVisualApplianceType::setPredefinedType(IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcAudioVisualApplianceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcAudioVisualApplianceType::declaration() const { return *IfcAudioVisualApplianceType_type; } Type::Enum IfcAudioVisualApplianceType::Class() { return Type::IfcAudioVisualApplianceType; } -IfcAudioVisualApplianceType::IfcAudioVisualApplianceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAudioVisualApplianceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcAudioVisualApplianceType::IfcAudioVisualApplianceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum 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,IfcAudioVisualApplianceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcAudioVisualApplianceType::IfcAudioVisualApplianceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcAudioVisualApplianceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcAudioVisualApplianceType::IfcAudioVisualApplianceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum 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,IfcAudioVisualApplianceTypeEnum::ToString(v10_PredefinedType)); 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 IfcBSplineCurveWithKnots -std::vector< int > /*[2:?]*/ IfcBSplineCurveWithKnots::KnotMultiplicities() const { return *entity->getArgument(5); } -void IfcBSplineCurveWithKnots::setKnotMultiplicities(std::vector< int > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -std::vector< double > /*[2:?]*/ IfcBSplineCurveWithKnots::Knots() const { return *entity->getArgument(6); } -void IfcBSplineCurveWithKnots::setKnots(std::vector< double > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcKnotType::IfcKnotType IfcBSplineCurveWithKnots::KnotSpec() const { return IfcKnotType::FromString(*entity->getArgument(7)); } -void IfcBSplineCurveWithKnots::setKnotSpec(IfcKnotType::IfcKnotType v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcKnotType::ToString(v)); } -bool IfcBSplineCurveWithKnots::is(Type::Enum v) const { return v == Type::IfcBSplineCurveWithKnots || IfcBSplineCurve::is(v); } -Type::Enum IfcBSplineCurveWithKnots::type() const { return Type::IfcBSplineCurveWithKnots; } +std::vector< int > /*[2:?]*/ IfcBSplineCurveWithKnots::KnotMultiplicities() const { return *data_->getArgument(5); } +void IfcBSplineCurveWithKnots::setKnotMultiplicities(std::vector< int > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +std::vector< double > /*[2:?]*/ IfcBSplineCurveWithKnots::Knots() const { return *data_->getArgument(6); } +void IfcBSplineCurveWithKnots::setKnots(std::vector< double > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +IfcKnotType::IfcKnotType IfcBSplineCurveWithKnots::KnotSpec() const { return IfcKnotType::FromString(*data_->getArgument(7)); } +void IfcBSplineCurveWithKnots::setKnotSpec(IfcKnotType::IfcKnotType v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcKnotType::ToString(v)); } + + +const IfcParse::entity& IfcBSplineCurveWithKnots::declaration() const { return *IfcBSplineCurveWithKnots_type; } Type::Enum IfcBSplineCurveWithKnots::Class() { return Type::IfcBSplineCurveWithKnots; } -IfcBSplineCurveWithKnots::IfcBSplineCurveWithKnots(IfcAbstractEntity* e) : IfcBSplineCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineCurveWithKnots)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBSplineCurveWithKnots::IfcBSplineCurveWithKnots(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec) : 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)); e->setArgument(5,(v6_KnotMultiplicities)); e->setArgument(6,(v7_Knots)); e->setArgument(7,v8_KnotSpec,IfcKnotType::ToString(v8_KnotSpec)); entity = e; EntityBuffer::Add(this); } +IfcBSplineCurveWithKnots::IfcBSplineCurveWithKnots(IfcAbstractEntity* e) : IfcBSplineCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineCurveWithKnots)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBSplineCurveWithKnots::IfcBSplineCurveWithKnots(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec) : 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)); e->setArgument(5,(v6_KnotMultiplicities)); e->setArgument(6,(v7_Knots)); e->setArgument(7,v8_KnotSpec,IfcKnotType::ToString(v8_KnotSpec)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBSplineSurface -int IfcBSplineSurface::UDegree() const { return *entity->getArgument(0); } -void IfcBSplineSurface::setUDegree(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -int IfcBSplineSurface::VDegree() const { return *entity->getArgument(1); } -void IfcBSplineSurface::setVDegree(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTemplatedEntityListList< IfcCartesianPoint >::ptr IfcBSplineSurface::ControlPointsList() const { IfcEntityListList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcBSplineSurface::setControlPointsList(IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -IfcBSplineSurfaceForm::IfcBSplineSurfaceForm IfcBSplineSurface::SurfaceForm() const { return IfcBSplineSurfaceForm::FromString(*entity->getArgument(3)); } -void IfcBSplineSurface::setSurfaceForm(IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v,IfcBSplineSurfaceForm::ToString(v)); } -bool IfcBSplineSurface::UClosed() const { return *entity->getArgument(4); } -void IfcBSplineSurface::setUClosed(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBSplineSurface::VClosed() const { return *entity->getArgument(5); } -void IfcBSplineSurface::setVClosed(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcBSplineSurface::SelfIntersect() const { return *entity->getArgument(6); } -void IfcBSplineSurface::setSelfIntersect(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcBSplineSurface::is(Type::Enum v) const { return v == Type::IfcBSplineSurface || IfcBoundedSurface::is(v); } -Type::Enum IfcBSplineSurface::type() const { return Type::IfcBSplineSurface; } +int IfcBSplineSurface::UDegree() const { return *data_->getArgument(0); } +void IfcBSplineSurface::setUDegree(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +int IfcBSplineSurface::VDegree() const { return *data_->getArgument(1); } +void IfcBSplineSurface::setVDegree(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTemplatedEntityListList< IfcCartesianPoint >::ptr IfcBSplineSurface::ControlPointsList() const { IfcEntityListList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcBSplineSurface::setControlPointsList(IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } +IfcBSplineSurfaceForm::IfcBSplineSurfaceForm IfcBSplineSurface::SurfaceForm() const { return IfcBSplineSurfaceForm::FromString(*data_->getArgument(3)); } +void IfcBSplineSurface::setSurfaceForm(IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v,IfcBSplineSurfaceForm::ToString(v)); } +bool IfcBSplineSurface::UClosed() const { return *data_->getArgument(4); } +void IfcBSplineSurface::setUClosed(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcBSplineSurface::VClosed() const { return *data_->getArgument(5); } +void IfcBSplineSurface::setVClosed(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcBSplineSurface::SelfIntersect() const { return *data_->getArgument(6); } +void IfcBSplineSurface::setSelfIntersect(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcBSplineSurface::declaration() const { return *IfcBSplineSurface_type; } Type::Enum IfcBSplineSurface::Class() { return Type::IfcBSplineSurface; } -IfcBSplineSurface::IfcBSplineSurface(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBSplineSurface::IfcBSplineSurface(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcBSplineSurface::IfcBSplineSurface(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBSplineSurface::IfcBSplineSurface(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBSplineSurfaceWithKnots -std::vector< int > /*[2:?]*/ IfcBSplineSurfaceWithKnots::UMultiplicities() const { return *entity->getArgument(7); } -void IfcBSplineSurfaceWithKnots::setUMultiplicities(std::vector< int > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -std::vector< int > /*[2:?]*/ IfcBSplineSurfaceWithKnots::VMultiplicities() const { return *entity->getArgument(8); } -void IfcBSplineSurfaceWithKnots::setVMultiplicities(std::vector< int > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -std::vector< double > /*[2:?]*/ IfcBSplineSurfaceWithKnots::UKnots() const { return *entity->getArgument(9); } -void IfcBSplineSurfaceWithKnots::setUKnots(std::vector< double > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -std::vector< double > /*[2:?]*/ IfcBSplineSurfaceWithKnots::VKnots() const { return *entity->getArgument(10); } -void IfcBSplineSurfaceWithKnots::setVKnots(std::vector< double > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -IfcKnotType::IfcKnotType IfcBSplineSurfaceWithKnots::KnotSpec() const { return IfcKnotType::FromString(*entity->getArgument(11)); } -void IfcBSplineSurfaceWithKnots::setKnotSpec(IfcKnotType::IfcKnotType v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcKnotType::ToString(v)); } -bool IfcBSplineSurfaceWithKnots::is(Type::Enum v) const { return v == Type::IfcBSplineSurfaceWithKnots || IfcBSplineSurface::is(v); } -Type::Enum IfcBSplineSurfaceWithKnots::type() const { return Type::IfcBSplineSurfaceWithKnots; } +std::vector< int > /*[2:?]*/ IfcBSplineSurfaceWithKnots::UMultiplicities() const { return *data_->getArgument(7); } +void IfcBSplineSurfaceWithKnots::setUMultiplicities(std::vector< int > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +std::vector< int > /*[2:?]*/ IfcBSplineSurfaceWithKnots::VMultiplicities() const { return *data_->getArgument(8); } +void IfcBSplineSurfaceWithKnots::setVMultiplicities(std::vector< int > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +std::vector< double > /*[2:?]*/ IfcBSplineSurfaceWithKnots::UKnots() const { return *data_->getArgument(9); } +void IfcBSplineSurfaceWithKnots::setUKnots(std::vector< double > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +std::vector< double > /*[2:?]*/ IfcBSplineSurfaceWithKnots::VKnots() const { return *data_->getArgument(10); } +void IfcBSplineSurfaceWithKnots::setVKnots(std::vector< double > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +IfcKnotType::IfcKnotType IfcBSplineSurfaceWithKnots::KnotSpec() const { return IfcKnotType::FromString(*data_->getArgument(11)); } +void IfcBSplineSurfaceWithKnots::setKnotSpec(IfcKnotType::IfcKnotType v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcKnotType::ToString(v)); } + + +const IfcParse::entity& IfcBSplineSurfaceWithKnots::declaration() const { return *IfcBSplineSurfaceWithKnots_type; } Type::Enum IfcBSplineSurfaceWithKnots::Class() { return Type::IfcBSplineSurfaceWithKnots; } -IfcBSplineSurfaceWithKnots::IfcBSplineSurfaceWithKnots(IfcAbstractEntity* e) : IfcBSplineSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineSurfaceWithKnots)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBSplineSurfaceWithKnots::IfcBSplineSurfaceWithKnots(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec) : IfcBSplineSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); e->setArgument(7,(v8_UMultiplicities)); e->setArgument(8,(v9_VMultiplicities)); e->setArgument(9,(v10_UKnots)); e->setArgument(10,(v11_VKnots)); e->setArgument(11,v12_KnotSpec,IfcKnotType::ToString(v12_KnotSpec)); entity = e; EntityBuffer::Add(this); } +IfcBSplineSurfaceWithKnots::IfcBSplineSurfaceWithKnots(IfcAbstractEntity* e) : IfcBSplineSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBSplineSurfaceWithKnots)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBSplineSurfaceWithKnots::IfcBSplineSurfaceWithKnots(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec) : IfcBSplineSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); e->setArgument(7,(v8_UMultiplicities)); e->setArgument(8,(v9_VMultiplicities)); e->setArgument(9,(v10_UKnots)); e->setArgument(10,(v11_VKnots)); e->setArgument(11,v12_KnotSpec,IfcKnotType::ToString(v12_KnotSpec)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBeam -bool IfcBeam::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeam::PredefinedType() const { return IfcBeamTypeEnum::FromString(*entity->getArgument(8)); } -void IfcBeam::setPredefinedType(IfcBeamTypeEnum::IfcBeamTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcBeamTypeEnum::ToString(v)); } -bool IfcBeam::is(Type::Enum v) const { return v == Type::IfcBeam || IfcBuildingElement::is(v); } -Type::Enum IfcBeam::type() const { return Type::IfcBeam; } +bool IfcBeam::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeam::PredefinedType() const { return IfcBeamTypeEnum::FromString(*data_->getArgument(8)); } +void IfcBeam::setPredefinedType(IfcBeamTypeEnum::IfcBeamTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcBeamTypeEnum::ToString(v)); } + + +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, boost::optional< IfcBeamTypeEnum::IfcBeamTypeEnum > 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,IfcBeamTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcBeamTypeEnum::IfcBeamTypeEnum > 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,IfcBeamTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBeamStandardCase -bool IfcBeamStandardCase::is(Type::Enum v) const { return v == Type::IfcBeamStandardCase || IfcBeam::is(v); } -Type::Enum IfcBeamStandardCase::type() const { return Type::IfcBeamStandardCase; } + + +const IfcParse::entity& IfcBeamStandardCase::declaration() const { return *IfcBeamStandardCase_type; } Type::Enum IfcBeamStandardCase::Class() { return Type::IfcBeamStandardCase; } -IfcBeamStandardCase::IfcBeamStandardCase(IfcAbstractEntity* e) : IfcBeam((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBeamStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBeamStandardCase::IfcBeamStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBeamTypeEnum::IfcBeamTypeEnum > v9_PredefinedType) : IfcBeam((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcBeamTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcBeamStandardCase::IfcBeamStandardCase(IfcAbstractEntity* e) : IfcBeam((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBeamStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBeamStandardCase::IfcBeamStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBeamTypeEnum::IfcBeamTypeEnum > v9_PredefinedType) : IfcBeam((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcBeamTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcBlobTexture -std::string IfcBlobTexture::RasterFormat() const { return *entity->getArgument(5); } -void IfcBlobTexture::setRasterFormat(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -boost::dynamic_bitset<> IfcBlobTexture::RasterCode() const { return *entity->getArgument(6); } -void IfcBlobTexture::setRasterCode(boost::dynamic_bitset<> v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,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(5); } +void IfcBlobTexture::setRasterFormat(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +boost::dynamic_bitset<> IfcBlobTexture::RasterCode() const { return *data_->getArgument(6); } +void IfcBlobTexture::setRasterCode(boost::dynamic_bitset<> v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_RasterFormat, boost::dynamic_bitset<> v7_RasterCode) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } e->setArgument(5,(v6_RasterFormat)); e->setArgument(6,(v7_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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_RasterFormat, boost::dynamic_bitset<> v7_RasterCode) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } e->setArgument(5,(v6_RasterFormat)); e->setArgument(6,(v7_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 IfcBoiler -bool IfcBoiler::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoiler::PredefinedType() const { return IfcBoilerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcBoiler::setPredefinedType(IfcBoilerTypeEnum::IfcBoilerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcBoilerTypeEnum::ToString(v)); } -bool IfcBoiler::is(Type::Enum v) const { return v == Type::IfcBoiler || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcBoiler::type() const { return Type::IfcBoiler; } +bool IfcBoiler::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoiler::PredefinedType() const { return IfcBoilerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcBoiler::setPredefinedType(IfcBoilerTypeEnum::IfcBoilerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcBoilerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBoiler::declaration() const { return *IfcBoiler_type; } Type::Enum IfcBoiler::Class() { return Type::IfcBoiler; } -IfcBoiler::IfcBoiler(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoiler)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoiler::IfcBoiler(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBoilerTypeEnum::IfcBoilerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcBoilerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcBoiler::IfcBoiler(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoiler)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoiler::IfcBoiler(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBoilerTypeEnum::IfcBoilerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcBoilerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcBoundaryCurve -bool IfcBoundaryCurve::is(Type::Enum v) const { return v == Type::IfcBoundaryCurve || IfcCompositeCurveOnSurface::is(v); } -Type::Enum IfcBoundaryCurve::type() const { return Type::IfcBoundaryCurve; } + + +const IfcParse::entity& IfcBoundaryCurve::declaration() const { return *IfcBoundaryCurve_type; } Type::Enum IfcBoundaryCurve::Class() { return Type::IfcBoundaryCurve; } -IfcBoundaryCurve::IfcBoundaryCurve(IfcAbstractEntity* e) : IfcCompositeCurveOnSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBoundaryCurve::IfcBoundaryCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcCompositeCurveOnSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Segments)->generalize()); e->setArgument(1,(v2_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcBoundaryCurve::IfcBoundaryCurve(IfcAbstractEntity* e) : IfcCompositeCurveOnSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBoundaryCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBoundaryCurve::IfcBoundaryCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcCompositeCurveOnSurface((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 IfcBoundaryEdgeCondition -bool IfcBoundaryEdgeCondition::hasTranslationalStiffnessByLengthX() const { return !entity->getArgument(1)->isNull(); } -IfcModulusOfTranslationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthX() const { return (IfcModulusOfTranslationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthX(IfcModulusOfTranslationalSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcBoundaryEdgeCondition::hasTranslationalStiffnessByLengthY() const { return !entity->getArgument(2)->isNull(); } -IfcModulusOfTranslationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthY() const { return (IfcModulusOfTranslationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthY(IfcModulusOfTranslationalSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoundaryEdgeCondition::hasTranslationalStiffnessByLengthZ() const { return !entity->getArgument(3)->isNull(); } -IfcModulusOfTranslationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthZ() const { return (IfcModulusOfTranslationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthZ(IfcModulusOfTranslationalSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthX() const { return !entity->getArgument(4)->isNull(); } -IfcModulusOfRotationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() const { return (IfcModulusOfRotationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthX(IfcModulusOfRotationalSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthY() const { return !entity->getArgument(5)->isNull(); } -IfcModulusOfRotationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() const { return (IfcModulusOfRotationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthY(IfcModulusOfRotationalSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthZ() const { return !entity->getArgument(6)->isNull(); } -IfcModulusOfRotationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() const { return (IfcModulusOfRotationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthZ(IfcModulusOfRotationalSubgradeReactionSelect* 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::hasTranslationalStiffnessByLengthX() const { return !data_->getArgument(1)->isNull(); } +IfcModulusOfTranslationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthX() const { return (IfcModulusOfTranslationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthX(IfcModulusOfTranslationalSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcBoundaryEdgeCondition::hasTranslationalStiffnessByLengthY() const { return !data_->getArgument(2)->isNull(); } +IfcModulusOfTranslationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthY() const { return (IfcModulusOfTranslationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthY(IfcModulusOfTranslationalSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcBoundaryEdgeCondition::hasTranslationalStiffnessByLengthZ() const { return !data_->getArgument(3)->isNull(); } +IfcModulusOfTranslationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::TranslationalStiffnessByLengthZ() const { return (IfcModulusOfTranslationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcBoundaryEdgeCondition::setTranslationalStiffnessByLengthZ(IfcModulusOfTranslationalSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthX() const { return !data_->getArgument(4)->isNull(); } +IfcModulusOfRotationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::RotationalStiffnessByLengthX() const { return (IfcModulusOfRotationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthX(IfcModulusOfRotationalSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthY() const { return !data_->getArgument(5)->isNull(); } +IfcModulusOfRotationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::RotationalStiffnessByLengthY() const { return (IfcModulusOfRotationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthY(IfcModulusOfRotationalSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcBoundaryEdgeCondition::hasRotationalStiffnessByLengthZ() const { return !data_->getArgument(6)->isNull(); } +IfcModulusOfRotationalSubgradeReactionSelect* IfcBoundaryEdgeCondition::RotationalStiffnessByLengthZ() const { return (IfcModulusOfRotationalSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcBoundaryEdgeCondition::setRotationalStiffnessByLengthZ(IfcModulusOfRotationalSubgradeReactionSelect* 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, IfcModulusOfTranslationalSubgradeReactionSelect* v2_TranslationalStiffnessByLengthX, IfcModulusOfTranslationalSubgradeReactionSelect* v3_TranslationalStiffnessByLengthY, IfcModulusOfTranslationalSubgradeReactionSelect* v4_TranslationalStiffnessByLengthZ, IfcModulusOfRotationalSubgradeReactionSelect* v5_RotationalStiffnessByLengthX, IfcModulusOfRotationalSubgradeReactionSelect* v6_RotationalStiffnessByLengthY, IfcModulusOfRotationalSubgradeReactionSelect* v7_RotationalStiffnessByLengthZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessByLengthX)); e->setArgument(2,(v3_TranslationalStiffnessByLengthY)); e->setArgument(3,(v4_TranslationalStiffnessByLengthZ)); e->setArgument(4,(v5_RotationalStiffnessByLengthX)); e->setArgument(5,(v6_RotationalStiffnessByLengthY)); e->setArgument(6,(v7_RotationalStiffnessByLengthZ)); 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, IfcModulusOfTranslationalSubgradeReactionSelect* v2_TranslationalStiffnessByLengthX, IfcModulusOfTranslationalSubgradeReactionSelect* v3_TranslationalStiffnessByLengthY, IfcModulusOfTranslationalSubgradeReactionSelect* v4_TranslationalStiffnessByLengthZ, IfcModulusOfRotationalSubgradeReactionSelect* v5_RotationalStiffnessByLengthX, IfcModulusOfRotationalSubgradeReactionSelect* v6_RotationalStiffnessByLengthY, IfcModulusOfRotationalSubgradeReactionSelect* v7_RotationalStiffnessByLengthZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessByLengthX)); e->setArgument(2,(v3_TranslationalStiffnessByLengthY)); e->setArgument(3,(v4_TranslationalStiffnessByLengthZ)); e->setArgument(4,(v5_RotationalStiffnessByLengthX)); e->setArgument(5,(v6_RotationalStiffnessByLengthY)); e->setArgument(6,(v7_RotationalStiffnessByLengthZ)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryFaceCondition -bool IfcBoundaryFaceCondition::hasTranslationalStiffnessByAreaX() const { return !entity->getArgument(1)->isNull(); } -IfcModulusOfSubgradeReactionSelect* IfcBoundaryFaceCondition::TranslationalStiffnessByAreaX() const { return (IfcModulusOfSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaX(IfcModulusOfSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcBoundaryFaceCondition::hasTranslationalStiffnessByAreaY() const { return !entity->getArgument(2)->isNull(); } -IfcModulusOfSubgradeReactionSelect* IfcBoundaryFaceCondition::TranslationalStiffnessByAreaY() const { return (IfcModulusOfSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaY(IfcModulusOfSubgradeReactionSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoundaryFaceCondition::hasTranslationalStiffnessByAreaZ() const { return !entity->getArgument(3)->isNull(); } -IfcModulusOfSubgradeReactionSelect* IfcBoundaryFaceCondition::TranslationalStiffnessByAreaZ() const { return (IfcModulusOfSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaZ(IfcModulusOfSubgradeReactionSelect* 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::hasTranslationalStiffnessByAreaX() const { return !data_->getArgument(1)->isNull(); } +IfcModulusOfSubgradeReactionSelect* IfcBoundaryFaceCondition::TranslationalStiffnessByAreaX() const { return (IfcModulusOfSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaX(IfcModulusOfSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcBoundaryFaceCondition::hasTranslationalStiffnessByAreaY() const { return !data_->getArgument(2)->isNull(); } +IfcModulusOfSubgradeReactionSelect* IfcBoundaryFaceCondition::TranslationalStiffnessByAreaY() const { return (IfcModulusOfSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaY(IfcModulusOfSubgradeReactionSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcBoundaryFaceCondition::hasTranslationalStiffnessByAreaZ() const { return !data_->getArgument(3)->isNull(); } +IfcModulusOfSubgradeReactionSelect* IfcBoundaryFaceCondition::TranslationalStiffnessByAreaZ() const { return (IfcModulusOfSubgradeReactionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcBoundaryFaceCondition::setTranslationalStiffnessByAreaZ(IfcModulusOfSubgradeReactionSelect* 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, IfcModulusOfSubgradeReactionSelect* v2_TranslationalStiffnessByAreaX, IfcModulusOfSubgradeReactionSelect* v3_TranslationalStiffnessByAreaY, IfcModulusOfSubgradeReactionSelect* v4_TranslationalStiffnessByAreaZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessByAreaX)); e->setArgument(2,(v3_TranslationalStiffnessByAreaY)); e->setArgument(3,(v4_TranslationalStiffnessByAreaZ)); 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, IfcModulusOfSubgradeReactionSelect* v2_TranslationalStiffnessByAreaX, IfcModulusOfSubgradeReactionSelect* v3_TranslationalStiffnessByAreaY, IfcModulusOfSubgradeReactionSelect* v4_TranslationalStiffnessByAreaZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessByAreaX)); e->setArgument(2,(v3_TranslationalStiffnessByAreaY)); e->setArgument(3,(v4_TranslationalStiffnessByAreaZ)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryNodeCondition -bool IfcBoundaryNodeCondition::hasTranslationalStiffnessX() const { return !entity->getArgument(1)->isNull(); } -IfcTranslationalStiffnessSelect* IfcBoundaryNodeCondition::TranslationalStiffnessX() const { return (IfcTranslationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcBoundaryNodeCondition::setTranslationalStiffnessX(IfcTranslationalStiffnessSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcBoundaryNodeCondition::hasTranslationalStiffnessY() const { return !entity->getArgument(2)->isNull(); } -IfcTranslationalStiffnessSelect* IfcBoundaryNodeCondition::TranslationalStiffnessY() const { return (IfcTranslationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcBoundaryNodeCondition::setTranslationalStiffnessY(IfcTranslationalStiffnessSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcBoundaryNodeCondition::hasTranslationalStiffnessZ() const { return !entity->getArgument(3)->isNull(); } -IfcTranslationalStiffnessSelect* IfcBoundaryNodeCondition::TranslationalStiffnessZ() const { return (IfcTranslationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcBoundaryNodeCondition::setTranslationalStiffnessZ(IfcTranslationalStiffnessSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcBoundaryNodeCondition::hasRotationalStiffnessX() const { return !entity->getArgument(4)->isNull(); } -IfcRotationalStiffnessSelect* IfcBoundaryNodeCondition::RotationalStiffnessX() const { return (IfcRotationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcBoundaryNodeCondition::setRotationalStiffnessX(IfcRotationalStiffnessSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcBoundaryNodeCondition::hasRotationalStiffnessY() const { return !entity->getArgument(5)->isNull(); } -IfcRotationalStiffnessSelect* IfcBoundaryNodeCondition::RotationalStiffnessY() const { return (IfcRotationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcBoundaryNodeCondition::setRotationalStiffnessY(IfcRotationalStiffnessSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcBoundaryNodeCondition::hasRotationalStiffnessZ() const { return !entity->getArgument(6)->isNull(); } -IfcRotationalStiffnessSelect* IfcBoundaryNodeCondition::RotationalStiffnessZ() const { return (IfcRotationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcBoundaryNodeCondition::setRotationalStiffnessZ(IfcRotationalStiffnessSelect* 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::hasTranslationalStiffnessX() const { return !data_->getArgument(1)->isNull(); } +IfcTranslationalStiffnessSelect* IfcBoundaryNodeCondition::TranslationalStiffnessX() const { return (IfcTranslationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcBoundaryNodeCondition::setTranslationalStiffnessX(IfcTranslationalStiffnessSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcBoundaryNodeCondition::hasTranslationalStiffnessY() const { return !data_->getArgument(2)->isNull(); } +IfcTranslationalStiffnessSelect* IfcBoundaryNodeCondition::TranslationalStiffnessY() const { return (IfcTranslationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcBoundaryNodeCondition::setTranslationalStiffnessY(IfcTranslationalStiffnessSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcBoundaryNodeCondition::hasTranslationalStiffnessZ() const { return !data_->getArgument(3)->isNull(); } +IfcTranslationalStiffnessSelect* IfcBoundaryNodeCondition::TranslationalStiffnessZ() const { return (IfcTranslationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcBoundaryNodeCondition::setTranslationalStiffnessZ(IfcTranslationalStiffnessSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessX() const { return !data_->getArgument(4)->isNull(); } +IfcRotationalStiffnessSelect* IfcBoundaryNodeCondition::RotationalStiffnessX() const { return (IfcRotationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcBoundaryNodeCondition::setRotationalStiffnessX(IfcRotationalStiffnessSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessY() const { return !data_->getArgument(5)->isNull(); } +IfcRotationalStiffnessSelect* IfcBoundaryNodeCondition::RotationalStiffnessY() const { return (IfcRotationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcBoundaryNodeCondition::setRotationalStiffnessY(IfcRotationalStiffnessSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcBoundaryNodeCondition::hasRotationalStiffnessZ() const { return !data_->getArgument(6)->isNull(); } +IfcRotationalStiffnessSelect* IfcBoundaryNodeCondition::RotationalStiffnessZ() const { return (IfcRotationalStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcBoundaryNodeCondition::setRotationalStiffnessZ(IfcRotationalStiffnessSelect* 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, IfcTranslationalStiffnessSelect* v2_TranslationalStiffnessX, IfcTranslationalStiffnessSelect* v3_TranslationalStiffnessY, IfcTranslationalStiffnessSelect* v4_TranslationalStiffnessZ, IfcRotationalStiffnessSelect* v5_RotationalStiffnessX, IfcRotationalStiffnessSelect* v6_RotationalStiffnessY, IfcRotationalStiffnessSelect* v7_RotationalStiffnessZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessX)); e->setArgument(2,(v3_TranslationalStiffnessY)); e->setArgument(3,(v4_TranslationalStiffnessZ)); e->setArgument(4,(v5_RotationalStiffnessX)); e->setArgument(5,(v6_RotationalStiffnessY)); e->setArgument(6,(v7_RotationalStiffnessZ)); 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, IfcTranslationalStiffnessSelect* v2_TranslationalStiffnessX, IfcTranslationalStiffnessSelect* v3_TranslationalStiffnessY, IfcTranslationalStiffnessSelect* v4_TranslationalStiffnessZ, IfcRotationalStiffnessSelect* v5_RotationalStiffnessX, IfcRotationalStiffnessSelect* v6_RotationalStiffnessY, IfcRotationalStiffnessSelect* v7_RotationalStiffnessZ) : IfcBoundaryCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessX)); e->setArgument(2,(v3_TranslationalStiffnessY)); e->setArgument(3,(v4_TranslationalStiffnessZ)); e->setArgument(4,(v5_RotationalStiffnessX)); e->setArgument(5,(v6_RotationalStiffnessY)); e->setArgument(6,(v7_RotationalStiffnessZ)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBoundaryNodeConditionWarping -bool IfcBoundaryNodeConditionWarping::hasWarpingStiffness() const { return !entity->getArgument(7)->isNull(); } -IfcWarpingStiffnessSelect* IfcBoundaryNodeConditionWarping::WarpingStiffness() const { return (IfcWarpingStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcBoundaryNodeConditionWarping::setWarpingStiffness(IfcWarpingStiffnessSelect* 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(); } +IfcWarpingStiffnessSelect* IfcBoundaryNodeConditionWarping::WarpingStiffness() const { return (IfcWarpingStiffnessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcBoundaryNodeConditionWarping::setWarpingStiffness(IfcWarpingStiffnessSelect* 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, IfcTranslationalStiffnessSelect* v2_TranslationalStiffnessX, IfcTranslationalStiffnessSelect* v3_TranslationalStiffnessY, IfcTranslationalStiffnessSelect* v4_TranslationalStiffnessZ, IfcRotationalStiffnessSelect* v5_RotationalStiffnessX, IfcRotationalStiffnessSelect* v6_RotationalStiffnessY, IfcRotationalStiffnessSelect* v7_RotationalStiffnessZ, IfcWarpingStiffnessSelect* v8_WarpingStiffness) : IfcBoundaryNodeCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessX)); e->setArgument(2,(v3_TranslationalStiffnessY)); e->setArgument(3,(v4_TranslationalStiffnessZ)); e->setArgument(4,(v5_RotationalStiffnessX)); e->setArgument(5,(v6_RotationalStiffnessY)); e->setArgument(6,(v7_RotationalStiffnessZ)); e->setArgument(7,(v8_WarpingStiffness)); 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, IfcTranslationalStiffnessSelect* v2_TranslationalStiffnessX, IfcTranslationalStiffnessSelect* v3_TranslationalStiffnessY, IfcTranslationalStiffnessSelect* v4_TranslationalStiffnessZ, IfcRotationalStiffnessSelect* v5_RotationalStiffnessX, IfcRotationalStiffnessSelect* v6_RotationalStiffnessY, IfcRotationalStiffnessSelect* v7_RotationalStiffnessZ, IfcWarpingStiffnessSelect* v8_WarpingStiffness) : IfcBoundaryNodeCondition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_TranslationalStiffnessX)); e->setArgument(2,(v3_TranslationalStiffnessY)); e->setArgument(3,(v4_TranslationalStiffnessZ)); e->setArgument(4,(v5_RotationalStiffnessX)); e->setArgument(5,(v6_RotationalStiffnessY)); e->setArgument(6,(v7_RotationalStiffnessZ)); e->setArgument(7,(v8_WarpingStiffness)); 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, boost::optional< 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } 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, boost::optional< 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } 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 -IfcRelCoversBldgElements::list::ptr IfcBuildingElement::HasCoverings() const { return entity->getInverse(Type::IfcRelCoversBldgElements, 4)->as(); } -bool IfcBuildingElement::is(Type::Enum v) const { return v == Type::IfcBuildingElement || IfcElement::is(v); } -Type::Enum IfcBuildingElement::type() const { return Type::IfcBuildingElement; } + +IfcRelCoversBldgElements::list::ptr IfcBuildingElement::HasCoverings() const { return data_->getInverse(Type::IfcRelCoversBldgElements, 4)->as(); } + +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 IfcBuildingElementPart -bool IfcBuildingElementPart::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum IfcBuildingElementPart::PredefinedType() const { return IfcBuildingElementPartTypeEnum::FromString(*entity->getArgument(8)); } -void IfcBuildingElementPart::setPredefinedType(IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcBuildingElementPartTypeEnum::ToString(v)); } -bool IfcBuildingElementPart::is(Type::Enum v) const { return v == Type::IfcBuildingElementPart || IfcElementComponent::is(v); } -Type::Enum IfcBuildingElementPart::type() const { return Type::IfcBuildingElementPart; } +bool IfcBuildingElementPart::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum IfcBuildingElementPart::PredefinedType() const { return IfcBuildingElementPartTypeEnum::FromString(*data_->getArgument(8)); } +void IfcBuildingElementPart::setPredefinedType(IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcBuildingElementPartTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBuildingElementPart::declaration() const { return *IfcBuildingElementPart_type; } Type::Enum IfcBuildingElementPart::Class() { return Type::IfcBuildingElementPart; } -IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntity* e) : IfcElementComponent((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, boost::optional< IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcBuildingElementPartTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntity* e) : IfcElementComponent((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, boost::optional< IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcBuildingElementPartTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementPartType -IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum IfcBuildingElementPartType::PredefinedType() const { return IfcBuildingElementPartTypeEnum::FromString(*entity->getArgument(9)); } -void IfcBuildingElementPartType::setPredefinedType(IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcBuildingElementPartTypeEnum::ToString(v)); } -bool IfcBuildingElementPartType::is(Type::Enum v) const { return v == Type::IfcBuildingElementPartType || IfcElementComponentType::is(v); } -Type::Enum IfcBuildingElementPartType::type() const { return Type::IfcBuildingElementPartType; } +IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum IfcBuildingElementPartType::PredefinedType() const { return IfcBuildingElementPartTypeEnum::FromString(*data_->getArgument(9)); } +void IfcBuildingElementPartType::setPredefinedType(IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcBuildingElementPartTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBuildingElementPartType::declaration() const { return *IfcBuildingElementPartType_type; } Type::Enum IfcBuildingElementPartType::Class() { return Type::IfcBuildingElementPartType; } -IfcBuildingElementPartType::IfcBuildingElementPartType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementPartType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingElementPartType::IfcBuildingElementPartType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v10_PredefinedType) : 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); } e->setArgument(9,v10_PredefinedType,IfcBuildingElementPartTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcBuildingElementPartType::IfcBuildingElementPartType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingElementPartType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingElementPartType::IfcBuildingElementPartType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v10_PredefinedType) : 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); } e->setArgument(9,v10_PredefinedType,IfcBuildingElementPartTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingElementProxy -bool IfcBuildingElementProxy::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxy::PredefinedType() const { return IfcBuildingElementProxyTypeEnum::FromString(*entity->getArgument(8)); } -void IfcBuildingElementProxy::setPredefinedType(IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcBuildingElementProxyTypeEnum::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::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxy::PredefinedType() const { return IfcBuildingElementProxyTypeEnum::FromString(*data_->getArgument(8)); } +void IfcBuildingElementProxy::setPredefinedType(IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcBuildingElementProxyTypeEnum::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< IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum > 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,IfcBuildingElementProxyTypeEnum::ToString(*v9_PredefinedType)); } 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< IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum > 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,IfcBuildingElementProxyTypeEnum::ToString(*v9_PredefinedType)); } 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, boost::optional< 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } 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, boost::optional< 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } if (v10_Elevation) { e->setArgument(9,(*v10_Elevation)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBuildingSystem -bool IfcBuildingSystem::hasPredefinedType() const { return !entity->getArgument(5)->isNull(); } -IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum IfcBuildingSystem::PredefinedType() const { return IfcBuildingSystemTypeEnum::FromString(*entity->getArgument(5)); } -void IfcBuildingSystem::setPredefinedType(IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcBuildingSystemTypeEnum::ToString(v)); } -bool IfcBuildingSystem::is(Type::Enum v) const { return v == Type::IfcBuildingSystem || IfcSystem::is(v); } -Type::Enum IfcBuildingSystem::type() const { return Type::IfcBuildingSystem; } +bool IfcBuildingSystem::hasPredefinedType() const { return !data_->getArgument(5)->isNull(); } +IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum IfcBuildingSystem::PredefinedType() const { return IfcBuildingSystemTypeEnum::FromString(*data_->getArgument(5)); } +void IfcBuildingSystem::setPredefinedType(IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcBuildingSystemTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBuildingSystem::declaration() const { return *IfcBuildingSystem_type; } Type::Enum IfcBuildingSystem::Class() { return Type::IfcBuildingSystem; } -IfcBuildingSystem::IfcBuildingSystem(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingSystem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBuildingSystem::IfcBuildingSystem(std::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< IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum > v6_PredefinedType) : 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); } if (v6_PredefinedType) { e->setArgument(5,*v6_PredefinedType,IfcBuildingSystemTypeEnum::ToString(*v6_PredefinedType)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcBuildingSystem::IfcBuildingSystem(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBuildingSystem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBuildingSystem::IfcBuildingSystem(std::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< IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum > v6_PredefinedType) : 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); } if (v6_PredefinedType) { e->setArgument(5,*v6_PredefinedType,IfcBuildingSystemTypeEnum::ToString(*v6_PredefinedType)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBurner -bool IfcBurner::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcBurnerTypeEnum::IfcBurnerTypeEnum IfcBurner::PredefinedType() const { return IfcBurnerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcBurner::setPredefinedType(IfcBurnerTypeEnum::IfcBurnerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcBurnerTypeEnum::ToString(v)); } -bool IfcBurner::is(Type::Enum v) const { return v == Type::IfcBurner || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcBurner::type() const { return Type::IfcBurner; } +bool IfcBurner::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcBurnerTypeEnum::IfcBurnerTypeEnum IfcBurner::PredefinedType() const { return IfcBurnerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcBurner::setPredefinedType(IfcBurnerTypeEnum::IfcBurnerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcBurnerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBurner::declaration() const { return *IfcBurner_type; } Type::Enum IfcBurner::Class() { return Type::IfcBurner; } -IfcBurner::IfcBurner(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBurner)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBurner::IfcBurner(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBurnerTypeEnum::IfcBurnerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcBurnerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcBurner::IfcBurner(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBurner)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBurner::IfcBurner(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBurnerTypeEnum::IfcBurnerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcBurnerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcBurnerType -IfcBurnerTypeEnum::IfcBurnerTypeEnum IfcBurnerType::PredefinedType() const { return IfcBurnerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcBurnerType::setPredefinedType(IfcBurnerTypeEnum::IfcBurnerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcBurnerTypeEnum::ToString(v)); } -bool IfcBurnerType::is(Type::Enum v) const { return v == Type::IfcBurnerType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcBurnerType::type() const { return Type::IfcBurnerType; } +IfcBurnerTypeEnum::IfcBurnerTypeEnum IfcBurnerType::PredefinedType() const { return IfcBurnerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcBurnerType::setPredefinedType(IfcBurnerTypeEnum::IfcBurnerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcBurnerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcBurnerType::declaration() const { return *IfcBurnerType_type; } Type::Enum IfcBurnerType::Class() { return Type::IfcBurnerType; } -IfcBurnerType::IfcBurnerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBurnerType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcBurnerType::IfcBurnerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBurnerTypeEnum::IfcBurnerTypeEnum 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,IfcBurnerTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcBurnerType::IfcBurnerType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcBurnerType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcBurnerType::IfcBurnerType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBurnerTypeEnum::IfcBurnerTypeEnum 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,IfcBurnerTypeEnum::ToString(v10_PredefinedType)); 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::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); } + + +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) : 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); } 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) : 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); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCableCarrierFitting -bool IfcCableCarrierFitting::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFitting::PredefinedType() const { return IfcCableCarrierFittingTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCableCarrierFitting::setPredefinedType(IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCableCarrierFittingTypeEnum::ToString(v)); } -bool IfcCableCarrierFitting::is(Type::Enum v) const { return v == Type::IfcCableCarrierFitting || IfcFlowFitting::is(v); } -Type::Enum IfcCableCarrierFitting::type() const { return Type::IfcCableCarrierFitting; } +bool IfcCableCarrierFitting::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFitting::PredefinedType() const { return IfcCableCarrierFittingTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCableCarrierFitting::setPredefinedType(IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCableCarrierFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableCarrierFitting::declaration() const { return *IfcCableCarrierFitting_type; } Type::Enum IfcCableCarrierFitting::Class() { return Type::IfcCableCarrierFitting; } -IfcCableCarrierFitting::IfcCableCarrierFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierFitting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableCarrierFitting::IfcCableCarrierFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableCarrierFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCableCarrierFitting::IfcCableCarrierFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierFitting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableCarrierFitting::IfcCableCarrierFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableCarrierFittingTypeEnum::ToString(*v9_PredefinedType)); } 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 IfcCableCarrierSegment -bool IfcCableCarrierSegment::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegment::PredefinedType() const { return IfcCableCarrierSegmentTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCableCarrierSegment::setPredefinedType(IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCableCarrierSegmentTypeEnum::ToString(v)); } -bool IfcCableCarrierSegment::is(Type::Enum v) const { return v == Type::IfcCableCarrierSegment || IfcFlowSegment::is(v); } -Type::Enum IfcCableCarrierSegment::type() const { return Type::IfcCableCarrierSegment; } +bool IfcCableCarrierSegment::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegment::PredefinedType() const { return IfcCableCarrierSegmentTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCableCarrierSegment::setPredefinedType(IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCableCarrierSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableCarrierSegment::declaration() const { return *IfcCableCarrierSegment_type; } Type::Enum IfcCableCarrierSegment::Class() { return Type::IfcCableCarrierSegment; } -IfcCableCarrierSegment::IfcCableCarrierSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableCarrierSegment::IfcCableCarrierSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableCarrierSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCableCarrierSegment::IfcCableCarrierSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableCarrierSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableCarrierSegment::IfcCableCarrierSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableCarrierSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcCableFitting -bool IfcCableFitting::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCableFittingTypeEnum::IfcCableFittingTypeEnum IfcCableFitting::PredefinedType() const { return IfcCableFittingTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCableFitting::setPredefinedType(IfcCableFittingTypeEnum::IfcCableFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCableFittingTypeEnum::ToString(v)); } -bool IfcCableFitting::is(Type::Enum v) const { return v == Type::IfcCableFitting || IfcFlowFitting::is(v); } -Type::Enum IfcCableFitting::type() const { return Type::IfcCableFitting; } +bool IfcCableFitting::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCableFittingTypeEnum::IfcCableFittingTypeEnum IfcCableFitting::PredefinedType() const { return IfcCableFittingTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCableFitting::setPredefinedType(IfcCableFittingTypeEnum::IfcCableFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCableFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableFitting::declaration() const { return *IfcCableFitting_type; } Type::Enum IfcCableFitting::Class() { return Type::IfcCableFitting; } -IfcCableFitting::IfcCableFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableFitting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableFitting::IfcCableFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableFittingTypeEnum::IfcCableFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCableFitting::IfcCableFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableFitting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableFitting::IfcCableFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableFittingTypeEnum::IfcCableFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCableFittingType -IfcCableFittingTypeEnum::IfcCableFittingTypeEnum IfcCableFittingType::PredefinedType() const { return IfcCableFittingTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCableFittingType::setPredefinedType(IfcCableFittingTypeEnum::IfcCableFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCableFittingTypeEnum::ToString(v)); } -bool IfcCableFittingType::is(Type::Enum v) const { return v == Type::IfcCableFittingType || IfcFlowFittingType::is(v); } -Type::Enum IfcCableFittingType::type() const { return Type::IfcCableFittingType; } +IfcCableFittingTypeEnum::IfcCableFittingTypeEnum IfcCableFittingType::PredefinedType() const { return IfcCableFittingTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCableFittingType::setPredefinedType(IfcCableFittingTypeEnum::IfcCableFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCableFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableFittingType::declaration() const { return *IfcCableFittingType_type; } Type::Enum IfcCableFittingType::Class() { return Type::IfcCableFittingType; } -IfcCableFittingType::IfcCableFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableFittingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableFittingType::IfcCableFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableFittingTypeEnum::IfcCableFittingTypeEnum 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,IfcCableFittingTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCableFittingType::IfcCableFittingType(IfcAbstractEntity* e) : IfcFlowFittingType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableFittingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableFittingType::IfcCableFittingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableFittingTypeEnum::IfcCableFittingTypeEnum 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,IfcCableFittingTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCableSegment -bool IfcCableSegment::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegment::PredefinedType() const { return IfcCableSegmentTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCableSegment::setPredefinedType(IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCableSegmentTypeEnum::ToString(v)); } -bool IfcCableSegment::is(Type::Enum v) const { return v == Type::IfcCableSegment || IfcFlowSegment::is(v); } -Type::Enum IfcCableSegment::type() const { return Type::IfcCableSegment; } +bool IfcCableSegment::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegment::PredefinedType() const { return IfcCableSegmentTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCableSegment::setPredefinedType(IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCableSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCableSegment::declaration() const { return *IfcCableSegment_type; } Type::Enum IfcCableSegment::Class() { return Type::IfcCableSegment; } -IfcCableSegment::IfcCableSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCableSegment::IfcCableSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCableSegment::IfcCableSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCableSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCableSegment::IfcCableSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCableSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 IfcCartesianPointList -bool IfcCartesianPointList::is(Type::Enum v) const { return v == Type::IfcCartesianPointList || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcCartesianPointList::type() const { return Type::IfcCartesianPointList; } + + +const IfcParse::entity& IfcCartesianPointList::declaration() const { return *IfcCartesianPointList_type; } Type::Enum IfcCartesianPointList::Class() { return Type::IfcCartesianPointList; } -IfcCartesianPointList::IfcCartesianPointList(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPointList)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianPointList::IfcCartesianPointList() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcCartesianPointList::IfcCartesianPointList(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPointList)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianPointList::IfcCartesianPointList() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCartesianPointList3D -std::vector< std::vector< double > > IfcCartesianPointList3D::CoordList() const { return *entity->getArgument(0); } -void IfcCartesianPointList3D::setCoordList(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCartesianPointList3D::is(Type::Enum v) const { return v == Type::IfcCartesianPointList3D || IfcCartesianPointList::is(v); } -Type::Enum IfcCartesianPointList3D::type() const { return Type::IfcCartesianPointList3D; } +std::vector< std::vector< double > > IfcCartesianPointList3D::CoordList() const { return *data_->getArgument(0); } +void IfcCartesianPointList3D::setCoordList(std::vector< std::vector< double > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcCartesianPointList3D::declaration() const { return *IfcCartesianPointList3D_type; } Type::Enum IfcCartesianPointList3D::Class() { return Type::IfcCartesianPointList3D; } -IfcCartesianPointList3D::IfcCartesianPointList3D(IfcAbstractEntity* e) : IfcCartesianPointList((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPointList3D)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCartesianPointList3D::IfcCartesianPointList3D(std::vector< std::vector< double > > v1_CoordList) : IfcCartesianPointList((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CoordList)); entity = e; EntityBuffer::Add(this); } +IfcCartesianPointList3D::IfcCartesianPointList3D(IfcAbstractEntity* e) : IfcCartesianPointList((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPointList3D)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCartesianPointList3D::IfcCartesianPointList3D(std::vector< std::vector< double > > v1_CoordList) : IfcCartesianPointList((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CoordList)); 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 IfcChiller -bool IfcChiller::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcChillerTypeEnum::IfcChillerTypeEnum IfcChiller::PredefinedType() const { return IfcChillerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcChiller::setPredefinedType(IfcChillerTypeEnum::IfcChillerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcChillerTypeEnum::ToString(v)); } -bool IfcChiller::is(Type::Enum v) const { return v == Type::IfcChiller || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcChiller::type() const { return Type::IfcChiller; } +bool IfcChiller::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcChillerTypeEnum::IfcChillerTypeEnum IfcChiller::PredefinedType() const { return IfcChillerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcChiller::setPredefinedType(IfcChillerTypeEnum::IfcChillerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcChillerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcChiller::declaration() const { return *IfcChiller_type; } Type::Enum IfcChiller::Class() { return Type::IfcChiller; } -IfcChiller::IfcChiller(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChiller)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcChiller::IfcChiller(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcChillerTypeEnum::IfcChillerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcChillerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcChiller::IfcChiller(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChiller)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcChiller::IfcChiller(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcChillerTypeEnum::IfcChillerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcChillerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcChimney -bool IfcChimney::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcChimneyTypeEnum::IfcChimneyTypeEnum IfcChimney::PredefinedType() const { return IfcChimneyTypeEnum::FromString(*entity->getArgument(8)); } -void IfcChimney::setPredefinedType(IfcChimneyTypeEnum::IfcChimneyTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcChimneyTypeEnum::ToString(v)); } -bool IfcChimney::is(Type::Enum v) const { return v == Type::IfcChimney || IfcBuildingElement::is(v); } -Type::Enum IfcChimney::type() const { return Type::IfcChimney; } +bool IfcChimney::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcChimneyTypeEnum::IfcChimneyTypeEnum IfcChimney::PredefinedType() const { return IfcChimneyTypeEnum::FromString(*data_->getArgument(8)); } +void IfcChimney::setPredefinedType(IfcChimneyTypeEnum::IfcChimneyTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcChimneyTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcChimney::declaration() const { return *IfcChimney_type; } Type::Enum IfcChimney::Class() { return Type::IfcChimney; } -IfcChimney::IfcChimney(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChimney)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcChimney::IfcChimney(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcChimneyTypeEnum::IfcChimneyTypeEnum > 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,IfcChimneyTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcChimney::IfcChimney(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChimney)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcChimney::IfcChimney(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcChimneyTypeEnum::IfcChimneyTypeEnum > 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,IfcChimneyTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcChimneyType -IfcChimneyTypeEnum::IfcChimneyTypeEnum IfcChimneyType::PredefinedType() const { return IfcChimneyTypeEnum::FromString(*entity->getArgument(9)); } -void IfcChimneyType::setPredefinedType(IfcChimneyTypeEnum::IfcChimneyTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcChimneyTypeEnum::ToString(v)); } -bool IfcChimneyType::is(Type::Enum v) const { return v == Type::IfcChimneyType || IfcBuildingElementType::is(v); } -Type::Enum IfcChimneyType::type() const { return Type::IfcChimneyType; } +IfcChimneyTypeEnum::IfcChimneyTypeEnum IfcChimneyType::PredefinedType() const { return IfcChimneyTypeEnum::FromString(*data_->getArgument(9)); } +void IfcChimneyType::setPredefinedType(IfcChimneyTypeEnum::IfcChimneyTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcChimneyTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcChimneyType::declaration() const { return *IfcChimneyType_type; } Type::Enum IfcChimneyType::Class() { return Type::IfcChimneyType; } -IfcChimneyType::IfcChimneyType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChimneyType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcChimneyType::IfcChimneyType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcChimneyTypeEnum::IfcChimneyTypeEnum 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,IfcChimneyTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcChimneyType::IfcChimneyType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcChimneyType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcChimneyType::IfcChimneyType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcChimneyTypeEnum::IfcChimneyTypeEnum 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,IfcChimneyTypeEnum::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 IfcCivilElement -bool IfcCivilElement::is(Type::Enum v) const { return v == Type::IfcCivilElement || IfcElement::is(v); } -Type::Enum IfcCivilElement::type() const { return Type::IfcCivilElement; } + + +const IfcParse::entity& IfcCivilElement::declaration() const { return *IfcCivilElement_type; } Type::Enum IfcCivilElement::Class() { return Type::IfcCivilElement; } -IfcCivilElement::IfcCivilElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCivilElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCivilElement::IfcCivilElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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); } +IfcCivilElement::IfcCivilElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCivilElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCivilElement::IfcCivilElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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 IfcCivilElementType -bool IfcCivilElementType::is(Type::Enum v) const { return v == Type::IfcCivilElementType || IfcElementType::is(v); } -Type::Enum IfcCivilElementType::type() const { return Type::IfcCivilElementType; } + + +const IfcParse::entity& IfcCivilElementType::declaration() const { return *IfcCivilElementType_type; } Type::Enum IfcCivilElementType::Class() { return Type::IfcCivilElementType; } -IfcCivilElementType::IfcCivilElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCivilElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCivilElementType::IfcCivilElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< 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); } +IfcCivilElementType::IfcCivilElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCivilElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCivilElementType::IfcCivilElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< 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 IfcClassification -bool IfcClassification::hasSource() const { return !entity->getArgument(0)->isNull(); } -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); } -bool IfcClassification::hasEdition() const { return !entity->getArgument(1)->isNull(); } -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(); } -std::string IfcClassification::EditionDate() const { return *entity->getArgument(2); } -void IfcClassification::setEditionDate(std::string 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); } -bool IfcClassification::hasDescription() const { return !entity->getArgument(4)->isNull(); } -std::string IfcClassification::Description() const { return *entity->getArgument(4); } -void IfcClassification::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcClassification::hasLocation() const { return !entity->getArgument(5)->isNull(); } -std::string IfcClassification::Location() const { return *entity->getArgument(5); } -void IfcClassification::setLocation(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcClassification::hasReferenceTokens() const { return !entity->getArgument(6)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcClassification::ReferenceTokens() const { return *entity->getArgument(6); } -void IfcClassification::setReferenceTokens(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcRelAssociatesClassification::list::ptr IfcClassification::ClassificationForObjects() const { return entity->getInverse(Type::IfcRelAssociatesClassification, 5)->as(); } -IfcClassificationReference::list::ptr IfcClassification::HasReferences() const { return entity->getInverse(Type::IfcClassificationReference, 3)->as(); } -bool IfcClassification::is(Type::Enum v) const { return v == Type::IfcClassification || IfcExternalInformation::is(v); } -Type::Enum IfcClassification::type() const { return Type::IfcClassification; } +bool IfcClassification::hasSource() const { return !data_->getArgument(0)->isNull(); } +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); } +bool IfcClassification::hasEdition() const { return !data_->getArgument(1)->isNull(); } +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(); } +std::string IfcClassification::EditionDate() const { return *data_->getArgument(2); } +void IfcClassification::setEditionDate(std::string 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); } +bool IfcClassification::hasDescription() const { return !data_->getArgument(4)->isNull(); } +std::string IfcClassification::Description() const { return *data_->getArgument(4); } +void IfcClassification::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcClassification::hasLocation() const { return !data_->getArgument(5)->isNull(); } +std::string IfcClassification::Location() const { return *data_->getArgument(5); } +void IfcClassification::setLocation(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcClassification::hasReferenceTokens() const { return !data_->getArgument(6)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcClassification::ReferenceTokens() const { return *data_->getArgument(6); } +void IfcClassification::setReferenceTokens(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + +IfcRelAssociatesClassification::list::ptr IfcClassification::ClassificationForObjects() const { return data_->getInverse(Type::IfcRelAssociatesClassification, 5)->as(); } +IfcClassificationReference::list::ptr IfcClassification::HasReferences() const { return data_->getInverse(Type::IfcClassificationReference, 3)->as(); } + +const IfcParse::entity& IfcClassification::declaration() const { return *IfcClassification_type; } Type::Enum IfcClassification::Class() { return Type::IfcClassification; } -IfcClassification::IfcClassification(IfcAbstractEntity* e) : IfcExternalInformation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcClassification)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcClassification::IfcClassification(boost::optional< std::string > v1_Source, boost::optional< std::string > v2_Edition, boost::optional< std::string > v3_EditionDate, std::string v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Location, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ReferenceTokens) : IfcExternalInformation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Source) { e->setArgument(0,(*v1_Source)); } else { e->setArgument(0); } if (v2_Edition) { e->setArgument(1,(*v2_Edition)); } else { e->setArgument(1); } if (v3_EditionDate) { e->setArgument(2,(*v3_EditionDate)); } else { e->setArgument(2); } e->setArgument(3,(v4_Name)); if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Location) { e->setArgument(5,(*v6_Location)); } else { e->setArgument(5); } if (v7_ReferenceTokens) { e->setArgument(6,(*v7_ReferenceTokens)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcClassification::IfcClassification(IfcAbstractEntity* e) : IfcExternalInformation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcClassification)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcClassification::IfcClassification(boost::optional< std::string > v1_Source, boost::optional< std::string > v2_Edition, boost::optional< std::string > v3_EditionDate, std::string v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Location, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ReferenceTokens) : IfcExternalInformation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Source) { e->setArgument(0,(*v1_Source)); } else { e->setArgument(0); } if (v2_Edition) { e->setArgument(1,(*v2_Edition)); } else { e->setArgument(1); } if (v3_EditionDate) { e->setArgument(2,(*v3_EditionDate)); } else { e->setArgument(2); } e->setArgument(3,(v4_Name)); if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Location) { e->setArgument(5,(*v6_Location)); } else { e->setArgument(5); } if (v7_ReferenceTokens) { e->setArgument(6,(*v7_ReferenceTokens)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcClassificationReference -bool IfcClassificationReference::hasReferencedSource() const { return !entity->getArgument(3)->isNull(); } -IfcClassificationReferenceSelect* IfcClassificationReference::ReferencedSource() const { return (IfcClassificationReferenceSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcClassificationReference::setReferencedSource(IfcClassificationReferenceSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcClassificationReference::hasDescription() const { return !entity->getArgument(4)->isNull(); } -std::string IfcClassificationReference::Description() const { return *entity->getArgument(4); } -void IfcClassificationReference::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcClassificationReference::hasSort() const { return !entity->getArgument(5)->isNull(); } -std::string IfcClassificationReference::Sort() const { return *entity->getArgument(5); } -void IfcClassificationReference::setSort(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcRelAssociatesClassification::list::ptr IfcClassificationReference::ClassificationRefForObjects() const { return entity->getInverse(Type::IfcRelAssociatesClassification, 5)->as(); } -IfcClassificationReference::list::ptr IfcClassificationReference::HasReferences() const { return entity->getInverse(Type::IfcClassificationReference, 3)->as(); } -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(); } +IfcClassificationReferenceSelect* IfcClassificationReference::ReferencedSource() const { return (IfcClassificationReferenceSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcClassificationReference::setReferencedSource(IfcClassificationReferenceSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcClassificationReference::hasDescription() const { return !data_->getArgument(4)->isNull(); } +std::string IfcClassificationReference::Description() const { return *data_->getArgument(4); } +void IfcClassificationReference::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcClassificationReference::hasSort() const { return !data_->getArgument(5)->isNull(); } +std::string IfcClassificationReference::Sort() const { return *data_->getArgument(5); } +void IfcClassificationReference::setSort(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcRelAssociatesClassification::list::ptr IfcClassificationReference::ClassificationRefForObjects() const { return data_->getInverse(Type::IfcRelAssociatesClassification, 5)->as(); } +IfcClassificationReference::list::ptr IfcClassificationReference::HasReferences() const { return data_->getInverse(Type::IfcClassificationReference, 3)->as(); } + +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_Identification, boost::optional< std::string > v3_Name, IfcClassificationReferenceSelect* v4_ReferencedSource, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Sort) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_ReferencedSource)); if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Sort) { e->setArgument(5,(*v6_Sort)); } else { e->setArgument(5); } 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_Identification, boost::optional< std::string > v3_Name, IfcClassificationReferenceSelect* v4_ReferencedSource, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Sort) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } e->setArgument(3,(v4_ReferencedSource)); if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Sort) { e->setArgument(5,(*v6_Sort)); } else { e->setArgument(5); } 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 IfcCoil -bool IfcCoil::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoil::PredefinedType() const { return IfcCoilTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCoil::setPredefinedType(IfcCoilTypeEnum::IfcCoilTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCoilTypeEnum::ToString(v)); } -bool IfcCoil::is(Type::Enum v) const { return v == Type::IfcCoil || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcCoil::type() const { return Type::IfcCoil; } +bool IfcCoil::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoil::PredefinedType() const { return IfcCoilTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCoil::setPredefinedType(IfcCoilTypeEnum::IfcCoilTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCoilTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCoil::declaration() const { return *IfcCoil_type; } Type::Enum IfcCoil::Class() { return Type::IfcCoil; } -IfcCoil::IfcCoil(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoil)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoil::IfcCoil(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCoilTypeEnum::IfcCoilTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCoilTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCoil::IfcCoil(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoil)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoil::IfcCoil(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCoilTypeEnum::IfcCoilTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCoilTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcColourRgbList -std::vector< std::vector< double > > IfcColourRgbList::ColourList() const { return *entity->getArgument(0); } -void IfcColourRgbList::setColourList(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcColourRgbList::is(Type::Enum v) const { return v == Type::IfcColourRgbList || IfcPresentationItem::is(v); } -Type::Enum IfcColourRgbList::type() const { return Type::IfcColourRgbList; } +std::vector< std::vector< double > > IfcColourRgbList::ColourList() const { return *data_->getArgument(0); } +void IfcColourRgbList::setColourList(std::vector< std::vector< double > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcColourRgbList::declaration() const { return *IfcColourRgbList_type; } Type::Enum IfcColourRgbList::Class() { return Type::IfcColourRgbList; } -IfcColourRgbList::IfcColourRgbList(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColourRgbList)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcColourRgbList::IfcColourRgbList(std::vector< std::vector< double > > v1_ColourList) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ColourList)); entity = e; EntityBuffer::Add(this); } +IfcColourRgbList::IfcColourRgbList(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColourRgbList)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcColourRgbList::IfcColourRgbList(std::vector< std::vector< double > > v1_ColourList) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ColourList)); 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((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 IfcColumn -bool IfcColumn::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumn::PredefinedType() const { return IfcColumnTypeEnum::FromString(*entity->getArgument(8)); } -void IfcColumn::setPredefinedType(IfcColumnTypeEnum::IfcColumnTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcColumnTypeEnum::ToString(v)); } -bool IfcColumn::is(Type::Enum v) const { return v == Type::IfcColumn || IfcBuildingElement::is(v); } -Type::Enum IfcColumn::type() const { return Type::IfcColumn; } +bool IfcColumn::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumn::PredefinedType() const { return IfcColumnTypeEnum::FromString(*data_->getArgument(8)); } +void IfcColumn::setPredefinedType(IfcColumnTypeEnum::IfcColumnTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcColumnTypeEnum::ToString(v)); } + + +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, boost::optional< IfcColumnTypeEnum::IfcColumnTypeEnum > 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,IfcColumnTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcColumnTypeEnum::IfcColumnTypeEnum > 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,IfcColumnTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcColumnStandardCase -bool IfcColumnStandardCase::is(Type::Enum v) const { return v == Type::IfcColumnStandardCase || IfcColumn::is(v); } -Type::Enum IfcColumnStandardCase::type() const { return Type::IfcColumnStandardCase; } + + +const IfcParse::entity& IfcColumnStandardCase::declaration() const { return *IfcColumnStandardCase_type; } Type::Enum IfcColumnStandardCase::Class() { return Type::IfcColumnStandardCase; } -IfcColumnStandardCase::IfcColumnStandardCase(IfcAbstractEntity* e) : IfcColumn((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColumnStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcColumnStandardCase::IfcColumnStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcColumnTypeEnum::IfcColumnTypeEnum > v9_PredefinedType) : IfcColumn((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcColumnTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcColumnStandardCase::IfcColumnStandardCase(IfcAbstractEntity* e) : IfcColumn((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColumnStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcColumnStandardCase::IfcColumnStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcColumnTypeEnum::IfcColumnTypeEnum > v9_PredefinedType) : IfcColumn((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcColumnTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcCommunicationsAppliance -bool IfcCommunicationsAppliance::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum IfcCommunicationsAppliance::PredefinedType() const { return IfcCommunicationsApplianceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCommunicationsAppliance::setPredefinedType(IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCommunicationsApplianceTypeEnum::ToString(v)); } -bool IfcCommunicationsAppliance::is(Type::Enum v) const { return v == Type::IfcCommunicationsAppliance || IfcFlowTerminal::is(v); } -Type::Enum IfcCommunicationsAppliance::type() const { return Type::IfcCommunicationsAppliance; } +bool IfcCommunicationsAppliance::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum IfcCommunicationsAppliance::PredefinedType() const { return IfcCommunicationsApplianceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCommunicationsAppliance::setPredefinedType(IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCommunicationsApplianceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCommunicationsAppliance::declaration() const { return *IfcCommunicationsAppliance_type; } Type::Enum IfcCommunicationsAppliance::Class() { return Type::IfcCommunicationsAppliance; } -IfcCommunicationsAppliance::IfcCommunicationsAppliance(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCommunicationsAppliance)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCommunicationsAppliance::IfcCommunicationsAppliance(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCommunicationsApplianceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCommunicationsAppliance::IfcCommunicationsAppliance(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCommunicationsAppliance)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCommunicationsAppliance::IfcCommunicationsAppliance(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCommunicationsApplianceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCommunicationsApplianceType -IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum IfcCommunicationsApplianceType::PredefinedType() const { return IfcCommunicationsApplianceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcCommunicationsApplianceType::setPredefinedType(IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcCommunicationsApplianceTypeEnum::ToString(v)); } -bool IfcCommunicationsApplianceType::is(Type::Enum v) const { return v == Type::IfcCommunicationsApplianceType || IfcFlowTerminalType::is(v); } -Type::Enum IfcCommunicationsApplianceType::type() const { return Type::IfcCommunicationsApplianceType; } +IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum IfcCommunicationsApplianceType::PredefinedType() const { return IfcCommunicationsApplianceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcCommunicationsApplianceType::setPredefinedType(IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcCommunicationsApplianceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCommunicationsApplianceType::declaration() const { return *IfcCommunicationsApplianceType_type; } Type::Enum IfcCommunicationsApplianceType::Class() { return Type::IfcCommunicationsApplianceType; } -IfcCommunicationsApplianceType::IfcCommunicationsApplianceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCommunicationsApplianceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCommunicationsApplianceType::IfcCommunicationsApplianceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum 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,IfcCommunicationsApplianceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCommunicationsApplianceType::IfcCommunicationsApplianceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCommunicationsApplianceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCommunicationsApplianceType::IfcCommunicationsApplianceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum 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,IfcCommunicationsApplianceTypeEnum::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 IfcComplexPropertyTemplate -bool IfcComplexPropertyTemplate::hasUsageName() const { return !entity->getArgument(4)->isNull(); } -std::string IfcComplexPropertyTemplate::UsageName() const { return *entity->getArgument(4); } -void IfcComplexPropertyTemplate::setUsageName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcComplexPropertyTemplate::hasTemplateType() const { return !entity->getArgument(5)->isNull(); } -IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum IfcComplexPropertyTemplate::TemplateType() const { return IfcComplexPropertyTemplateTypeEnum::FromString(*entity->getArgument(5)); } -void IfcComplexPropertyTemplate::setTemplateType(IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcComplexPropertyTemplateTypeEnum::ToString(v)); } -bool IfcComplexPropertyTemplate::hasHasPropertyTemplates() const { return !entity->getArgument(6)->isNull(); } -IfcTemplatedEntityList< IfcPropertyTemplate >::ptr IfcComplexPropertyTemplate::HasPropertyTemplates() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcComplexPropertyTemplate::setHasPropertyTemplates(IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -bool IfcComplexPropertyTemplate::is(Type::Enum v) const { return v == Type::IfcComplexPropertyTemplate || IfcPropertyTemplate::is(v); } -Type::Enum IfcComplexPropertyTemplate::type() const { return Type::IfcComplexPropertyTemplate; } +bool IfcComplexPropertyTemplate::hasUsageName() const { return !data_->getArgument(4)->isNull(); } +std::string IfcComplexPropertyTemplate::UsageName() const { return *data_->getArgument(4); } +void IfcComplexPropertyTemplate::setUsageName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcComplexPropertyTemplate::hasTemplateType() const { return !data_->getArgument(5)->isNull(); } +IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum IfcComplexPropertyTemplate::TemplateType() const { return IfcComplexPropertyTemplateTypeEnum::FromString(*data_->getArgument(5)); } +void IfcComplexPropertyTemplate::setTemplateType(IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcComplexPropertyTemplateTypeEnum::ToString(v)); } +bool IfcComplexPropertyTemplate::hasHasPropertyTemplates() const { return !data_->getArgument(6)->isNull(); } +IfcTemplatedEntityList< IfcPropertyTemplate >::ptr IfcComplexPropertyTemplate::HasPropertyTemplates() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcComplexPropertyTemplate::setHasPropertyTemplates(IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } + + +const IfcParse::entity& IfcComplexPropertyTemplate::declaration() const { return *IfcComplexPropertyTemplate_type; } Type::Enum IfcComplexPropertyTemplate::Class() { return Type::IfcComplexPropertyTemplate; } -IfcComplexPropertyTemplate::IfcComplexPropertyTemplate(IfcAbstractEntity* e) : IfcPropertyTemplate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcComplexPropertyTemplate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcComplexPropertyTemplate::IfcComplexPropertyTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_UsageName, boost::optional< IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum > v6_TemplateType, boost::optional< IfcTemplatedEntityList< IfcPropertyTemplate >::ptr > v7_HasPropertyTemplates) : IfcPropertyTemplate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_UsageName) { e->setArgument(4,(*v5_UsageName)); } else { e->setArgument(4); } if (v6_TemplateType) { e->setArgument(5,*v6_TemplateType,IfcComplexPropertyTemplateTypeEnum::ToString(*v6_TemplateType)); } else { e->setArgument(5); } if (v7_HasPropertyTemplates) { e->setArgument(6,(*v7_HasPropertyTemplates)->generalize()); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcComplexPropertyTemplate::IfcComplexPropertyTemplate(IfcAbstractEntity* e) : IfcPropertyTemplate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcComplexPropertyTemplate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcComplexPropertyTemplate::IfcComplexPropertyTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_UsageName, boost::optional< IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum > v6_TemplateType, boost::optional< IfcTemplatedEntityList< IfcPropertyTemplate >::ptr > v7_HasPropertyTemplates) : IfcPropertyTemplate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_UsageName) { e->setArgument(4,(*v5_UsageName)); } else { e->setArgument(4); } if (v6_TemplateType) { e->setArgument(5,*v6_TemplateType,IfcComplexPropertyTemplateTypeEnum::ToString(*v6_TemplateType)); } else { e->setArgument(5); } if (v7_HasPropertyTemplates) { e->setArgument(6,(*v7_HasPropertyTemplates)->generalize()); } else { e->setArgument(6); } 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 IfcCompositeCurveOnSurface -bool IfcCompositeCurveOnSurface::is(Type::Enum v) const { return v == Type::IfcCompositeCurveOnSurface || IfcCompositeCurve::is(v); } -Type::Enum IfcCompositeCurveOnSurface::type() const { return Type::IfcCompositeCurveOnSurface; } + + +const IfcParse::entity& IfcCompositeCurveOnSurface::declaration() const { return *IfcCompositeCurveOnSurface_type; } Type::Enum IfcCompositeCurveOnSurface::Class() { return Type::IfcCompositeCurveOnSurface; } -IfcCompositeCurveOnSurface::IfcCompositeCurveOnSurface(IfcAbstractEntity* e) : IfcCompositeCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeCurveOnSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCompositeCurveOnSurface::IfcCompositeCurveOnSurface(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); } +IfcCompositeCurveOnSurface::IfcCompositeCurveOnSurface(IfcAbstractEntity* e) : IfcCompositeCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompositeCurveOnSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCompositeCurveOnSurface::IfcCompositeCurveOnSurface(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 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 IfcCompressor -bool IfcCompressor::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressor::PredefinedType() const { return IfcCompressorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCompressor::setPredefinedType(IfcCompressorTypeEnum::IfcCompressorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCompressorTypeEnum::ToString(v)); } -bool IfcCompressor::is(Type::Enum v) const { return v == Type::IfcCompressor || IfcFlowMovingDevice::is(v); } -Type::Enum IfcCompressor::type() const { return Type::IfcCompressor; } +bool IfcCompressor::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressor::PredefinedType() const { return IfcCompressorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCompressor::setPredefinedType(IfcCompressorTypeEnum::IfcCompressorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCompressorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCompressor::declaration() const { return *IfcCompressor_type; } Type::Enum IfcCompressor::Class() { return Type::IfcCompressor; } -IfcCompressor::IfcCompressor(IfcAbstractEntity* e) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompressor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCompressor::IfcCompressor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCompressorTypeEnum::IfcCompressorTypeEnum > v9_PredefinedType) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCompressorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCompressor::IfcCompressor(IfcAbstractEntity* e) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCompressor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCompressor::IfcCompressor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCompressorTypeEnum::IfcCompressorTypeEnum > v9_PredefinedType) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCompressorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcCondenser -bool IfcCondenser::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenser::PredefinedType() const { return IfcCondenserTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCondenser::setPredefinedType(IfcCondenserTypeEnum::IfcCondenserTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCondenserTypeEnum::ToString(v)); } -bool IfcCondenser::is(Type::Enum v) const { return v == Type::IfcCondenser || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcCondenser::type() const { return Type::IfcCondenser; } +bool IfcCondenser::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenser::PredefinedType() const { return IfcCondenserTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCondenser::setPredefinedType(IfcCondenserTypeEnum::IfcCondenserTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCondenserTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCondenser::declaration() const { return *IfcCondenser_type; } Type::Enum IfcCondenser::Class() { return Type::IfcCondenser; } -IfcCondenser::IfcCondenser(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCondenser)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCondenser::IfcCondenser(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCondenserTypeEnum::IfcCondenserTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCondenserTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCondenser::IfcCondenser(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCondenser)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCondenser::IfcCondenser(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCondenserTypeEnum::IfcCondenserTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCondenserTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 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 IfcConnectionVolumeGeometry -IfcSolidOrShell* IfcConnectionVolumeGeometry::VolumeOnRelatingElement() const { return (IfcSolidOrShell*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcConnectionVolumeGeometry::setVolumeOnRelatingElement(IfcSolidOrShell* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcConnectionVolumeGeometry::hasVolumeOnRelatedElement() const { return !entity->getArgument(1)->isNull(); } -IfcSolidOrShell* IfcConnectionVolumeGeometry::VolumeOnRelatedElement() const { return (IfcSolidOrShell*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcConnectionVolumeGeometry::setVolumeOnRelatedElement(IfcSolidOrShell* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcConnectionVolumeGeometry::is(Type::Enum v) const { return v == Type::IfcConnectionVolumeGeometry || IfcConnectionGeometry::is(v); } -Type::Enum IfcConnectionVolumeGeometry::type() const { return Type::IfcConnectionVolumeGeometry; } +IfcSolidOrShell* IfcConnectionVolumeGeometry::VolumeOnRelatingElement() const { return (IfcSolidOrShell*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcConnectionVolumeGeometry::setVolumeOnRelatingElement(IfcSolidOrShell* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcConnectionVolumeGeometry::hasVolumeOnRelatedElement() const { return !data_->getArgument(1)->isNull(); } +IfcSolidOrShell* IfcConnectionVolumeGeometry::VolumeOnRelatedElement() const { return (IfcSolidOrShell*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcConnectionVolumeGeometry::setVolumeOnRelatedElement(IfcSolidOrShell* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcConnectionVolumeGeometry::declaration() const { return *IfcConnectionVolumeGeometry_type; } Type::Enum IfcConnectionVolumeGeometry::Class() { return Type::IfcConnectionVolumeGeometry; } -IfcConnectionVolumeGeometry::IfcConnectionVolumeGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionVolumeGeometry)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConnectionVolumeGeometry::IfcConnectionVolumeGeometry(IfcSolidOrShell* v1_VolumeOnRelatingElement, IfcSolidOrShell* v2_VolumeOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VolumeOnRelatingElement)); e->setArgument(1,(v2_VolumeOnRelatedElement)); entity = e; EntityBuffer::Add(this); } +IfcConnectionVolumeGeometry::IfcConnectionVolumeGeometry(IfcAbstractEntity* e) : IfcConnectionGeometry((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConnectionVolumeGeometry)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConnectionVolumeGeometry::IfcConnectionVolumeGeometry(IfcSolidOrShell* v1_VolumeOnRelatingElement, IfcSolidOrShell* v2_VolumeOnRelatedElement) : IfcConnectionGeometry((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VolumeOnRelatingElement)); e->setArgument(1,(v2_VolumeOnRelatedElement)); 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(); } -std::string IfcConstraint::CreationTime() const { return *entity->getArgument(5); } -void IfcConstraint::setCreationTime(std::string 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); } -IfcExternalReferenceRelationship::list::ptr IfcConstraint::HasExternalReferences() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -IfcResourceConstraintRelationship::list::ptr IfcConstraint::PropertiesForConstraint() const { return entity->getInverse(Type::IfcResourceConstraintRelationship, 2)->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(); } +std::string IfcConstraint::CreationTime() const { return *data_->getArgument(5); } +void IfcConstraint::setCreationTime(std::string 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); } + +IfcExternalReferenceRelationship::list::ptr IfcConstraint::HasExternalReferences() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } +IfcResourceConstraintRelationship::list::ptr IfcConstraint::PropertiesForConstraint() const { return data_->getInverse(Type::IfcResourceConstraintRelationship, 2)->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, boost::optional< std::string > 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)); if (v6_CreationTime) { e->setArgument(5,(*v6_CreationTime)); } else { e->setArgument(5); } 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, boost::optional< std::string > 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)); if (v6_CreationTime) { e->setArgument(5,(*v6_CreationTime)); } else { e->setArgument(5); } if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionEquipmentResource -bool IfcConstructionEquipmentResource::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum IfcConstructionEquipmentResource::PredefinedType() const { return IfcConstructionEquipmentResourceTypeEnum::FromString(*entity->getArgument(10)); } -void IfcConstructionEquipmentResource::setPredefinedType(IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcConstructionEquipmentResourceTypeEnum::ToString(v)); } -bool IfcConstructionEquipmentResource::is(Type::Enum v) const { return v == Type::IfcConstructionEquipmentResource || IfcConstructionResource::is(v); } -Type::Enum IfcConstructionEquipmentResource::type() const { return Type::IfcConstructionEquipmentResource; } +bool IfcConstructionEquipmentResource::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum IfcConstructionEquipmentResource::PredefinedType() const { return IfcConstructionEquipmentResourceTypeEnum::FromString(*data_->getArgument(10)); } +void IfcConstructionEquipmentResource::setPredefinedType(IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcConstructionEquipmentResourceTypeEnum::ToString(v)); } + + +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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcConstructionEquipmentResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcConstructionEquipmentResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionEquipmentResourceType -IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum IfcConstructionEquipmentResourceType::PredefinedType() const { return IfcConstructionEquipmentResourceTypeEnum::FromString(*entity->getArgument(11)); } -void IfcConstructionEquipmentResourceType::setPredefinedType(IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcConstructionEquipmentResourceTypeEnum::ToString(v)); } -bool IfcConstructionEquipmentResourceType::is(Type::Enum v) const { return v == Type::IfcConstructionEquipmentResourceType || IfcConstructionResourceType::is(v); } -Type::Enum IfcConstructionEquipmentResourceType::type() const { return Type::IfcConstructionEquipmentResourceType; } +IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum IfcConstructionEquipmentResourceType::PredefinedType() const { return IfcConstructionEquipmentResourceTypeEnum::FromString(*data_->getArgument(11)); } +void IfcConstructionEquipmentResourceType::setPredefinedType(IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcConstructionEquipmentResourceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcConstructionEquipmentResourceType::declaration() const { return *IfcConstructionEquipmentResourceType_type; } Type::Enum IfcConstructionEquipmentResourceType::Class() { return Type::IfcConstructionEquipmentResourceType; } -IfcConstructionEquipmentResourceType::IfcConstructionEquipmentResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionEquipmentResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionEquipmentResourceType::IfcConstructionEquipmentResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcConstructionEquipmentResourceTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcConstructionEquipmentResourceType::IfcConstructionEquipmentResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionEquipmentResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionEquipmentResourceType::IfcConstructionEquipmentResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcConstructionEquipmentResourceTypeEnum::ToString(v12_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionMaterialResource -bool IfcConstructionMaterialResource::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum IfcConstructionMaterialResource::PredefinedType() const { return IfcConstructionMaterialResourceTypeEnum::FromString(*entity->getArgument(10)); } -void IfcConstructionMaterialResource::setPredefinedType(IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcConstructionMaterialResourceTypeEnum::ToString(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::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum IfcConstructionMaterialResource::PredefinedType() const { return IfcConstructionMaterialResourceTypeEnum::FromString(*data_->getArgument(10)); } +void IfcConstructionMaterialResource::setPredefinedType(IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcConstructionMaterialResourceTypeEnum::ToString(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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcConstructionMaterialResourceTypeEnum::ToString(*v11_PredefinedType)); } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcConstructionMaterialResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionMaterialResourceType -IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum IfcConstructionMaterialResourceType::PredefinedType() const { return IfcConstructionMaterialResourceTypeEnum::FromString(*entity->getArgument(11)); } -void IfcConstructionMaterialResourceType::setPredefinedType(IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcConstructionMaterialResourceTypeEnum::ToString(v)); } -bool IfcConstructionMaterialResourceType::is(Type::Enum v) const { return v == Type::IfcConstructionMaterialResourceType || IfcConstructionResourceType::is(v); } -Type::Enum IfcConstructionMaterialResourceType::type() const { return Type::IfcConstructionMaterialResourceType; } +IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum IfcConstructionMaterialResourceType::PredefinedType() const { return IfcConstructionMaterialResourceTypeEnum::FromString(*data_->getArgument(11)); } +void IfcConstructionMaterialResourceType::setPredefinedType(IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcConstructionMaterialResourceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcConstructionMaterialResourceType::declaration() const { return *IfcConstructionMaterialResourceType_type; } Type::Enum IfcConstructionMaterialResourceType::Class() { return Type::IfcConstructionMaterialResourceType; } -IfcConstructionMaterialResourceType::IfcConstructionMaterialResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionMaterialResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionMaterialResourceType::IfcConstructionMaterialResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcConstructionMaterialResourceTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcConstructionMaterialResourceType::IfcConstructionMaterialResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionMaterialResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionMaterialResourceType::IfcConstructionMaterialResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcConstructionMaterialResourceTypeEnum::ToString(v12_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionProductResource -bool IfcConstructionProductResource::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum IfcConstructionProductResource::PredefinedType() const { return IfcConstructionProductResourceTypeEnum::FromString(*entity->getArgument(10)); } -void IfcConstructionProductResource::setPredefinedType(IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcConstructionProductResourceTypeEnum::ToString(v)); } -bool IfcConstructionProductResource::is(Type::Enum v) const { return v == Type::IfcConstructionProductResource || IfcConstructionResource::is(v); } -Type::Enum IfcConstructionProductResource::type() const { return Type::IfcConstructionProductResource; } +bool IfcConstructionProductResource::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum IfcConstructionProductResource::PredefinedType() const { return IfcConstructionProductResourceTypeEnum::FromString(*data_->getArgument(10)); } +void IfcConstructionProductResource::setPredefinedType(IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcConstructionProductResourceTypeEnum::ToString(v)); } + + +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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcConstructionProductResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcConstructionProductResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionProductResourceType -IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum IfcConstructionProductResourceType::PredefinedType() const { return IfcConstructionProductResourceTypeEnum::FromString(*entity->getArgument(11)); } -void IfcConstructionProductResourceType::setPredefinedType(IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcConstructionProductResourceTypeEnum::ToString(v)); } -bool IfcConstructionProductResourceType::is(Type::Enum v) const { return v == Type::IfcConstructionProductResourceType || IfcConstructionResourceType::is(v); } -Type::Enum IfcConstructionProductResourceType::type() const { return Type::IfcConstructionProductResourceType; } +IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum IfcConstructionProductResourceType::PredefinedType() const { return IfcConstructionProductResourceTypeEnum::FromString(*data_->getArgument(11)); } +void IfcConstructionProductResourceType::setPredefinedType(IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcConstructionProductResourceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcConstructionProductResourceType::declaration() const { return *IfcConstructionProductResourceType_type; } Type::Enum IfcConstructionProductResourceType::Class() { return Type::IfcConstructionProductResourceType; } -IfcConstructionProductResourceType::IfcConstructionProductResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionProductResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionProductResourceType::IfcConstructionProductResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcConstructionProductResourceTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcConstructionProductResourceType::IfcConstructionProductResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionProductResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionProductResourceType::IfcConstructionProductResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcConstructionProductResourceTypeEnum::ToString(v12_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionResource -bool IfcConstructionResource::hasUsage() const { return !entity->getArgument(7)->isNull(); } -IfcResourceTime* IfcConstructionResource::Usage() const { return (IfcResourceTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcConstructionResource::setUsage(IfcResourceTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcConstructionResource::hasBaseCosts() const { return !entity->getArgument(8)->isNull(); } -IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcConstructionResource::BaseCosts() const { IfcEntityList::ptr es = *entity->getArgument(8); return es->as(); } -void IfcConstructionResource::setBaseCosts(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v->generalize()); } -bool IfcConstructionResource::hasBaseQuantity() const { return !entity->getArgument(9)->isNull(); } -IfcPhysicalQuantity* IfcConstructionResource::BaseQuantity() const { return (IfcPhysicalQuantity*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcConstructionResource::setBaseQuantity(IfcPhysicalQuantity* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,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::hasUsage() const { return !data_->getArgument(7)->isNull(); } +IfcResourceTime* IfcConstructionResource::Usage() const { return (IfcResourceTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcConstructionResource::setUsage(IfcResourceTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcConstructionResource::hasBaseCosts() const { return !data_->getArgument(8)->isNull(); } +IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcConstructionResource::BaseCosts() const { IfcEntityList::ptr es = *data_->getArgument(8); return es->as(); } +void IfcConstructionResource::setBaseCosts(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v->generalize()); } +bool IfcConstructionResource::hasBaseQuantity() const { return !data_->getArgument(9)->isNull(); } +IfcPhysicalQuantity* IfcConstructionResource::BaseQuantity() const { return (IfcPhysicalQuantity*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcConstructionResource::setBaseQuantity(IfcPhysicalQuantity* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcConstructionResourceType -bool IfcConstructionResourceType::hasBaseCosts() const { return !entity->getArgument(9)->isNull(); } -IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcConstructionResourceType::BaseCosts() const { IfcEntityList::ptr es = *entity->getArgument(9); return es->as(); } -void IfcConstructionResourceType::setBaseCosts(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v->generalize()); } -bool IfcConstructionResourceType::hasBaseQuantity() const { return !entity->getArgument(10)->isNull(); } -IfcPhysicalQuantity* IfcConstructionResourceType::BaseQuantity() const { return (IfcPhysicalQuantity*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcConstructionResourceType::setBaseQuantity(IfcPhysicalQuantity* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcConstructionResourceType::is(Type::Enum v) const { return v == Type::IfcConstructionResourceType || IfcTypeResource::is(v); } -Type::Enum IfcConstructionResourceType::type() const { return Type::IfcConstructionResourceType; } +bool IfcConstructionResourceType::hasBaseCosts() const { return !data_->getArgument(9)->isNull(); } +IfcTemplatedEntityList< IfcAppliedValue >::ptr IfcConstructionResourceType::BaseCosts() const { IfcEntityList::ptr es = *data_->getArgument(9); return es->as(); } +void IfcConstructionResourceType::setBaseCosts(IfcTemplatedEntityList< IfcAppliedValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v->generalize()); } +bool IfcConstructionResourceType::hasBaseQuantity() const { return !data_->getArgument(10)->isNull(); } +IfcPhysicalQuantity* IfcConstructionResourceType::BaseQuantity() const { return (IfcPhysicalQuantity*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcConstructionResourceType::setBaseQuantity(IfcPhysicalQuantity* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcConstructionResourceType::declaration() const { return *IfcConstructionResourceType_type; } Type::Enum IfcConstructionResourceType::Class() { return Type::IfcConstructionResourceType; } -IfcConstructionResourceType::IfcConstructionResourceType(IfcAbstractEntity* e) : IfcTypeResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConstructionResourceType::IfcConstructionResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity) : IfcTypeResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); entity = e; EntityBuffer::Add(this); } +IfcConstructionResourceType::IfcConstructionResourceType(IfcAbstractEntity* e) : IfcTypeResource((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConstructionResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConstructionResourceType::IfcConstructionResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity) : IfcTypeResource((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcContext -bool IfcContext::hasObjectType() const { return !entity->getArgument(4)->isNull(); } -std::string IfcContext::ObjectType() const { return *entity->getArgument(4); } -void IfcContext::setObjectType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcContext::hasLongName() const { return !entity->getArgument(5)->isNull(); } -std::string IfcContext::LongName() const { return *entity->getArgument(5); } -void IfcContext::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcContext::hasPhase() const { return !entity->getArgument(6)->isNull(); } -std::string IfcContext::Phase() const { return *entity->getArgument(6); } -void IfcContext::setPhase(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcContext::hasRepresentationContexts() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcRepresentationContext >::ptr IfcContext::RepresentationContexts() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcContext::setRepresentationContexts(IfcTemplatedEntityList< IfcRepresentationContext >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcContext::hasUnitsInContext() const { return !entity->getArgument(8)->isNull(); } -IfcUnitAssignment* IfcContext::UnitsInContext() const { return (IfcUnitAssignment*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcContext::setUnitsInContext(IfcUnitAssignment* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcRelDefinesByProperties::list::ptr IfcContext::IsDefinedBy() const { return entity->getInverse(Type::IfcRelDefinesByProperties, 4)->as(); } -IfcRelDeclares::list::ptr IfcContext::Declares() const { return entity->getInverse(Type::IfcRelDeclares, 4)->as(); } -bool IfcContext::is(Type::Enum v) const { return v == Type::IfcContext || IfcObjectDefinition::is(v); } -Type::Enum IfcContext::type() const { return Type::IfcContext; } +bool IfcContext::hasObjectType() const { return !data_->getArgument(4)->isNull(); } +std::string IfcContext::ObjectType() const { return *data_->getArgument(4); } +void IfcContext::setObjectType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcContext::hasLongName() const { return !data_->getArgument(5)->isNull(); } +std::string IfcContext::LongName() const { return *data_->getArgument(5); } +void IfcContext::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcContext::hasPhase() const { return !data_->getArgument(6)->isNull(); } +std::string IfcContext::Phase() const { return *data_->getArgument(6); } +void IfcContext::setPhase(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcContext::hasRepresentationContexts() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcRepresentationContext >::ptr IfcContext::RepresentationContexts() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcContext::setRepresentationContexts(IfcTemplatedEntityList< IfcRepresentationContext >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcContext::hasUnitsInContext() const { return !data_->getArgument(8)->isNull(); } +IfcUnitAssignment* IfcContext::UnitsInContext() const { return (IfcUnitAssignment*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcContext::setUnitsInContext(IfcUnitAssignment* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + +IfcRelDefinesByProperties::list::ptr IfcContext::IsDefinedBy() const { return data_->getInverse(Type::IfcRelDefinesByProperties, 4)->as(); } +IfcRelDeclares::list::ptr IfcContext::Declares() const { return data_->getInverse(Type::IfcRelDeclares, 4)->as(); } + +const IfcParse::entity& IfcContext::declaration() const { return *IfcContext_type; } Type::Enum IfcContext::Class() { return Type::IfcContext; } -IfcContext::IfcContext(IfcAbstractEntity* e) : IfcObjectDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcContext)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcContext::IfcContext(std::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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : 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); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } if (v7_Phase) { e->setArgument(6,(*v7_Phase)); } else { e->setArgument(6); } if (v8_RepresentationContexts) { e->setArgument(7,(*v8_RepresentationContexts)->generalize()); } else { e->setArgument(7); } e->setArgument(8,(v9_UnitsInContext)); entity = e; EntityBuffer::Add(this); } +IfcContext::IfcContext(IfcAbstractEntity* e) : IfcObjectDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcContext)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcContext::IfcContext(std::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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : 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); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } if (v7_Phase) { e->setArgument(6,(*v7_Phase)); } else { e->setArgument(6); } if (v8_RepresentationContexts) { e->setArgument(7,(*v8_RepresentationContexts)->generalize()); } else { e->setArgument(7); } e->setArgument(8,(v9_UnitsInContext)); 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); } -IfcExternalReferenceRelationship::list::ptr IfcContextDependentUnit::HasExternalReference() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -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); } + +IfcExternalReferenceRelationship::list::ptr IfcContextDependentUnit::HasExternalReference() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } + +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 -bool IfcControl::hasIdentification() const { return !entity->getArgument(5)->isNull(); } -std::string IfcControl::Identification() const { return *entity->getArgument(5); } -void IfcControl::setIdentification(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -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; } +bool IfcControl::hasIdentification() const { return !data_->getArgument(5)->isNull(); } +std::string IfcControl::Identification() const { return *data_->getArgument(5); } +void IfcControl::setIdentification(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +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, boost::optional< std::string > v6_Identification) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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, boost::optional< std::string > v6_Identification) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcController -bool IfcController::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcControllerTypeEnum::IfcControllerTypeEnum IfcController::PredefinedType() const { return IfcControllerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcController::setPredefinedType(IfcControllerTypeEnum::IfcControllerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcControllerTypeEnum::ToString(v)); } -bool IfcController::is(Type::Enum v) const { return v == Type::IfcController || IfcDistributionControlElement::is(v); } -Type::Enum IfcController::type() const { return Type::IfcController; } +bool IfcController::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcControllerTypeEnum::IfcControllerTypeEnum IfcController::PredefinedType() const { return IfcControllerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcController::setPredefinedType(IfcControllerTypeEnum::IfcControllerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcControllerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcController::declaration() const { return *IfcController_type; } Type::Enum IfcController::Class() { return Type::IfcController; } -IfcController::IfcController(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcController)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcController::IfcController(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcControllerTypeEnum::IfcControllerTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcControllerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcController::IfcController(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcController)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcController::IfcController(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcControllerTypeEnum::IfcControllerTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcControllerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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); } -IfcExternalReferenceRelationship::list::ptr IfcConversionBasedUnit::HasExternalReference() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -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); } + +IfcExternalReferenceRelationship::list::ptr IfcConversionBasedUnit::HasExternalReference() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } + +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 IfcConversionBasedUnitWithOffset -double IfcConversionBasedUnitWithOffset::ConversionOffset() const { return *entity->getArgument(4); } -void IfcConversionBasedUnitWithOffset::setConversionOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcConversionBasedUnitWithOffset::is(Type::Enum v) const { return v == Type::IfcConversionBasedUnitWithOffset || IfcConversionBasedUnit::is(v); } -Type::Enum IfcConversionBasedUnitWithOffset::type() const { return Type::IfcConversionBasedUnitWithOffset; } +double IfcConversionBasedUnitWithOffset::ConversionOffset() const { return *data_->getArgument(4); } +void IfcConversionBasedUnitWithOffset::setConversionOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcConversionBasedUnitWithOffset::declaration() const { return *IfcConversionBasedUnitWithOffset_type; } Type::Enum IfcConversionBasedUnitWithOffset::Class() { return Type::IfcConversionBasedUnitWithOffset; } -IfcConversionBasedUnitWithOffset::IfcConversionBasedUnitWithOffset(IfcAbstractEntity* e) : IfcConversionBasedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConversionBasedUnitWithOffset)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcConversionBasedUnitWithOffset::IfcConversionBasedUnitWithOffset(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name, IfcMeasureWithUnit* v4_ConversionFactor, double v5_ConversionOffset) : IfcConversionBasedUnit((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)); e->setArgument(4,(v5_ConversionOffset)); entity = e; EntityBuffer::Add(this); } +IfcConversionBasedUnitWithOffset::IfcConversionBasedUnitWithOffset(IfcAbstractEntity* e) : IfcConversionBasedUnit((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcConversionBasedUnitWithOffset)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcConversionBasedUnitWithOffset::IfcConversionBasedUnitWithOffset(IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name, IfcMeasureWithUnit* v4_ConversionFactor, double v5_ConversionOffset) : IfcConversionBasedUnit((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)); e->setArgument(4,(v5_ConversionOffset)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCooledBeam -bool IfcCooledBeam::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeam::PredefinedType() const { return IfcCooledBeamTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCooledBeam::setPredefinedType(IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCooledBeamTypeEnum::ToString(v)); } -bool IfcCooledBeam::is(Type::Enum v) const { return v == Type::IfcCooledBeam || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcCooledBeam::type() const { return Type::IfcCooledBeam; } +bool IfcCooledBeam::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeam::PredefinedType() const { return IfcCooledBeamTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCooledBeam::setPredefinedType(IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCooledBeamTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCooledBeam::declaration() const { return *IfcCooledBeam_type; } Type::Enum IfcCooledBeam::Class() { return Type::IfcCooledBeam; } -IfcCooledBeam::IfcCooledBeam(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCooledBeam)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCooledBeam::IfcCooledBeam(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCooledBeamTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCooledBeam::IfcCooledBeam(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCooledBeam)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCooledBeam::IfcCooledBeam(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCooledBeamTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcCoolingTower -bool IfcCoolingTower::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTower::PredefinedType() const { return IfcCoolingTowerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCoolingTower::setPredefinedType(IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCoolingTowerTypeEnum::ToString(v)); } -bool IfcCoolingTower::is(Type::Enum v) const { return v == Type::IfcCoolingTower || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcCoolingTower::type() const { return Type::IfcCoolingTower; } +bool IfcCoolingTower::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTower::PredefinedType() const { return IfcCoolingTowerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCoolingTower::setPredefinedType(IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCoolingTowerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCoolingTower::declaration() const { return *IfcCoolingTower_type; } Type::Enum IfcCoolingTower::Class() { return Type::IfcCoolingTower; } -IfcCoolingTower::IfcCoolingTower(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoolingTower)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoolingTower::IfcCoolingTower(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCoolingTowerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcCoolingTower::IfcCoolingTower(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCoolingTower)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoolingTower::IfcCoolingTower(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcCoolingTowerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcCoordinateOperation -IfcCoordinateReferenceSystemSelect* IfcCoordinateOperation::SourceCRS() const { return (IfcCoordinateReferenceSystemSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCoordinateOperation::setSourceCRS(IfcCoordinateReferenceSystemSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCoordinateReferenceSystem* IfcCoordinateOperation::TargetCRS() const { return (IfcCoordinateReferenceSystem*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcCoordinateOperation::setTargetCRS(IfcCoordinateReferenceSystem* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcCoordinateOperation::is(Type::Enum v) const { return v == Type::IfcCoordinateOperation; } -Type::Enum IfcCoordinateOperation::type() const { return Type::IfcCoordinateOperation; } +IfcCoordinateReferenceSystemSelect* IfcCoordinateOperation::SourceCRS() const { return (IfcCoordinateReferenceSystemSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCoordinateOperation::setSourceCRS(IfcCoordinateReferenceSystemSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCoordinateReferenceSystem* IfcCoordinateOperation::TargetCRS() const { return (IfcCoordinateReferenceSystem*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcCoordinateOperation::setTargetCRS(IfcCoordinateReferenceSystem* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcCoordinateOperation::declaration() const { return *IfcCoordinateOperation_type; } Type::Enum IfcCoordinateOperation::Class() { return Type::IfcCoordinateOperation; } -IfcCoordinateOperation::IfcCoordinateOperation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCoordinateOperation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoordinateOperation::IfcCoordinateOperation(IfcCoordinateReferenceSystemSelect* v1_SourceCRS, IfcCoordinateReferenceSystem* v2_TargetCRS) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SourceCRS)); e->setArgument(1,(v2_TargetCRS)); entity = e; EntityBuffer::Add(this); } +IfcCoordinateOperation::IfcCoordinateOperation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCoordinateOperation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoordinateOperation::IfcCoordinateOperation(IfcCoordinateReferenceSystemSelect* v1_SourceCRS, IfcCoordinateReferenceSystem* v2_TargetCRS) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SourceCRS)); e->setArgument(1,(v2_TargetCRS)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCoordinateReferenceSystem -bool IfcCoordinateReferenceSystem::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcCoordinateReferenceSystem::Name() const { return *entity->getArgument(0); } -void IfcCoordinateReferenceSystem::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcCoordinateReferenceSystem::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcCoordinateReferenceSystem::Description() const { return *entity->getArgument(1); } -void IfcCoordinateReferenceSystem::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -std::string IfcCoordinateReferenceSystem::GeodeticDatum() const { return *entity->getArgument(2); } -void IfcCoordinateReferenceSystem::setGeodeticDatum(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcCoordinateReferenceSystem::hasVerticalDatum() const { return !entity->getArgument(3)->isNull(); } -std::string IfcCoordinateReferenceSystem::VerticalDatum() const { return *entity->getArgument(3); } -void IfcCoordinateReferenceSystem::setVerticalDatum(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcCoordinateReferenceSystem::is(Type::Enum v) const { return v == Type::IfcCoordinateReferenceSystem; } -Type::Enum IfcCoordinateReferenceSystem::type() const { return Type::IfcCoordinateReferenceSystem; } +bool IfcCoordinateReferenceSystem::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcCoordinateReferenceSystem::Name() const { return *data_->getArgument(0); } +void IfcCoordinateReferenceSystem::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcCoordinateReferenceSystem::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcCoordinateReferenceSystem::Description() const { return *data_->getArgument(1); } +void IfcCoordinateReferenceSystem::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +std::string IfcCoordinateReferenceSystem::GeodeticDatum() const { return *data_->getArgument(2); } +void IfcCoordinateReferenceSystem::setGeodeticDatum(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcCoordinateReferenceSystem::hasVerticalDatum() const { return !data_->getArgument(3)->isNull(); } +std::string IfcCoordinateReferenceSystem::VerticalDatum() const { return *data_->getArgument(3); } +void IfcCoordinateReferenceSystem::setVerticalDatum(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcCoordinateReferenceSystem::declaration() const { return *IfcCoordinateReferenceSystem_type; } Type::Enum IfcCoordinateReferenceSystem::Class() { return Type::IfcCoordinateReferenceSystem; } -IfcCoordinateReferenceSystem::IfcCoordinateReferenceSystem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCoordinateReferenceSystem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCoordinateReferenceSystem::IfcCoordinateReferenceSystem(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, std::string v3_GeodeticDatum, boost::optional< std::string > v4_VerticalDatum) : 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_GeodeticDatum)); if (v4_VerticalDatum) { e->setArgument(3,(*v4_VerticalDatum)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcCoordinateReferenceSystem::IfcCoordinateReferenceSystem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcCoordinateReferenceSystem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCoordinateReferenceSystem::IfcCoordinateReferenceSystem(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, std::string v3_GeodeticDatum, boost::optional< std::string > v4_VerticalDatum) : 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_GeodeticDatum)); if (v4_VerticalDatum) { e->setArgument(3,(*v4_VerticalDatum)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCostItem -bool IfcCostItem::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -IfcCostItemTypeEnum::IfcCostItemTypeEnum IfcCostItem::PredefinedType() const { return IfcCostItemTypeEnum::FromString(*entity->getArgument(6)); } -void IfcCostItem::setPredefinedType(IfcCostItemTypeEnum::IfcCostItemTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcCostItemTypeEnum::ToString(v)); } -bool IfcCostItem::hasCostValues() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcCostValue >::ptr IfcCostItem::CostValues() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcCostItem::setCostValues(IfcTemplatedEntityList< IfcCostValue >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcCostItem::hasCostQuantities() const { return !entity->getArgument(8)->isNull(); } -IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr IfcCostItem::CostQuantities() const { IfcEntityList::ptr es = *entity->getArgument(8); return es->as(); } -void IfcCostItem::setCostQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v->generalize()); } -bool IfcCostItem::is(Type::Enum v) const { return v == Type::IfcCostItem || IfcControl::is(v); } -Type::Enum IfcCostItem::type() const { return Type::IfcCostItem; } +bool IfcCostItem::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +IfcCostItemTypeEnum::IfcCostItemTypeEnum IfcCostItem::PredefinedType() const { return IfcCostItemTypeEnum::FromString(*data_->getArgument(6)); } +void IfcCostItem::setPredefinedType(IfcCostItemTypeEnum::IfcCostItemTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcCostItemTypeEnum::ToString(v)); } +bool IfcCostItem::hasCostValues() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcCostValue >::ptr IfcCostItem::CostValues() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcCostItem::setCostValues(IfcTemplatedEntityList< IfcCostValue >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcCostItem::hasCostQuantities() const { return !data_->getArgument(8)->isNull(); } +IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr IfcCostItem::CostQuantities() const { IfcEntityList::ptr es = *data_->getArgument(8); return es->as(); } +void IfcCostItem::setCostQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v->generalize()); } + + +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, boost::optional< std::string > v6_Identification, boost::optional< IfcCostItemTypeEnum::IfcCostItemTypeEnum > v7_PredefinedType, boost::optional< IfcTemplatedEntityList< IfcCostValue >::ptr > v8_CostValues, boost::optional< IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr > v9_CostQuantities) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcCostItemTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_CostValues) { e->setArgument(7,(*v8_CostValues)->generalize()); } else { e->setArgument(7); } if (v9_CostQuantities) { e->setArgument(8,(*v9_CostQuantities)->generalize()); } else { e->setArgument(8); } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcCostItemTypeEnum::IfcCostItemTypeEnum > v7_PredefinedType, boost::optional< IfcTemplatedEntityList< IfcCostValue >::ptr > v8_CostValues, boost::optional< IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr > v9_CostQuantities) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcCostItemTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_CostValues) { e->setArgument(7,(*v8_CostValues)->generalize()); } else { e->setArgument(7); } if (v9_CostQuantities) { e->setArgument(8,(*v9_CostQuantities)->generalize()); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCostSchedule -bool IfcCostSchedule::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostSchedule::PredefinedType() const { return IfcCostScheduleTypeEnum::FromString(*entity->getArgument(6)); } -void IfcCostSchedule::setPredefinedType(IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcCostScheduleTypeEnum::ToString(v)); } -bool IfcCostSchedule::hasStatus() const { return !entity->getArgument(7)->isNull(); } -std::string IfcCostSchedule::Status() const { return *entity->getArgument(7); } -void IfcCostSchedule::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcCostSchedule::hasSubmittedOn() const { return !entity->getArgument(8)->isNull(); } -std::string IfcCostSchedule::SubmittedOn() const { return *entity->getArgument(8); } -void IfcCostSchedule::setSubmittedOn(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcCostSchedule::hasUpdateDate() const { return !entity->getArgument(9)->isNull(); } -std::string IfcCostSchedule::UpdateDate() const { return *entity->getArgument(9); } -void IfcCostSchedule::setUpdateDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,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::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostSchedule::PredefinedType() const { return IfcCostScheduleTypeEnum::FromString(*data_->getArgument(6)); } +void IfcCostSchedule::setPredefinedType(IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcCostScheduleTypeEnum::ToString(v)); } +bool IfcCostSchedule::hasStatus() const { return !data_->getArgument(7)->isNull(); } +std::string IfcCostSchedule::Status() const { return *data_->getArgument(7); } +void IfcCostSchedule::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcCostSchedule::hasSubmittedOn() const { return !data_->getArgument(8)->isNull(); } +std::string IfcCostSchedule::SubmittedOn() const { return *data_->getArgument(8); } +void IfcCostSchedule::setSubmittedOn(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcCostSchedule::hasUpdateDate() const { return !data_->getArgument(9)->isNull(); } +std::string IfcCostSchedule::UpdateDate() const { return *data_->getArgument(9); } +void IfcCostSchedule::setUpdateDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,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, boost::optional< std::string > v6_Identification, boost::optional< IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_SubmittedOn, boost::optional< std::string > v10_UpdateDate) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcCostScheduleTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_SubmittedOn) { e->setArgument(8,(*v9_SubmittedOn)); } else { e->setArgument(8); } if (v10_UpdateDate) { e->setArgument(9,(*v10_UpdateDate)); } else { e->setArgument(9); } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_SubmittedOn, boost::optional< std::string > v10_UpdateDate) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcCostScheduleTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_SubmittedOn) { e->setArgument(8,(*v9_SubmittedOn)); } else { e->setArgument(8); } if (v10_UpdateDate) { e->setArgument(9,(*v10_UpdateDate)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCostValue -bool IfcCostValue::is(Type::Enum v) const { return v == Type::IfcCostValue || IfcAppliedValue::is(v); } -Type::Enum IfcCostValue::type() const { return Type::IfcCostValue; } + + +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, boost::optional< std::string > v5_ApplicableDate, boost::optional< std::string > v6_FixedUntilDate, boost::optional< std::string > v7_Category, boost::optional< std::string > v8_Condition, boost::optional< IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum > v9_ArithmeticOperator, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_Components) : 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)); if (v5_ApplicableDate) { e->setArgument(4,(*v5_ApplicableDate)); } else { e->setArgument(4); } if (v6_FixedUntilDate) { e->setArgument(5,(*v6_FixedUntilDate)); } else { e->setArgument(5); } if (v7_Category) { e->setArgument(6,(*v7_Category)); } else { e->setArgument(6); } if (v8_Condition) { e->setArgument(7,(*v8_Condition)); } else { e->setArgument(7); } if (v9_ArithmeticOperator) { e->setArgument(8,*v9_ArithmeticOperator,IfcArithmeticOperatorEnum::ToString(*v9_ArithmeticOperator)); } else { e->setArgument(8); } if (v10_Components) { e->setArgument(9,(*v10_Components)->generalize()); } else { e->setArgument(9); } 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, boost::optional< std::string > v5_ApplicableDate, boost::optional< std::string > v6_FixedUntilDate, boost::optional< std::string > v7_Category, boost::optional< std::string > v8_Condition, boost::optional< IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum > v9_ArithmeticOperator, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_Components) : 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)); if (v5_ApplicableDate) { e->setArgument(4,(*v5_ApplicableDate)); } else { e->setArgument(4); } if (v6_FixedUntilDate) { e->setArgument(5,(*v6_FixedUntilDate)); } else { e->setArgument(5); } if (v7_Category) { e->setArgument(6,(*v7_Category)); } else { e->setArgument(6); } if (v8_Condition) { e->setArgument(7,(*v8_Condition)); } else { e->setArgument(7); } if (v9_ArithmeticOperator) { e->setArgument(8,*v9_ArithmeticOperator,IfcArithmeticOperatorEnum::ToString(*v9_ArithmeticOperator)); } else { e->setArgument(8); } if (v10_Components) { e->setArgument(9,(*v10_Components)->generalize()); } else { e->setArgument(9); } 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::CoversElements() 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::CoversElements() 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 IfcCrewResource -bool IfcCrewResource::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum IfcCrewResource::PredefinedType() const { return IfcCrewResourceTypeEnum::FromString(*entity->getArgument(10)); } -void IfcCrewResource::setPredefinedType(IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcCrewResourceTypeEnum::ToString(v)); } -bool IfcCrewResource::is(Type::Enum v) const { return v == Type::IfcCrewResource || IfcConstructionResource::is(v); } -Type::Enum IfcCrewResource::type() const { return Type::IfcCrewResource; } +bool IfcCrewResource::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum IfcCrewResource::PredefinedType() const { return IfcCrewResourceTypeEnum::FromString(*data_->getArgument(10)); } +void IfcCrewResource::setPredefinedType(IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcCrewResourceTypeEnum::ToString(v)); } + + +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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcCrewResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcCrewResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCrewResourceType -IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum IfcCrewResourceType::PredefinedType() const { return IfcCrewResourceTypeEnum::FromString(*entity->getArgument(11)); } -void IfcCrewResourceType::setPredefinedType(IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcCrewResourceTypeEnum::ToString(v)); } -bool IfcCrewResourceType::is(Type::Enum v) const { return v == Type::IfcCrewResourceType || IfcConstructionResourceType::is(v); } -Type::Enum IfcCrewResourceType::type() const { return Type::IfcCrewResourceType; } +IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum IfcCrewResourceType::PredefinedType() const { return IfcCrewResourceTypeEnum::FromString(*data_->getArgument(11)); } +void IfcCrewResourceType::setPredefinedType(IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcCrewResourceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcCrewResourceType::declaration() const { return *IfcCrewResourceType_type; } Type::Enum IfcCrewResourceType::Class() { return Type::IfcCrewResourceType; } -IfcCrewResourceType::IfcCrewResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCrewResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCrewResourceType::IfcCrewResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcCrewResourceTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcCrewResourceType::IfcCrewResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCrewResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCrewResourceType::IfcCrewResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcCrewResourceTypeEnum::ToString(v12_PredefinedType)); 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(2))); } -void IfcCurrencyRelationship::setRelatingMonetaryUnit(IfcMonetaryUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcMonetaryUnit* IfcCurrencyRelationship::RelatedMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcCurrencyRelationship::setRelatedMonetaryUnit(IfcMonetaryUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcCurrencyRelationship::ExchangeRate() const { return *entity->getArgument(4); } -void IfcCurrencyRelationship::setExchangeRate(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcCurrencyRelationship::hasRateDateTime() const { return !entity->getArgument(5)->isNull(); } -std::string IfcCurrencyRelationship::RateDateTime() const { return *entity->getArgument(5); } -void IfcCurrencyRelationship::setRateDateTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcCurrencyRelationship::hasRateSource() const { return !entity->getArgument(6)->isNull(); } -IfcLibraryInformation* IfcCurrencyRelationship::RateSource() const { return (IfcLibraryInformation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcCurrencyRelationship::setRateSource(IfcLibraryInformation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcCurrencyRelationship::is(Type::Enum v) const { return v == Type::IfcCurrencyRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcCurrencyRelationship::type() const { return Type::IfcCurrencyRelationship; } +IfcMonetaryUnit* IfcCurrencyRelationship::RelatingMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcCurrencyRelationship::setRelatingMonetaryUnit(IfcMonetaryUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcMonetaryUnit* IfcCurrencyRelationship::RelatedMonetaryUnit() const { return (IfcMonetaryUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcCurrencyRelationship::setRelatedMonetaryUnit(IfcMonetaryUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcCurrencyRelationship::ExchangeRate() const { return *data_->getArgument(4); } +void IfcCurrencyRelationship::setExchangeRate(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcCurrencyRelationship::hasRateDateTime() const { return !data_->getArgument(5)->isNull(); } +std::string IfcCurrencyRelationship::RateDateTime() const { return *data_->getArgument(5); } +void IfcCurrencyRelationship::setRateDateTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcCurrencyRelationship::hasRateSource() const { return !data_->getArgument(6)->isNull(); } +IfcLibraryInformation* IfcCurrencyRelationship::RateSource() const { return (IfcLibraryInformation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcCurrencyRelationship::setRateSource(IfcLibraryInformation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcCurrencyRelationship::declaration() const { return *IfcCurrencyRelationship_type; } Type::Enum IfcCurrencyRelationship::Class() { return Type::IfcCurrencyRelationship; } -IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurrencyRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurrencyRelationship::IfcCurrencyRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMonetaryUnit* v3_RelatingMonetaryUnit, IfcMonetaryUnit* v4_RelatedMonetaryUnit, double v5_ExchangeRate, boost::optional< std::string > v6_RateDateTime, IfcLibraryInformation* v7_RateSource) : IfcResourceLevelRelationship((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_RelatingMonetaryUnit)); e->setArgument(3,(v4_RelatedMonetaryUnit)); e->setArgument(4,(v5_ExchangeRate)); if (v6_RateDateTime) { e->setArgument(5,(*v6_RateDateTime)); } else { e->setArgument(5); } e->setArgument(6,(v7_RateSource)); entity = e; EntityBuffer::Add(this); } +IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurrencyRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurrencyRelationship::IfcCurrencyRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMonetaryUnit* v3_RelatingMonetaryUnit, IfcMonetaryUnit* v4_RelatedMonetaryUnit, double v5_ExchangeRate, boost::optional< std::string > v6_RateDateTime, IfcLibraryInformation* v7_RateSource) : IfcResourceLevelRelationship((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_RelatingMonetaryUnit)); e->setArgument(3,(v4_RelatedMonetaryUnit)); e->setArgument(4,(v5_ExchangeRate)); if (v6_RateDateTime) { e->setArgument(5,(*v6_RateDateTime)); } else { e->setArgument(5); } e->setArgument(6,(v7_RateSource)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCurtainWall -bool IfcCurtainWall::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWall::PredefinedType() const { return IfcCurtainWallTypeEnum::FromString(*entity->getArgument(8)); } -void IfcCurtainWall::setPredefinedType(IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcCurtainWallTypeEnum::ToString(v)); } -bool IfcCurtainWall::is(Type::Enum v) const { return v == Type::IfcCurtainWall || IfcBuildingElement::is(v); } -Type::Enum IfcCurtainWall::type() const { return Type::IfcCurtainWall; } +bool IfcCurtainWall::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWall::PredefinedType() const { return IfcCurtainWallTypeEnum::FromString(*data_->getArgument(8)); } +void IfcCurtainWall::setPredefinedType(IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcCurtainWallTypeEnum::ToString(v)); } + + +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, boost::optional< IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum > 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,IfcCurtainWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum > 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,IfcCurtainWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcCurveBoundedSurface -IfcSurface* IfcCurveBoundedSurface::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcCurveBoundedSurface::setBasisSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcTemplatedEntityList< IfcBoundaryCurve >::ptr IfcCurveBoundedSurface::Boundaries() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcCurveBoundedSurface::setBoundaries(IfcTemplatedEntityList< IfcBoundaryCurve >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcCurveBoundedSurface::ImplicitOuter() const { return *entity->getArgument(2); } -void IfcCurveBoundedSurface::setImplicitOuter(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcCurveBoundedSurface::is(Type::Enum v) const { return v == Type::IfcCurveBoundedSurface || IfcBoundedSurface::is(v); } -Type::Enum IfcCurveBoundedSurface::type() const { return Type::IfcCurveBoundedSurface; } +IfcSurface* IfcCurveBoundedSurface::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcCurveBoundedSurface::setBasisSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcTemplatedEntityList< IfcBoundaryCurve >::ptr IfcCurveBoundedSurface::Boundaries() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcCurveBoundedSurface::setBoundaries(IfcTemplatedEntityList< IfcBoundaryCurve >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcCurveBoundedSurface::ImplicitOuter() const { return *data_->getArgument(2); } +void IfcCurveBoundedSurface::setImplicitOuter(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcCurveBoundedSurface::declaration() const { return *IfcCurveBoundedSurface_type; } Type::Enum IfcCurveBoundedSurface::Class() { return Type::IfcCurveBoundedSurface; } -IfcCurveBoundedSurface::IfcCurveBoundedSurface(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurveBoundedSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCurveBoundedSurface::IfcCurveBoundedSurface(IfcSurface* v1_BasisSurface, IfcTemplatedEntityList< IfcBoundaryCurve >::ptr v2_Boundaries, bool v3_ImplicitOuter) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_Boundaries)->generalize()); e->setArgument(2,(v3_ImplicitOuter)); entity = e; EntityBuffer::Add(this); } +IfcCurveBoundedSurface::IfcCurveBoundedSurface(IfcAbstractEntity* e) : IfcBoundedSurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCurveBoundedSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCurveBoundedSurface::IfcCurveBoundedSurface(IfcSurface* v1_BasisSurface, IfcTemplatedEntityList< IfcBoundaryCurve >::ptr v2_Boundaries, bool v3_ImplicitOuter) : IfcBoundedSurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_Boundaries)->generalize()); e->setArgument(2,(v3_ImplicitOuter)); 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::hasModelOrDraughting() const { return !entity->getArgument(4)->isNull(); } -bool IfcCurveStyle::ModelOrDraughting() const { return *entity->getArgument(4); } -void IfcCurveStyle::setModelOrDraughting(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcCurveStyle::hasModelOrDraughting() const { return !data_->getArgument(4)->isNull(); } +bool IfcCurveStyle::ModelOrDraughting() const { return *data_->getArgument(4); } +void IfcCurveStyle::setModelOrDraughting(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< bool > v5_ModelOrDraughting) : 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)); if (v5_ModelOrDraughting) { e->setArgument(4,(*v5_ModelOrDraughting)); } else { e->setArgument(4); } 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, boost::optional< bool > v5_ModelOrDraughting) : 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)); if (v5_ModelOrDraughting) { e->setArgument(4,(*v5_ModelOrDraughting)); } else { e->setArgument(4); } 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((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_CurveFontScaling)); entity = e; EntityBuffer::Add(this); } +IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((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_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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VisibleSegmentLength)); e->setArgument(1,(v2_InvisibleSegmentLength)); entity = e; EntityBuffer::Add(this); } +IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_VisibleSegmentLength)); e->setArgument(1,(v2_InvisibleSegmentLength)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcCylindricalSurface -double IfcCylindricalSurface::Radius() const { return *entity->getArgument(1); } -void IfcCylindricalSurface::setRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcCylindricalSurface::is(Type::Enum v) const { return v == Type::IfcCylindricalSurface || IfcElementarySurface::is(v); } -Type::Enum IfcCylindricalSurface::type() const { return Type::IfcCylindricalSurface; } +double IfcCylindricalSurface::Radius() const { return *data_->getArgument(1); } +void IfcCylindricalSurface::setRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcCylindricalSurface::declaration() const { return *IfcCylindricalSurface_type; } Type::Enum IfcCylindricalSurface::Class() { return Type::IfcCylindricalSurface; } -IfcCylindricalSurface::IfcCylindricalSurface(IfcAbstractEntity* e) : IfcElementarySurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCylindricalSurface)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcCylindricalSurface::IfcCylindricalSurface(IfcAxis2Placement3D* v1_Position, double v2_Radius) : IfcElementarySurface((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Position)); e->setArgument(1,(v2_Radius)); entity = e; EntityBuffer::Add(this); } +IfcCylindricalSurface::IfcCylindricalSurface(IfcAbstractEntity* e) : IfcElementarySurface((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCylindricalSurface)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcCylindricalSurface::IfcCylindricalSurface(IfcAxis2Placement3D* v1_Position, double v2_Radius) : IfcElementarySurface((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 IfcDamper -bool IfcDamper::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamper::PredefinedType() const { return IfcDamperTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDamper::setPredefinedType(IfcDamperTypeEnum::IfcDamperTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDamperTypeEnum::ToString(v)); } -bool IfcDamper::is(Type::Enum v) const { return v == Type::IfcDamper || IfcFlowController::is(v); } -Type::Enum IfcDamper::type() const { return Type::IfcDamper; } +bool IfcDamper::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamper::PredefinedType() const { return IfcDamperTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDamper::setPredefinedType(IfcDamperTypeEnum::IfcDamperTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDamperTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDamper::declaration() const { return *IfcDamper_type; } Type::Enum IfcDamper::Class() { return Type::IfcDamper; } -IfcDamper::IfcDamper(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDamper)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDamper::IfcDamper(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDamperTypeEnum::IfcDamperTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDamperTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDamper::IfcDamper(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDamper)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDamper::IfcDamper(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDamperTypeEnum::IfcDamperTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDamperTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 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::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum IfcDiscreteAccessory::PredefinedType() const { return IfcDiscreteAccessoryTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDiscreteAccessory::setPredefinedType(IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDiscreteAccessoryTypeEnum::ToString(v)); } -bool IfcDiscreteAccessory::is(Type::Enum v) const { return v == Type::IfcDiscreteAccessory || IfcElementComponent::is(v); } -Type::Enum IfcDiscreteAccessory::type() const { return Type::IfcDiscreteAccessory; } +bool IfcDiscreteAccessory::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum IfcDiscreteAccessory::PredefinedType() const { return IfcDiscreteAccessoryTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDiscreteAccessory::setPredefinedType(IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDiscreteAccessoryTypeEnum::ToString(v)); } + + +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, boost::optional< IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDiscreteAccessoryTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDiscreteAccessoryTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDiscreteAccessoryType -IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum IfcDiscreteAccessoryType::PredefinedType() const { return IfcDiscreteAccessoryTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDiscreteAccessoryType::setPredefinedType(IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDiscreteAccessoryTypeEnum::ToString(v)); } -bool IfcDiscreteAccessoryType::is(Type::Enum v) const { return v == Type::IfcDiscreteAccessoryType || IfcElementComponentType::is(v); } -Type::Enum IfcDiscreteAccessoryType::type() const { return Type::IfcDiscreteAccessoryType; } +IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum IfcDiscreteAccessoryType::PredefinedType() const { return IfcDiscreteAccessoryTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDiscreteAccessoryType::setPredefinedType(IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDiscreteAccessoryTypeEnum::ToString(v)); } + + +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, IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v10_PredefinedType) : 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); } e->setArgument(9,v10_PredefinedType,IfcDiscreteAccessoryTypeEnum::ToString(v10_PredefinedType)); 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, IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v10_PredefinedType) : 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); } e->setArgument(9,v10_PredefinedType,IfcDiscreteAccessoryTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionChamberElement -bool IfcDistributionChamberElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElement::PredefinedType() const { return IfcDistributionChamberElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDistributionChamberElement::setPredefinedType(IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDistributionChamberElementTypeEnum::ToString(v)); } -bool IfcDistributionChamberElement::is(Type::Enum v) const { return v == Type::IfcDistributionChamberElement || IfcDistributionFlowElement::is(v); } -Type::Enum IfcDistributionChamberElement::type() const { return Type::IfcDistributionChamberElement; } +bool IfcDistributionChamberElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElement::PredefinedType() const { return IfcDistributionChamberElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDistributionChamberElement::setPredefinedType(IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDistributionChamberElementTypeEnum::ToString(v)); } + + +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, boost::optional< IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDistributionChamberElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDistributionChamberElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcDistributionCircuit -bool IfcDistributionCircuit::is(Type::Enum v) const { return v == Type::IfcDistributionCircuit || IfcDistributionSystem::is(v); } -Type::Enum IfcDistributionCircuit::type() const { return Type::IfcDistributionCircuit; } + + +const IfcParse::entity& IfcDistributionCircuit::declaration() const { return *IfcDistributionCircuit_type; } Type::Enum IfcDistributionCircuit::Class() { return Type::IfcDistributionCircuit; } -IfcDistributionCircuit::IfcDistributionCircuit(IfcAbstractEntity* e) : IfcDistributionSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionCircuit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionCircuit::IfcDistributionCircuit(std::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< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v7_PredefinedType) : IfcDistributionSystem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcDistributionSystemEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcDistributionCircuit::IfcDistributionCircuit(IfcAbstractEntity* e) : IfcDistributionSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionCircuit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionCircuit::IfcDistributionCircuit(std::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< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v7_PredefinedType) : IfcDistributionSystem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcDistributionSystemEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionControlElement -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; } + +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) : 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); } +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) : 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 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 -IfcRelConnectsPortToElement::list::ptr IfcDistributionElement::HasPorts() const { return entity->getInverse(Type::IfcRelConnectsPortToElement, 5)->as(); } -bool IfcDistributionElement::is(Type::Enum v) const { return v == Type::IfcDistributionElement || IfcElement::is(v); } -Type::Enum IfcDistributionElement::type() const { return Type::IfcDistributionElement; } + +IfcRelConnectsPortToElement::list::ptr IfcDistributionElement::HasPorts() const { return data_->getInverse(Type::IfcRelConnectsPortToElement, 5)->as(); } + +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::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum IfcDistributionPort::PredefinedType() const { return IfcDistributionPortTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDistributionPort::setPredefinedType(IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDistributionPortTypeEnum::ToString(v)); } -bool IfcDistributionPort::hasSystemType() const { return !entity->getArgument(9)->isNull(); } -IfcDistributionSystemEnum::IfcDistributionSystemEnum IfcDistributionPort::SystemType() const { return IfcDistributionSystemEnum::FromString(*entity->getArgument(9)); } -void IfcDistributionPort::setSystemType(IfcDistributionSystemEnum::IfcDistributionSystemEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDistributionSystemEnum::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)); } +bool IfcDistributionPort::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum IfcDistributionPort::PredefinedType() const { return IfcDistributionPortTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDistributionPort::setPredefinedType(IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDistributionPortTypeEnum::ToString(v)); } +bool IfcDistributionPort::hasSystemType() const { return !data_->getArgument(9)->isNull(); } +IfcDistributionSystemEnum::IfcDistributionSystemEnum IfcDistributionPort::SystemType() const { return IfcDistributionSystemEnum::FromString(*data_->getArgument(9)); } +void IfcDistributionPort::setSystemType(IfcDistributionSystemEnum::IfcDistributionSystemEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDistributionSystemEnum::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, boost::optional< IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum > v9_PredefinedType, boost::optional< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v10_SystemType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDistributionPortTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } if (v10_SystemType) { e->setArgument(9,*v10_SystemType,IfcDistributionSystemEnum::ToString(*v10_SystemType)); } else { e->setArgument(9); } 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, boost::optional< IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum > v9_PredefinedType, boost::optional< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v10_SystemType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcDistributionPortTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } if (v10_SystemType) { e->setArgument(9,*v10_SystemType,IfcDistributionSystemEnum::ToString(*v10_SystemType)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDistributionSystem -bool IfcDistributionSystem::hasLongName() const { return !entity->getArgument(5)->isNull(); } -std::string IfcDistributionSystem::LongName() const { return *entity->getArgument(5); } -void IfcDistributionSystem::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcDistributionSystem::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -IfcDistributionSystemEnum::IfcDistributionSystemEnum IfcDistributionSystem::PredefinedType() const { return IfcDistributionSystemEnum::FromString(*entity->getArgument(6)); } -void IfcDistributionSystem::setPredefinedType(IfcDistributionSystemEnum::IfcDistributionSystemEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcDistributionSystemEnum::ToString(v)); } -bool IfcDistributionSystem::is(Type::Enum v) const { return v == Type::IfcDistributionSystem || IfcSystem::is(v); } -Type::Enum IfcDistributionSystem::type() const { return Type::IfcDistributionSystem; } +bool IfcDistributionSystem::hasLongName() const { return !data_->getArgument(5)->isNull(); } +std::string IfcDistributionSystem::LongName() const { return *data_->getArgument(5); } +void IfcDistributionSystem::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcDistributionSystem::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +IfcDistributionSystemEnum::IfcDistributionSystemEnum IfcDistributionSystem::PredefinedType() const { return IfcDistributionSystemEnum::FromString(*data_->getArgument(6)); } +void IfcDistributionSystem::setPredefinedType(IfcDistributionSystemEnum::IfcDistributionSystemEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcDistributionSystemEnum::ToString(v)); } + + +const IfcParse::entity& IfcDistributionSystem::declaration() const { return *IfcDistributionSystem_type; } Type::Enum IfcDistributionSystem::Class() { return Type::IfcDistributionSystem; } -IfcDistributionSystem::IfcDistributionSystem(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionSystem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDistributionSystem::IfcDistributionSystem(std::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< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v7_PredefinedType) : 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); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcDistributionSystemEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcDistributionSystem::IfcDistributionSystem(IfcAbstractEntity* e) : IfcSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDistributionSystem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDistributionSystem::IfcDistributionSystem(std::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< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v7_PredefinedType) : 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); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcDistributionSystemEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDocumentInformation -std::string IfcDocumentInformation::Identification() const { return *entity->getArgument(0); } -void IfcDocumentInformation::setIdentification(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::hasLocation() const { return !entity->getArgument(3)->isNull(); } -std::string IfcDocumentInformation::Location() const { return *entity->getArgument(3); } -void IfcDocumentInformation::setLocation(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -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(); } -std::string IfcDocumentInformation::CreationTime() const { return *entity->getArgument(10); } -void IfcDocumentInformation::setCreationTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcDocumentInformation::hasLastRevisionTime() const { return !entity->getArgument(11)->isNull(); } -std::string IfcDocumentInformation::LastRevisionTime() const { return *entity->getArgument(11); } -void IfcDocumentInformation::setLastRevisionTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcDocumentInformation::hasElectronicFormat() const { return !entity->getArgument(12)->isNull(); } -std::string IfcDocumentInformation::ElectronicFormat() const { return *entity->getArgument(12); } -void IfcDocumentInformation::setElectronicFormat(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcDocumentInformation::hasValidFrom() const { return !entity->getArgument(13)->isNull(); } -std::string IfcDocumentInformation::ValidFrom() const { return *entity->getArgument(13); } -void IfcDocumentInformation::setValidFrom(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcDocumentInformation::hasValidUntil() const { return !entity->getArgument(14)->isNull(); } -std::string IfcDocumentInformation::ValidUntil() const { return *entity->getArgument(14); } -void IfcDocumentInformation::setValidUntil(std::string 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)); } -IfcRelAssociatesDocument::list::ptr IfcDocumentInformation::DocumentInfoForObjects() const { return entity->getInverse(Type::IfcRelAssociatesDocument, 5)->as(); } -IfcDocumentReference::list::ptr IfcDocumentInformation::HasDocumentReferences() const { return entity->getInverse(Type::IfcDocumentReference, 4)->as(); } -IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointedTo() const { return entity->getInverse(Type::IfcDocumentInformationRelationship, 3)->as(); } -IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointer() const { return entity->getInverse(Type::IfcDocumentInformationRelationship, 2)->as(); } -bool IfcDocumentInformation::is(Type::Enum v) const { return v == Type::IfcDocumentInformation || IfcExternalInformation::is(v); } -Type::Enum IfcDocumentInformation::type() const { return Type::IfcDocumentInformation; } +std::string IfcDocumentInformation::Identification() const { return *data_->getArgument(0); } +void IfcDocumentInformation::setIdentification(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::hasLocation() const { return !data_->getArgument(3)->isNull(); } +std::string IfcDocumentInformation::Location() const { return *data_->getArgument(3); } +void IfcDocumentInformation::setLocation(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +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(); } +std::string IfcDocumentInformation::CreationTime() const { return *data_->getArgument(10); } +void IfcDocumentInformation::setCreationTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcDocumentInformation::hasLastRevisionTime() const { return !data_->getArgument(11)->isNull(); } +std::string IfcDocumentInformation::LastRevisionTime() const { return *data_->getArgument(11); } +void IfcDocumentInformation::setLastRevisionTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcDocumentInformation::hasElectronicFormat() const { return !data_->getArgument(12)->isNull(); } +std::string IfcDocumentInformation::ElectronicFormat() const { return *data_->getArgument(12); } +void IfcDocumentInformation::setElectronicFormat(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcDocumentInformation::hasValidFrom() const { return !data_->getArgument(13)->isNull(); } +std::string IfcDocumentInformation::ValidFrom() const { return *data_->getArgument(13); } +void IfcDocumentInformation::setValidFrom(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcDocumentInformation::hasValidUntil() const { return !data_->getArgument(14)->isNull(); } +std::string IfcDocumentInformation::ValidUntil() const { return *data_->getArgument(14); } +void IfcDocumentInformation::setValidUntil(std::string 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)); } + +IfcRelAssociatesDocument::list::ptr IfcDocumentInformation::DocumentInfoForObjects() const { return data_->getInverse(Type::IfcRelAssociatesDocument, 5)->as(); } +IfcDocumentReference::list::ptr IfcDocumentInformation::HasDocumentReferences() const { return data_->getInverse(Type::IfcDocumentReference, 4)->as(); } +IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointedTo() const { return data_->getInverse(Type::IfcDocumentInformationRelationship, 3)->as(); } +IfcDocumentInformationRelationship::list::ptr IfcDocumentInformation::IsPointer() const { return data_->getInverse(Type::IfcDocumentInformationRelationship, 2)->as(); } + +const IfcParse::entity& IfcDocumentInformation::declaration() const { return *IfcDocumentInformation_type; } Type::Enum IfcDocumentInformation::Class() { return Type::IfcDocumentInformation; } -IfcDocumentInformation::IfcDocumentInformation(IfcAbstractEntity* e) : IfcExternalInformation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDocumentInformation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDocumentInformation::IfcDocumentInformation(std::string v1_Identification, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< std::string > v4_Location, 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, boost::optional< std::string > v11_CreationTime, boost::optional< std::string > v12_LastRevisionTime, boost::optional< std::string > v13_ElectronicFormat, boost::optional< std::string > v14_ValidFrom, boost::optional< std::string > v15_ValidUntil, boost::optional< IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum > v16_Confidentiality, boost::optional< IfcDocumentStatusEnum::IfcDocumentStatusEnum > v17_Status) : IfcExternalInformation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Identification)); e->setArgument(1,(v2_Name)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_Location) { e->setArgument(3,(*v4_Location)); } 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); } if (v11_CreationTime) { e->setArgument(10,(*v11_CreationTime)); } else { e->setArgument(10); } if (v12_LastRevisionTime) { e->setArgument(11,(*v12_LastRevisionTime)); } else { e->setArgument(11); } if (v13_ElectronicFormat) { e->setArgument(12,(*v13_ElectronicFormat)); } else { e->setArgument(12); } if (v14_ValidFrom) { e->setArgument(13,(*v14_ValidFrom)); } else { e->setArgument(13); } if (v15_ValidUntil) { e->setArgument(14,(*v15_ValidUntil)); } else { e->setArgument(14); } 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) : IfcExternalInformation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDocumentInformation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDocumentInformation::IfcDocumentInformation(std::string v1_Identification, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< std::string > v4_Location, 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, boost::optional< std::string > v11_CreationTime, boost::optional< std::string > v12_LastRevisionTime, boost::optional< std::string > v13_ElectronicFormat, boost::optional< std::string > v14_ValidFrom, boost::optional< std::string > v15_ValidUntil, boost::optional< IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum > v16_Confidentiality, boost::optional< IfcDocumentStatusEnum::IfcDocumentStatusEnum > v17_Status) : IfcExternalInformation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Identification)); e->setArgument(1,(v2_Name)); if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } if (v4_Location) { e->setArgument(3,(*v4_Location)); } 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); } if (v11_CreationTime) { e->setArgument(10,(*v11_CreationTime)); } else { e->setArgument(10); } if (v12_LastRevisionTime) { e->setArgument(11,(*v12_LastRevisionTime)); } else { e->setArgument(11); } if (v13_ElectronicFormat) { e->setArgument(12,(*v13_ElectronicFormat)); } else { e->setArgument(12); } if (v14_ValidFrom) { e->setArgument(13,(*v14_ValidFrom)); } else { e->setArgument(13); } if (v15_ValidUntil) { e->setArgument(14,(*v15_ValidUntil)); } else { e->setArgument(14); } 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(2))); } -void IfcDocumentInformationRelationship::setRelatingDocument(IfcDocumentInformation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcDocumentInformation >::ptr IfcDocumentInformationRelationship::RelatedDocuments() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcDocumentInformationRelationship::setRelatedDocuments(IfcTemplatedEntityList< IfcDocumentInformation >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcDocumentInformationRelationship::hasRelationshipType() const { return !entity->getArgument(4)->isNull(); } -std::string IfcDocumentInformationRelationship::RelationshipType() const { return *entity->getArgument(4); } -void IfcDocumentInformationRelationship::setRelationshipType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcDocumentInformationRelationship::is(Type::Enum v) const { return v == Type::IfcDocumentInformationRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcDocumentInformationRelationship::type() const { return Type::IfcDocumentInformationRelationship; } +IfcDocumentInformation* IfcDocumentInformationRelationship::RelatingDocument() const { return (IfcDocumentInformation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcDocumentInformationRelationship::setRelatingDocument(IfcDocumentInformation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcDocumentInformation >::ptr IfcDocumentInformationRelationship::RelatedDocuments() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcDocumentInformationRelationship::setRelatedDocuments(IfcTemplatedEntityList< IfcDocumentInformation >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } +bool IfcDocumentInformationRelationship::hasRelationshipType() const { return !data_->getArgument(4)->isNull(); } +std::string IfcDocumentInformationRelationship::RelationshipType() const { return *data_->getArgument(4); } +void IfcDocumentInformationRelationship::setRelationshipType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcDocumentInformationRelationship::declaration() const { return *IfcDocumentInformationRelationship_type; } Type::Enum IfcDocumentInformationRelationship::Class() { return Type::IfcDocumentInformationRelationship; } -IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDocumentInformationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDocumentInformation* v3_RelatingDocument, IfcTemplatedEntityList< IfcDocumentInformation >::ptr v4_RelatedDocuments, boost::optional< std::string > v5_RelationshipType) : IfcResourceLevelRelationship((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_RelatingDocument)); e->setArgument(3,(v4_RelatedDocuments)->generalize()); if (v5_RelationshipType) { e->setArgument(4,(*v5_RelationshipType)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDocumentInformationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDocumentInformation* v3_RelatingDocument, IfcTemplatedEntityList< IfcDocumentInformation >::ptr v4_RelatedDocuments, boost::optional< std::string > v5_RelationshipType) : IfcResourceLevelRelationship((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_RelatingDocument)); e->setArgument(3,(v4_RelatedDocuments)->generalize()); if (v5_RelationshipType) { e->setArgument(4,(*v5_RelationshipType)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcDocumentReference -bool IfcDocumentReference::hasDescription() const { return !entity->getArgument(3)->isNull(); } -std::string IfcDocumentReference::Description() const { return *entity->getArgument(3); } -void IfcDocumentReference::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcDocumentReference::hasReferencedDocument() const { return !entity->getArgument(4)->isNull(); } -IfcDocumentInformation* IfcDocumentReference::ReferencedDocument() const { return (IfcDocumentInformation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcDocumentReference::setReferencedDocument(IfcDocumentInformation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcRelAssociatesDocument::list::ptr IfcDocumentReference::DocumentRefForObjects() const { return entity->getInverse(Type::IfcRelAssociatesDocument, 5)->as(); } -bool IfcDocumentReference::is(Type::Enum v) const { return v == Type::IfcDocumentReference || IfcExternalReference::is(v); } -Type::Enum IfcDocumentReference::type() const { return Type::IfcDocumentReference; } +bool IfcDocumentReference::hasDescription() const { return !data_->getArgument(3)->isNull(); } +std::string IfcDocumentReference::Description() const { return *data_->getArgument(3); } +void IfcDocumentReference::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcDocumentReference::hasReferencedDocument() const { return !data_->getArgument(4)->isNull(); } +IfcDocumentInformation* IfcDocumentReference::ReferencedDocument() const { return (IfcDocumentInformation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcDocumentReference::setReferencedDocument(IfcDocumentInformation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + +IfcRelAssociatesDocument::list::ptr IfcDocumentReference::DocumentRefForObjects() const { return data_->getInverse(Type::IfcRelAssociatesDocument, 5)->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_Identification, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcDocumentInformation* v5_ReferencedDocument) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } 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_ReferencedDocument)); 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_Identification, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcDocumentInformation* v5_ReferencedDocument) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } 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_ReferencedDocument)); 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::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcDoorTypeEnum::IfcDoorTypeEnum IfcDoor::PredefinedType() const { return IfcDoorTypeEnum::FromString(*entity->getArgument(10)); } -void IfcDoor::setPredefinedType(IfcDoorTypeEnum::IfcDoorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcDoorTypeEnum::ToString(v)); } -bool IfcDoor::hasOperationType() const { return !entity->getArgument(11)->isNull(); } -IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum IfcDoor::OperationType() const { return IfcDoorTypeOperationEnum::FromString(*entity->getArgument(11)); } -void IfcDoor::setOperationType(IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcDoorTypeOperationEnum::ToString(v)); } -bool IfcDoor::hasUserDefinedOperationType() const { return !entity->getArgument(12)->isNull(); } -std::string IfcDoor::UserDefinedOperationType() const { return *entity->getArgument(12); } -void IfcDoor::setUserDefinedOperationType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,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); } +bool IfcDoor::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcDoorTypeEnum::IfcDoorTypeEnum IfcDoor::PredefinedType() const { return IfcDoorTypeEnum::FromString(*data_->getArgument(10)); } +void IfcDoor::setPredefinedType(IfcDoorTypeEnum::IfcDoorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcDoorTypeEnum::ToString(v)); } +bool IfcDoor::hasOperationType() const { return !data_->getArgument(11)->isNull(); } +IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum IfcDoor::OperationType() const { return IfcDoorTypeOperationEnum::FromString(*data_->getArgument(11)); } +void IfcDoor::setOperationType(IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcDoorTypeOperationEnum::ToString(v)); } +bool IfcDoor::hasUserDefinedOperationType() const { return !data_->getArgument(12)->isNull(); } +std::string IfcDoor::UserDefinedOperationType() const { return *data_->getArgument(12); } +void IfcDoor::setUserDefinedOperationType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,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, boost::optional< IfcDoorTypeEnum::IfcDoorTypeEnum > v11_PredefinedType, boost::optional< IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum > v12_OperationType, boost::optional< std::string > v13_UserDefinedOperationType) : 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcDoorTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_OperationType) { e->setArgument(11,*v12_OperationType,IfcDoorTypeOperationEnum::ToString(*v12_OperationType)); } else { e->setArgument(11); } if (v13_UserDefinedOperationType) { e->setArgument(12,(*v13_UserDefinedOperationType)); } else { e->setArgument(12); } 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, boost::optional< IfcDoorTypeEnum::IfcDoorTypeEnum > v11_PredefinedType, boost::optional< IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum > v12_OperationType, boost::optional< std::string > v13_UserDefinedOperationType) : 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcDoorTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_OperationType) { e->setArgument(11,*v12_OperationType,IfcDoorTypeOperationEnum::ToString(*v12_OperationType)); } else { e->setArgument(11); } if (v13_UserDefinedOperationType) { e->setArgument(12,(*v13_UserDefinedOperationType)); } else { e->setArgument(12); } 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::hasLiningToPanelOffsetX() const { return !entity->getArgument(15)->isNull(); } -double IfcDoorLiningProperties::LiningToPanelOffsetX() const { return *entity->getArgument(15); } -void IfcDoorLiningProperties::setLiningToPanelOffsetX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcDoorLiningProperties::hasLiningToPanelOffsetY() const { return !entity->getArgument(16)->isNull(); } -double IfcDoorLiningProperties::LiningToPanelOffsetY() const { return *entity->getArgument(16); } -void IfcDoorLiningProperties::setLiningToPanelOffsetY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcDoorLiningProperties::is(Type::Enum v) const { return v == Type::IfcDoorLiningProperties || IfcPreDefinedPropertySet::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); } +bool IfcDoorLiningProperties::hasLiningToPanelOffsetX() const { return !data_->getArgument(15)->isNull(); } +double IfcDoorLiningProperties::LiningToPanelOffsetX() const { return *data_->getArgument(15); } +void IfcDoorLiningProperties::setLiningToPanelOffsetX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcDoorLiningProperties::hasLiningToPanelOffsetY() const { return !data_->getArgument(16)->isNull(); } +double IfcDoorLiningProperties::LiningToPanelOffsetY() const { return *data_->getArgument(16); } +void IfcDoorLiningProperties::setLiningToPanelOffsetY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } + + +const IfcParse::entity& IfcDoorLiningProperties::declaration() const { return *IfcDoorLiningProperties_type; } Type::Enum IfcDoorLiningProperties::Class() { return Type::IfcDoorLiningProperties; } -IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntity* e) : IfcPreDefinedPropertySet((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, boost::optional< double > v16_LiningToPanelOffsetX, boost::optional< double > v17_LiningToPanelOffsetY) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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)); if (v16_LiningToPanelOffsetX) { e->setArgument(15,(*v16_LiningToPanelOffsetX)); } else { e->setArgument(15); } if (v17_LiningToPanelOffsetY) { e->setArgument(16,(*v17_LiningToPanelOffsetY)); } else { e->setArgument(16); } entity = e; EntityBuffer::Add(this); } +IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntity* e) : IfcPreDefinedPropertySet((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, boost::optional< double > v16_LiningToPanelOffsetX, boost::optional< double > v17_LiningToPanelOffsetY) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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)); if (v16_LiningToPanelOffsetX) { e->setArgument(15,(*v16_LiningToPanelOffsetX)); } else { e->setArgument(15); } if (v17_LiningToPanelOffsetY) { e->setArgument(16,(*v17_LiningToPanelOffsetY)); } else { e->setArgument(16); } 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 || IfcPreDefinedPropertySet::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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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 IfcDoorStandardCase -bool IfcDoorStandardCase::is(Type::Enum v) const { return v == Type::IfcDoorStandardCase || IfcDoor::is(v); } -Type::Enum IfcDoorStandardCase::type() const { return Type::IfcDoorStandardCase; } + + +const IfcParse::entity& IfcDoorStandardCase::declaration() const { return *IfcDoorStandardCase_type; } Type::Enum IfcDoorStandardCase::Class() { return Type::IfcDoorStandardCase; } -IfcDoorStandardCase::IfcDoorStandardCase(IfcAbstractEntity* e) : IfcDoor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDoorStandardCase::IfcDoorStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcDoorTypeEnum::IfcDoorTypeEnum > v11_PredefinedType, boost::optional< IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum > v12_OperationType, boost::optional< std::string > v13_UserDefinedOperationType) : IfcDoor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcDoorTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_OperationType) { e->setArgument(11,*v12_OperationType,IfcDoorTypeOperationEnum::ToString(*v12_OperationType)); } else { e->setArgument(11); } if (v13_UserDefinedOperationType) { e->setArgument(12,(*v13_UserDefinedOperationType)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcDoorStandardCase::IfcDoorStandardCase(IfcAbstractEntity* e) : IfcDoor((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDoorStandardCase::IfcDoorStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcDoorTypeEnum::IfcDoorTypeEnum > v11_PredefinedType, boost::optional< IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum > v12_OperationType, boost::optional< std::string > v13_UserDefinedOperationType) : IfcDoor((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcDoorTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_OperationType) { e->setArgument(11,*v12_OperationType,IfcDoorTypeOperationEnum::ToString(*v12_OperationType)); } else { e->setArgument(11); } if (v13_UserDefinedOperationType) { e->setArgument(12,(*v13_UserDefinedOperationType)); } else { e->setArgument(12); } 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 IfcDoorType -IfcDoorTypeEnum::IfcDoorTypeEnum IfcDoorType::PredefinedType() const { return IfcDoorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcDoorType::setPredefinedType(IfcDoorTypeEnum::IfcDoorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcDoorTypeEnum::ToString(v)); } -IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum IfcDoorType::OperationType() const { return IfcDoorTypeOperationEnum::FromString(*entity->getArgument(10)); } -void IfcDoorType::setOperationType(IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcDoorTypeOperationEnum::ToString(v)); } -bool IfcDoorType::hasParameterTakesPrecedence() const { return !entity->getArgument(11)->isNull(); } -bool IfcDoorType::ParameterTakesPrecedence() const { return *entity->getArgument(11); } -void IfcDoorType::setParameterTakesPrecedence(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcDoorType::hasUserDefinedOperationType() const { return !entity->getArgument(12)->isNull(); } -std::string IfcDoorType::UserDefinedOperationType() const { return *entity->getArgument(12); } -void IfcDoorType::setUserDefinedOperationType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcDoorType::is(Type::Enum v) const { return v == Type::IfcDoorType || IfcBuildingElementType::is(v); } -Type::Enum IfcDoorType::type() const { return Type::IfcDoorType; } +IfcDoorTypeEnum::IfcDoorTypeEnum IfcDoorType::PredefinedType() const { return IfcDoorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcDoorType::setPredefinedType(IfcDoorTypeEnum::IfcDoorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcDoorTypeEnum::ToString(v)); } +IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum IfcDoorType::OperationType() const { return IfcDoorTypeOperationEnum::FromString(*data_->getArgument(10)); } +void IfcDoorType::setOperationType(IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcDoorTypeOperationEnum::ToString(v)); } +bool IfcDoorType::hasParameterTakesPrecedence() const { return !data_->getArgument(11)->isNull(); } +bool IfcDoorType::ParameterTakesPrecedence() const { return *data_->getArgument(11); } +void IfcDoorType::setParameterTakesPrecedence(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcDoorType::hasUserDefinedOperationType() const { return !data_->getArgument(12)->isNull(); } +std::string IfcDoorType::UserDefinedOperationType() const { return *data_->getArgument(12); } +void IfcDoorType::setUserDefinedOperationType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcDoorType::declaration() const { return *IfcDoorType_type; } Type::Enum IfcDoorType::Class() { return Type::IfcDoorType; } -IfcDoorType::IfcDoorType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDoorType::IfcDoorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDoorTypeEnum::IfcDoorTypeEnum v10_PredefinedType, IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v11_OperationType, boost::optional< bool > v12_ParameterTakesPrecedence, boost::optional< std::string > v13_UserDefinedOperationType) : 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,IfcDoorTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,v11_OperationType,IfcDoorTypeOperationEnum::ToString(v11_OperationType)); if (v12_ParameterTakesPrecedence) { e->setArgument(11,(*v12_ParameterTakesPrecedence)); } else { e->setArgument(11); } if (v13_UserDefinedOperationType) { e->setArgument(12,(*v13_UserDefinedOperationType)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcDoorType::IfcDoorType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDoorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDoorType::IfcDoorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDoorTypeEnum::IfcDoorTypeEnum v10_PredefinedType, IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v11_OperationType, boost::optional< bool > v12_ParameterTakesPrecedence, boost::optional< std::string > v13_UserDefinedOperationType) : 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,IfcDoorTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,v11_OperationType,IfcDoorTypeOperationEnum::ToString(v11_OperationType)); if (v12_ParameterTakesPrecedence) { e->setArgument(11,(*v12_ParameterTakesPrecedence)); } else { e->setArgument(11); } if (v13_UserDefinedOperationType) { e->setArgument(12,(*v13_UserDefinedOperationType)); } else { e->setArgument(12); } 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 IfcDuctFitting -bool IfcDuctFitting::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFitting::PredefinedType() const { return IfcDuctFittingTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDuctFitting::setPredefinedType(IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDuctFittingTypeEnum::ToString(v)); } -bool IfcDuctFitting::is(Type::Enum v) const { return v == Type::IfcDuctFitting || IfcFlowFitting::is(v); } -Type::Enum IfcDuctFitting::type() const { return Type::IfcDuctFitting; } +bool IfcDuctFitting::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFitting::PredefinedType() const { return IfcDuctFittingTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDuctFitting::setPredefinedType(IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDuctFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDuctFitting::declaration() const { return *IfcDuctFitting_type; } Type::Enum IfcDuctFitting::Class() { return Type::IfcDuctFitting; } -IfcDuctFitting::IfcDuctFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctFitting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDuctFitting::IfcDuctFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcDuctFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDuctFitting::IfcDuctFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctFitting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDuctFitting::IfcDuctFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcDuctFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcDuctSegment -bool IfcDuctSegment::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegment::PredefinedType() const { return IfcDuctSegmentTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDuctSegment::setPredefinedType(IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDuctSegmentTypeEnum::ToString(v)); } -bool IfcDuctSegment::is(Type::Enum v) const { return v == Type::IfcDuctSegment || IfcFlowSegment::is(v); } -Type::Enum IfcDuctSegment::type() const { return Type::IfcDuctSegment; } +bool IfcDuctSegment::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegment::PredefinedType() const { return IfcDuctSegmentTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDuctSegment::setPredefinedType(IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDuctSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDuctSegment::declaration() const { return *IfcDuctSegment_type; } Type::Enum IfcDuctSegment::Class() { return Type::IfcDuctSegment; } -IfcDuctSegment::IfcDuctSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDuctSegment::IfcDuctSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcDuctSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDuctSegment::IfcDuctSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDuctSegment::IfcDuctSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcDuctSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcDuctSilencer -bool IfcDuctSilencer::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencer::PredefinedType() const { return IfcDuctSilencerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcDuctSilencer::setPredefinedType(IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcDuctSilencerTypeEnum::ToString(v)); } -bool IfcDuctSilencer::is(Type::Enum v) const { return v == Type::IfcDuctSilencer || IfcFlowTreatmentDevice::is(v); } -Type::Enum IfcDuctSilencer::type() const { return Type::IfcDuctSilencer; } +bool IfcDuctSilencer::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencer::PredefinedType() const { return IfcDuctSilencerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcDuctSilencer::setPredefinedType(IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcDuctSilencerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcDuctSilencer::declaration() const { return *IfcDuctSilencer_type; } Type::Enum IfcDuctSilencer::Class() { return Type::IfcDuctSilencer; } -IfcDuctSilencer::IfcDuctSilencer(IfcAbstractEntity* e) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSilencer)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcDuctSilencer::IfcDuctSilencer(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum > v9_PredefinedType) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcDuctSilencerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcDuctSilencer::IfcDuctSilencer(IfcAbstractEntity* e) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcDuctSilencer)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcDuctSilencer::IfcDuctSilencer(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum > v9_PredefinedType) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcDuctSilencerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 IfcElectricAppliance -bool IfcElectricAppliance::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricAppliance::PredefinedType() const { return IfcElectricApplianceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcElectricAppliance::setPredefinedType(IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricApplianceTypeEnum::ToString(v)); } -bool IfcElectricAppliance::is(Type::Enum v) const { return v == Type::IfcElectricAppliance || IfcFlowTerminal::is(v); } -Type::Enum IfcElectricAppliance::type() const { return Type::IfcElectricAppliance; } +bool IfcElectricAppliance::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricAppliance::PredefinedType() const { return IfcElectricApplianceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcElectricAppliance::setPredefinedType(IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricApplianceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricAppliance::declaration() const { return *IfcElectricAppliance_type; } Type::Enum IfcElectricAppliance::Class() { return Type::IfcElectricAppliance; } -IfcElectricAppliance::IfcElectricAppliance(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricAppliance)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricAppliance::IfcElectricAppliance(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricApplianceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElectricAppliance::IfcElectricAppliance(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricAppliance)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricAppliance::IfcElectricAppliance(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricApplianceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcElectricDistributionBoard -bool IfcElectricDistributionBoard::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum IfcElectricDistributionBoard::PredefinedType() const { return IfcElectricDistributionBoardTypeEnum::FromString(*entity->getArgument(8)); } -void IfcElectricDistributionBoard::setPredefinedType(IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricDistributionBoardTypeEnum::ToString(v)); } -bool IfcElectricDistributionBoard::is(Type::Enum v) const { return v == Type::IfcElectricDistributionBoard || IfcFlowController::is(v); } -Type::Enum IfcElectricDistributionBoard::type() const { return Type::IfcElectricDistributionBoard; } +bool IfcElectricDistributionBoard::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum IfcElectricDistributionBoard::PredefinedType() const { return IfcElectricDistributionBoardTypeEnum::FromString(*data_->getArgument(8)); } +void IfcElectricDistributionBoard::setPredefinedType(IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricDistributionBoardTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricDistributionBoard::declaration() const { return *IfcElectricDistributionBoard_type; } Type::Enum IfcElectricDistributionBoard::Class() { return Type::IfcElectricDistributionBoard; } -IfcElectricDistributionBoard::IfcElectricDistributionBoard(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricDistributionBoard)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricDistributionBoard::IfcElectricDistributionBoard(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcElectricDistributionBoardTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElectricDistributionBoard::IfcElectricDistributionBoard(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricDistributionBoard)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricDistributionBoard::IfcElectricDistributionBoard(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcElectricDistributionBoardTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricDistributionBoardType -IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum IfcElectricDistributionBoardType::PredefinedType() const { return IfcElectricDistributionBoardTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElectricDistributionBoardType::setPredefinedType(IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElectricDistributionBoardTypeEnum::ToString(v)); } -bool IfcElectricDistributionBoardType::is(Type::Enum v) const { return v == Type::IfcElectricDistributionBoardType || IfcFlowControllerType::is(v); } -Type::Enum IfcElectricDistributionBoardType::type() const { return Type::IfcElectricDistributionBoardType; } +IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum IfcElectricDistributionBoardType::PredefinedType() const { return IfcElectricDistributionBoardTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElectricDistributionBoardType::setPredefinedType(IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElectricDistributionBoardTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricDistributionBoardType::declaration() const { return *IfcElectricDistributionBoardType_type; } Type::Enum IfcElectricDistributionBoardType::Class() { return Type::IfcElectricDistributionBoardType; } -IfcElectricDistributionBoardType::IfcElectricDistributionBoardType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricDistributionBoardType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricDistributionBoardType::IfcElectricDistributionBoardType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum 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,IfcElectricDistributionBoardTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElectricDistributionBoardType::IfcElectricDistributionBoardType(IfcAbstractEntity* e) : IfcFlowControllerType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricDistributionBoardType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricDistributionBoardType::IfcElectricDistributionBoardType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum 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,IfcElectricDistributionBoardTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElectricFlowStorageDevice -bool IfcElectricFlowStorageDevice::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDevice::PredefinedType() const { return IfcElectricFlowStorageDeviceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcElectricFlowStorageDevice::setPredefinedType(IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricFlowStorageDeviceTypeEnum::ToString(v)); } -bool IfcElectricFlowStorageDevice::is(Type::Enum v) const { return v == Type::IfcElectricFlowStorageDevice || IfcFlowStorageDevice::is(v); } -Type::Enum IfcElectricFlowStorageDevice::type() const { return Type::IfcElectricFlowStorageDevice; } +bool IfcElectricFlowStorageDevice::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDevice::PredefinedType() const { return IfcElectricFlowStorageDeviceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcElectricFlowStorageDevice::setPredefinedType(IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricFlowStorageDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricFlowStorageDevice::declaration() const { return *IfcElectricFlowStorageDevice_type; } Type::Enum IfcElectricFlowStorageDevice::Class() { return Type::IfcElectricFlowStorageDevice; } -IfcElectricFlowStorageDevice::IfcElectricFlowStorageDevice(IfcAbstractEntity* e) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricFlowStorageDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricFlowStorageDevice::IfcElectricFlowStorageDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum > v9_PredefinedType) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricFlowStorageDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElectricFlowStorageDevice::IfcElectricFlowStorageDevice(IfcAbstractEntity* e) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricFlowStorageDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricFlowStorageDevice::IfcElectricFlowStorageDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum > v9_PredefinedType) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricFlowStorageDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcElectricGenerator -bool IfcElectricGenerator::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGenerator::PredefinedType() const { return IfcElectricGeneratorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcElectricGenerator::setPredefinedType(IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricGeneratorTypeEnum::ToString(v)); } -bool IfcElectricGenerator::is(Type::Enum v) const { return v == Type::IfcElectricGenerator || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcElectricGenerator::type() const { return Type::IfcElectricGenerator; } +bool IfcElectricGenerator::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGenerator::PredefinedType() const { return IfcElectricGeneratorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcElectricGenerator::setPredefinedType(IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricGeneratorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricGenerator::declaration() const { return *IfcElectricGenerator_type; } Type::Enum IfcElectricGenerator::Class() { return Type::IfcElectricGenerator; } -IfcElectricGenerator::IfcElectricGenerator(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricGenerator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricGenerator::IfcElectricGenerator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricGeneratorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElectricGenerator::IfcElectricGenerator(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricGenerator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricGenerator::IfcElectricGenerator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricGeneratorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcElectricMotor -bool IfcElectricMotor::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotor::PredefinedType() const { return IfcElectricMotorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcElectricMotor::setPredefinedType(IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricMotorTypeEnum::ToString(v)); } -bool IfcElectricMotor::is(Type::Enum v) const { return v == Type::IfcElectricMotor || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcElectricMotor::type() const { return Type::IfcElectricMotor; } +bool IfcElectricMotor::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotor::PredefinedType() const { return IfcElectricMotorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcElectricMotor::setPredefinedType(IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricMotorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricMotor::declaration() const { return *IfcElectricMotor_type; } Type::Enum IfcElectricMotor::Class() { return Type::IfcElectricMotor; } -IfcElectricMotor::IfcElectricMotor(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricMotor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricMotor::IfcElectricMotor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricMotorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElectricMotor::IfcElectricMotor(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricMotor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricMotor::IfcElectricMotor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcElectricMotorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcElectricTimeControl -bool IfcElectricTimeControl::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControl::PredefinedType() const { return IfcElectricTimeControlTypeEnum::FromString(*entity->getArgument(8)); } -void IfcElectricTimeControl::setPredefinedType(IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcElectricTimeControlTypeEnum::ToString(v)); } -bool IfcElectricTimeControl::is(Type::Enum v) const { return v == Type::IfcElectricTimeControl || IfcFlowController::is(v); } -Type::Enum IfcElectricTimeControl::type() const { return Type::IfcElectricTimeControl; } +bool IfcElectricTimeControl::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControl::PredefinedType() const { return IfcElectricTimeControlTypeEnum::FromString(*data_->getArgument(8)); } +void IfcElectricTimeControl::setPredefinedType(IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcElectricTimeControlTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElectricTimeControl::declaration() const { return *IfcElectricTimeControl_type; } Type::Enum IfcElectricTimeControl::Class() { return Type::IfcElectricTimeControl; } -IfcElectricTimeControl::IfcElectricTimeControl(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricTimeControl)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElectricTimeControl::IfcElectricTimeControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcElectricTimeControlTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcElectricTimeControl::IfcElectricTimeControl(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElectricTimeControl)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElectricTimeControl::IfcElectricTimeControl(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcElectricTimeControlTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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); } -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(); } -IfcRelInterferesElements::list::ptr IfcElement::IsInterferedByElements() const { return entity->getInverse(Type::IfcRelInterferesElements, 5)->as(); } -IfcRelInterferesElements::list::ptr IfcElement::InterferesElements() const { return entity->getInverse(Type::IfcRelInterferesElements, 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(); } -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); } + +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(); } +IfcRelInterferesElements::list::ptr IfcElement::IsInterferedByElements() const { return data_->getInverse(Type::IfcRelInterferesElements, 5)->as(); } +IfcRelInterferesElements::list::ptr IfcElement::InterferesElements() const { return data_->getInverse(Type::IfcRelInterferesElements, 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(); } +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)); } -bool IfcElementAssembly::hasPredefinedType() const { return !entity->getArgument(9)->isNull(); } -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)); } +bool IfcElementAssembly::hasPredefinedType() const { return !data_->getArgument(9)->isNull(); } +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, boost::optional< 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); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcElementAssemblyTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } 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, boost::optional< 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); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcElementAssemblyTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcElementAssemblyType -IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssemblyType::PredefinedType() const { return IfcElementAssemblyTypeEnum::FromString(*entity->getArgument(9)); } -void IfcElementAssemblyType::setPredefinedType(IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcElementAssemblyTypeEnum::ToString(v)); } -bool IfcElementAssemblyType::is(Type::Enum v) const { return v == Type::IfcElementAssemblyType || IfcElementType::is(v); } -Type::Enum IfcElementAssemblyType::type() const { return Type::IfcElementAssemblyType; } +IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssemblyType::PredefinedType() const { return IfcElementAssemblyTypeEnum::FromString(*data_->getArgument(9)); } +void IfcElementAssemblyType::setPredefinedType(IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcElementAssemblyTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcElementAssemblyType::declaration() const { return *IfcElementAssemblyType_type; } Type::Enum IfcElementAssemblyType::Class() { return Type::IfcElementAssemblyType; } -IfcElementAssemblyType::IfcElementAssemblyType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementAssemblyType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcElementAssemblyType::IfcElementAssemblyType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum 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,IfcElementAssemblyTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcElementAssemblyType::IfcElementAssemblyType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcElementAssemblyType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcElementAssemblyType::IfcElementAssemblyType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum 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,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 || IfcQuantitySet::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) : IfcQuantitySet((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) : IfcQuantitySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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) : IfcQuantitySet((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) : IfcQuantitySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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 IfcEngine -bool IfcEngine::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcEngineTypeEnum::IfcEngineTypeEnum IfcEngine::PredefinedType() const { return IfcEngineTypeEnum::FromString(*entity->getArgument(8)); } -void IfcEngine::setPredefinedType(IfcEngineTypeEnum::IfcEngineTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcEngineTypeEnum::ToString(v)); } -bool IfcEngine::is(Type::Enum v) const { return v == Type::IfcEngine || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcEngine::type() const { return Type::IfcEngine; } +bool IfcEngine::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcEngineTypeEnum::IfcEngineTypeEnum IfcEngine::PredefinedType() const { return IfcEngineTypeEnum::FromString(*data_->getArgument(8)); } +void IfcEngine::setPredefinedType(IfcEngineTypeEnum::IfcEngineTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcEngineTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcEngine::declaration() const { return *IfcEngine_type; } Type::Enum IfcEngine::Class() { return Type::IfcEngine; } -IfcEngine::IfcEngine(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEngine)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEngine::IfcEngine(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEngineTypeEnum::IfcEngineTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcEngineTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcEngine::IfcEngine(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEngine)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEngine::IfcEngine(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEngineTypeEnum::IfcEngineTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcEngineTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEngineType -IfcEngineTypeEnum::IfcEngineTypeEnum IfcEngineType::PredefinedType() const { return IfcEngineTypeEnum::FromString(*entity->getArgument(9)); } -void IfcEngineType::setPredefinedType(IfcEngineTypeEnum::IfcEngineTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcEngineTypeEnum::ToString(v)); } -bool IfcEngineType::is(Type::Enum v) const { return v == Type::IfcEngineType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcEngineType::type() const { return Type::IfcEngineType; } +IfcEngineTypeEnum::IfcEngineTypeEnum IfcEngineType::PredefinedType() const { return IfcEngineTypeEnum::FromString(*data_->getArgument(9)); } +void IfcEngineType::setPredefinedType(IfcEngineTypeEnum::IfcEngineTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcEngineTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcEngineType::declaration() const { return *IfcEngineType_type; } Type::Enum IfcEngineType::Class() { return Type::IfcEngineType; } -IfcEngineType::IfcEngineType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEngineType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEngineType::IfcEngineType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEngineTypeEnum::IfcEngineTypeEnum 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,IfcEngineTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcEngineType::IfcEngineType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEngineType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEngineType::IfcEngineType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEngineTypeEnum::IfcEngineTypeEnum 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,IfcEngineTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEvaporativeCooler -bool IfcEvaporativeCooler::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCooler::PredefinedType() const { return IfcEvaporativeCoolerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcEvaporativeCooler::setPredefinedType(IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcEvaporativeCoolerTypeEnum::ToString(v)); } -bool IfcEvaporativeCooler::is(Type::Enum v) const { return v == Type::IfcEvaporativeCooler || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcEvaporativeCooler::type() const { return Type::IfcEvaporativeCooler; } +bool IfcEvaporativeCooler::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCooler::PredefinedType() const { return IfcEvaporativeCoolerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcEvaporativeCooler::setPredefinedType(IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcEvaporativeCoolerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcEvaporativeCooler::declaration() const { return *IfcEvaporativeCooler_type; } Type::Enum IfcEvaporativeCooler::Class() { return Type::IfcEvaporativeCooler; } -IfcEvaporativeCooler::IfcEvaporativeCooler(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporativeCooler)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEvaporativeCooler::IfcEvaporativeCooler(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcEvaporativeCoolerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcEvaporativeCooler::IfcEvaporativeCooler(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporativeCooler)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEvaporativeCooler::IfcEvaporativeCooler(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcEvaporativeCoolerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcEvaporator -bool IfcEvaporator::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporator::PredefinedType() const { return IfcEvaporatorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcEvaporator::setPredefinedType(IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcEvaporatorTypeEnum::ToString(v)); } -bool IfcEvaporator::is(Type::Enum v) const { return v == Type::IfcEvaporator || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcEvaporator::type() const { return Type::IfcEvaporator; } +bool IfcEvaporator::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporator::PredefinedType() const { return IfcEvaporatorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcEvaporator::setPredefinedType(IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcEvaporatorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcEvaporator::declaration() const { return *IfcEvaporator_type; } Type::Enum IfcEvaporator::Class() { return Type::IfcEvaporator; } -IfcEvaporator::IfcEvaporator(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEvaporator::IfcEvaporator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcEvaporatorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcEvaporator::IfcEvaporator(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvaporator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEvaporator::IfcEvaporator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcEvaporatorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcEvent -bool IfcEvent::hasPredefinedType() const { return !entity->getArgument(7)->isNull(); } -IfcEventTypeEnum::IfcEventTypeEnum IfcEvent::PredefinedType() const { return IfcEventTypeEnum::FromString(*entity->getArgument(7)); } -void IfcEvent::setPredefinedType(IfcEventTypeEnum::IfcEventTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcEventTypeEnum::ToString(v)); } -bool IfcEvent::hasEventTriggerType() const { return !entity->getArgument(8)->isNull(); } -IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum IfcEvent::EventTriggerType() const { return IfcEventTriggerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcEvent::setEventTriggerType(IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcEventTriggerTypeEnum::ToString(v)); } -bool IfcEvent::hasUserDefinedEventTriggerType() const { return !entity->getArgument(9)->isNull(); } -std::string IfcEvent::UserDefinedEventTriggerType() const { return *entity->getArgument(9); } -void IfcEvent::setUserDefinedEventTriggerType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcEvent::hasEventOccurenceTime() const { return !entity->getArgument(10)->isNull(); } -IfcEventTime* IfcEvent::EventOccurenceTime() const { return (IfcEventTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcEvent::setEventOccurenceTime(IfcEventTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcEvent::is(Type::Enum v) const { return v == Type::IfcEvent || IfcProcess::is(v); } -Type::Enum IfcEvent::type() const { return Type::IfcEvent; } +bool IfcEvent::hasPredefinedType() const { return !data_->getArgument(7)->isNull(); } +IfcEventTypeEnum::IfcEventTypeEnum IfcEvent::PredefinedType() const { return IfcEventTypeEnum::FromString(*data_->getArgument(7)); } +void IfcEvent::setPredefinedType(IfcEventTypeEnum::IfcEventTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcEventTypeEnum::ToString(v)); } +bool IfcEvent::hasEventTriggerType() const { return !data_->getArgument(8)->isNull(); } +IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum IfcEvent::EventTriggerType() const { return IfcEventTriggerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcEvent::setEventTriggerType(IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcEventTriggerTypeEnum::ToString(v)); } +bool IfcEvent::hasUserDefinedEventTriggerType() const { return !data_->getArgument(9)->isNull(); } +std::string IfcEvent::UserDefinedEventTriggerType() const { return *data_->getArgument(9); } +void IfcEvent::setUserDefinedEventTriggerType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcEvent::hasEventOccurenceTime() const { return !data_->getArgument(10)->isNull(); } +IfcEventTime* IfcEvent::EventOccurenceTime() const { return (IfcEventTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcEvent::setEventOccurenceTime(IfcEventTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcEvent::declaration() const { return *IfcEvent_type; } Type::Enum IfcEvent::Class() { return Type::IfcEvent; } -IfcEvent::IfcEvent(IfcAbstractEntity* e) : IfcProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvent)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEvent::IfcEvent(std::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_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< IfcEventTypeEnum::IfcEventTypeEnum > v8_PredefinedType, boost::optional< IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum > v9_EventTriggerType, boost::optional< std::string > v10_UserDefinedEventTriggerType, IfcEventTime* v11_EventOccurenceTime) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } if (v8_PredefinedType) { e->setArgument(7,*v8_PredefinedType,IfcEventTypeEnum::ToString(*v8_PredefinedType)); } else { e->setArgument(7); } if (v9_EventTriggerType) { e->setArgument(8,*v9_EventTriggerType,IfcEventTriggerTypeEnum::ToString(*v9_EventTriggerType)); } else { e->setArgument(8); } if (v10_UserDefinedEventTriggerType) { e->setArgument(9,(*v10_UserDefinedEventTriggerType)); } else { e->setArgument(9); } e->setArgument(10,(v11_EventOccurenceTime)); entity = e; EntityBuffer::Add(this); } +IfcEvent::IfcEvent(IfcAbstractEntity* e) : IfcProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEvent)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEvent::IfcEvent(std::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_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< IfcEventTypeEnum::IfcEventTypeEnum > v8_PredefinedType, boost::optional< IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum > v9_EventTriggerType, boost::optional< std::string > v10_UserDefinedEventTriggerType, IfcEventTime* v11_EventOccurenceTime) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } if (v8_PredefinedType) { e->setArgument(7,*v8_PredefinedType,IfcEventTypeEnum::ToString(*v8_PredefinedType)); } else { e->setArgument(7); } if (v9_EventTriggerType) { e->setArgument(8,*v9_EventTriggerType,IfcEventTriggerTypeEnum::ToString(*v9_EventTriggerType)); } else { e->setArgument(8); } if (v10_UserDefinedEventTriggerType) { e->setArgument(9,(*v10_UserDefinedEventTriggerType)); } else { e->setArgument(9); } e->setArgument(10,(v11_EventOccurenceTime)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEventTime -bool IfcEventTime::hasActualDate() const { return !entity->getArgument(3)->isNull(); } -std::string IfcEventTime::ActualDate() const { return *entity->getArgument(3); } -void IfcEventTime::setActualDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcEventTime::hasEarlyDate() const { return !entity->getArgument(4)->isNull(); } -std::string IfcEventTime::EarlyDate() const { return *entity->getArgument(4); } -void IfcEventTime::setEarlyDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcEventTime::hasLateDate() const { return !entity->getArgument(5)->isNull(); } -std::string IfcEventTime::LateDate() const { return *entity->getArgument(5); } -void IfcEventTime::setLateDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcEventTime::hasScheduleDate() const { return !entity->getArgument(6)->isNull(); } -std::string IfcEventTime::ScheduleDate() const { return *entity->getArgument(6); } -void IfcEventTime::setScheduleDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcEventTime::is(Type::Enum v) const { return v == Type::IfcEventTime || IfcSchedulingTime::is(v); } -Type::Enum IfcEventTime::type() const { return Type::IfcEventTime; } +bool IfcEventTime::hasActualDate() const { return !data_->getArgument(3)->isNull(); } +std::string IfcEventTime::ActualDate() const { return *data_->getArgument(3); } +void IfcEventTime::setActualDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcEventTime::hasEarlyDate() const { return !data_->getArgument(4)->isNull(); } +std::string IfcEventTime::EarlyDate() const { return *data_->getArgument(4); } +void IfcEventTime::setEarlyDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcEventTime::hasLateDate() const { return !data_->getArgument(5)->isNull(); } +std::string IfcEventTime::LateDate() const { return *data_->getArgument(5); } +void IfcEventTime::setLateDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcEventTime::hasScheduleDate() const { return !data_->getArgument(6)->isNull(); } +std::string IfcEventTime::ScheduleDate() const { return *data_->getArgument(6); } +void IfcEventTime::setScheduleDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcEventTime::declaration() const { return *IfcEventTime_type; } Type::Enum IfcEventTime::Class() { return Type::IfcEventTime; } -IfcEventTime::IfcEventTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEventTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEventTime::IfcEventTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< std::string > v4_ActualDate, boost::optional< std::string > v5_EarlyDate, boost::optional< std::string > v6_LateDate, boost::optional< std::string > v7_ScheduleDate) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_ActualDate) { e->setArgument(3,(*v4_ActualDate)); } else { e->setArgument(3); } if (v5_EarlyDate) { e->setArgument(4,(*v5_EarlyDate)); } else { e->setArgument(4); } if (v6_LateDate) { e->setArgument(5,(*v6_LateDate)); } else { e->setArgument(5); } if (v7_ScheduleDate) { e->setArgument(6,(*v7_ScheduleDate)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcEventTime::IfcEventTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEventTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEventTime::IfcEventTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< std::string > v4_ActualDate, boost::optional< std::string > v5_EarlyDate, boost::optional< std::string > v6_LateDate, boost::optional< std::string > v7_ScheduleDate) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_ActualDate) { e->setArgument(3,(*v4_ActualDate)); } else { e->setArgument(3); } if (v5_EarlyDate) { e->setArgument(4,(*v5_EarlyDate)); } else { e->setArgument(4); } if (v6_LateDate) { e->setArgument(5,(*v6_LateDate)); } else { e->setArgument(5); } if (v7_ScheduleDate) { e->setArgument(6,(*v7_ScheduleDate)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcEventType -IfcEventTypeEnum::IfcEventTypeEnum IfcEventType::PredefinedType() const { return IfcEventTypeEnum::FromString(*entity->getArgument(9)); } -void IfcEventType::setPredefinedType(IfcEventTypeEnum::IfcEventTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcEventTypeEnum::ToString(v)); } -IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum IfcEventType::EventTriggerType() const { return IfcEventTriggerTypeEnum::FromString(*entity->getArgument(10)); } -void IfcEventType::setEventTriggerType(IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcEventTriggerTypeEnum::ToString(v)); } -bool IfcEventType::hasUserDefinedEventTriggerType() const { return !entity->getArgument(11)->isNull(); } -std::string IfcEventType::UserDefinedEventTriggerType() const { return *entity->getArgument(11); } -void IfcEventType::setUserDefinedEventTriggerType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcEventType::is(Type::Enum v) const { return v == Type::IfcEventType || IfcTypeProcess::is(v); } -Type::Enum IfcEventType::type() const { return Type::IfcEventType; } +IfcEventTypeEnum::IfcEventTypeEnum IfcEventType::PredefinedType() const { return IfcEventTypeEnum::FromString(*data_->getArgument(9)); } +void IfcEventType::setPredefinedType(IfcEventTypeEnum::IfcEventTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcEventTypeEnum::ToString(v)); } +IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum IfcEventType::EventTriggerType() const { return IfcEventTriggerTypeEnum::FromString(*data_->getArgument(10)); } +void IfcEventType::setEventTriggerType(IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcEventTriggerTypeEnum::ToString(v)); } +bool IfcEventType::hasUserDefinedEventTriggerType() const { return !data_->getArgument(11)->isNull(); } +std::string IfcEventType::UserDefinedEventTriggerType() const { return *data_->getArgument(11); } +void IfcEventType::setUserDefinedEventTriggerType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcEventType::declaration() const { return *IfcEventType_type; } Type::Enum IfcEventType::Class() { return Type::IfcEventType; } -IfcEventType::IfcEventType(IfcAbstractEntity* e) : IfcTypeProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEventType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcEventType::IfcEventType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcEventTypeEnum::IfcEventTypeEnum v10_PredefinedType, IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v11_EventTriggerType, boost::optional< std::string > v12_UserDefinedEventTriggerType) : IfcTypeProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcEventTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,v11_EventTriggerType,IfcEventTriggerTypeEnum::ToString(v11_EventTriggerType)); if (v12_UserDefinedEventTriggerType) { e->setArgument(11,(*v12_UserDefinedEventTriggerType)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcEventType::IfcEventType(IfcAbstractEntity* e) : IfcTypeProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcEventType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcEventType::IfcEventType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcEventTypeEnum::IfcEventTypeEnum v10_PredefinedType, IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v11_EventTriggerType, boost::optional< std::string > v12_UserDefinedEventTriggerType) : IfcTypeProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcEventTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,v11_EventTriggerType,IfcEventTriggerTypeEnum::ToString(v11_EventTriggerType)); if (v12_UserDefinedEventTriggerType) { e->setArgument(11,(*v12_UserDefinedEventTriggerType)); } else { e->setArgument(11); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExtendedProperties -bool IfcExtendedProperties::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcExtendedProperties::Name() const { return *entity->getArgument(0); } -void IfcExtendedProperties::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcExtendedProperties::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcExtendedProperties::Description() const { return *entity->getArgument(1); } -void IfcExtendedProperties::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTemplatedEntityList< IfcProperty >::ptr IfcExtendedProperties::Properties() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcExtendedProperties::setProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcExtendedProperties::is(Type::Enum v) const { return v == Type::IfcExtendedProperties || IfcPropertyAbstraction::is(v); } -Type::Enum IfcExtendedProperties::type() const { return Type::IfcExtendedProperties; } +bool IfcExtendedProperties::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcExtendedProperties::Name() const { return *data_->getArgument(0); } +void IfcExtendedProperties::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcExtendedProperties::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcExtendedProperties::Description() const { return *data_->getArgument(1); } +void IfcExtendedProperties::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTemplatedEntityList< IfcProperty >::ptr IfcExtendedProperties::Properties() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcExtendedProperties::setProperties(IfcTemplatedEntityList< IfcProperty >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } + + +const IfcParse::entity& IfcExtendedProperties::declaration() const { return *IfcExtendedProperties_type; } Type::Enum IfcExtendedProperties::Class() { return Type::IfcExtendedProperties; } -IfcExtendedProperties::IfcExtendedProperties(IfcAbstractEntity* e) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtendedProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExtendedProperties::IfcExtendedProperties(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties) : IfcPropertyAbstraction((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_Properties)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcExtendedProperties::IfcExtendedProperties(IfcAbstractEntity* e) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtendedProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExtendedProperties::IfcExtendedProperties(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties) : IfcPropertyAbstraction((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_Properties)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternalInformation -bool IfcExternalInformation::is(Type::Enum v) const { return v == Type::IfcExternalInformation; } -Type::Enum IfcExternalInformation::type() const { return Type::IfcExternalInformation; } + + +const IfcParse::entity& IfcExternalInformation::declaration() const { return *IfcExternalInformation_type; } Type::Enum IfcExternalInformation::Class() { return Type::IfcExternalInformation; } -IfcExternalInformation::IfcExternalInformation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcExternalInformation)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternalInformation::IfcExternalInformation() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcExternalInformation::IfcExternalInformation(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcExternalInformation)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternalInformation::IfcExternalInformation() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); 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::hasIdentification() const { return !entity->getArgument(1)->isNull(); } -std::string IfcExternalReference::Identification() const { return *entity->getArgument(1); } -void IfcExternalReference::setIdentification(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); } -IfcExternalReferenceRelationship::list::ptr IfcExternalReference::ExternalReferenceForResources() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 2)->as(); } -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::hasIdentification() const { return !data_->getArgument(1)->isNull(); } +std::string IfcExternalReference::Identification() const { return *data_->getArgument(1); } +void IfcExternalReference::setIdentification(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); } + +IfcExternalReferenceRelationship::list::ptr IfcExternalReference::ExternalReferenceForResources() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 2)->as(); } + +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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternalReferenceRelationship -IfcExternalReference* IfcExternalReferenceRelationship::RelatingReference() const { return (IfcExternalReference*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcExternalReferenceRelationship::setRelatingReference(IfcExternalReference* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcEntityList::ptr IfcExternalReferenceRelationship::RelatedResourceObjects() const { return *entity->getArgument(3); } -void IfcExternalReferenceRelationship::setRelatedResourceObjects(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcExternalReferenceRelationship::is(Type::Enum v) const { return v == Type::IfcExternalReferenceRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcExternalReferenceRelationship::type() const { return Type::IfcExternalReferenceRelationship; } +IfcExternalReference* IfcExternalReferenceRelationship::RelatingReference() const { return (IfcExternalReference*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcExternalReferenceRelationship::setRelatingReference(IfcExternalReference* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcEntityList::ptr IfcExternalReferenceRelationship::RelatedResourceObjects() const { return *data_->getArgument(3); } +void IfcExternalReferenceRelationship::setRelatedResourceObjects(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcExternalReferenceRelationship::declaration() const { return *IfcExternalReferenceRelationship_type; } Type::Enum IfcExternalReferenceRelationship::Class() { return Type::IfcExternalReferenceRelationship; } -IfcExternalReferenceRelationship::IfcExternalReferenceRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternalReferenceRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternalReferenceRelationship::IfcExternalReferenceRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcExternalReference* v3_RelatingReference, IfcEntityList::ptr v4_RelatedResourceObjects) : IfcResourceLevelRelationship((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_RelatingReference)); e->setArgument(3,(v4_RelatedResourceObjects)); entity = e; EntityBuffer::Add(this); } +IfcExternalReferenceRelationship::IfcExternalReferenceRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternalReferenceRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternalReferenceRelationship::IfcExternalReferenceRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcExternalReference* v3_RelatingReference, IfcEntityList::ptr v4_RelatedResourceObjects) : IfcResourceLevelRelationship((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_RelatingReference)); e->setArgument(3,(v4_RelatedResourceObjects)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternalSpatialElement -bool IfcExternalSpatialElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum IfcExternalSpatialElement::PredefinedType() const { return IfcExternalSpatialElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcExternalSpatialElement::setPredefinedType(IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcExternalSpatialElementTypeEnum::ToString(v)); } -IfcRelSpaceBoundary::list::ptr IfcExternalSpatialElement::BoundedBy() const { return entity->getInverse(Type::IfcRelSpaceBoundary, 4)->as(); } -bool IfcExternalSpatialElement::is(Type::Enum v) const { return v == Type::IfcExternalSpatialElement || IfcExternalSpatialStructureElement::is(v); } -Type::Enum IfcExternalSpatialElement::type() const { return Type::IfcExternalSpatialElement; } +bool IfcExternalSpatialElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum IfcExternalSpatialElement::PredefinedType() const { return IfcExternalSpatialElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcExternalSpatialElement::setPredefinedType(IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcExternalSpatialElementTypeEnum::ToString(v)); } + +IfcRelSpaceBoundary::list::ptr IfcExternalSpatialElement::BoundedBy() const { return data_->getInverse(Type::IfcRelSpaceBoundary, 4)->as(); } + +const IfcParse::entity& IfcExternalSpatialElement::declaration() const { return *IfcExternalSpatialElement_type; } Type::Enum IfcExternalSpatialElement::Class() { return Type::IfcExternalSpatialElement; } -IfcExternalSpatialElement::IfcExternalSpatialElement(IfcAbstractEntity* e) : IfcExternalSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternalSpatialElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternalSpatialElement::IfcExternalSpatialElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum > v9_PredefinedType) : IfcExternalSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcExternalSpatialElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcExternalSpatialElement::IfcExternalSpatialElement(IfcAbstractEntity* e) : IfcExternalSpatialStructureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternalSpatialElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternalSpatialElement::IfcExternalSpatialElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum > v9_PredefinedType) : IfcExternalSpatialStructureElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcExternalSpatialElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcExternalSpatialStructureElement -bool IfcExternalSpatialStructureElement::is(Type::Enum v) const { return v == Type::IfcExternalSpatialStructureElement || IfcSpatialElement::is(v); } -Type::Enum IfcExternalSpatialStructureElement::type() const { return Type::IfcExternalSpatialStructureElement; } + + +const IfcParse::entity& IfcExternalSpatialStructureElement::declaration() const { return *IfcExternalSpatialStructureElement_type; } Type::Enum IfcExternalSpatialStructureElement::Class() { return Type::IfcExternalSpatialStructureElement; } -IfcExternalSpatialStructureElement::IfcExternalSpatialStructureElement(IfcAbstractEntity* e) : IfcSpatialElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternalSpatialStructureElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExternalSpatialStructureElement::IfcExternalSpatialStructureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : IfcSpatialElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } entity = e; EntityBuffer::Add(this); } +IfcExternalSpatialStructureElement::IfcExternalSpatialStructureElement(IfcAbstractEntity* e) : IfcSpatialElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExternalSpatialStructureElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExternalSpatialStructureElement::IfcExternalSpatialStructureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : IfcSpatialElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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_Identification, 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_Identification) { e->setArgument(1,(*v2_Identification)); } 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 IfcExtrudedAreaSolidTapered -IfcProfileDef* IfcExtrudedAreaSolidTapered::EndSweptArea() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcExtrudedAreaSolidTapered::setEndSweptArea(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcExtrudedAreaSolidTapered::is(Type::Enum v) const { return v == Type::IfcExtrudedAreaSolidTapered || IfcExtrudedAreaSolid::is(v); } -Type::Enum IfcExtrudedAreaSolidTapered::type() const { return Type::IfcExtrudedAreaSolidTapered; } +IfcProfileDef* IfcExtrudedAreaSolidTapered::EndSweptArea() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcExtrudedAreaSolidTapered::setEndSweptArea(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcExtrudedAreaSolidTapered::declaration() const { return *IfcExtrudedAreaSolidTapered_type; } Type::Enum IfcExtrudedAreaSolidTapered::Class() { return Type::IfcExtrudedAreaSolidTapered; } -IfcExtrudedAreaSolidTapered::IfcExtrudedAreaSolidTapered(IfcAbstractEntity* e) : IfcExtrudedAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtrudedAreaSolidTapered)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcExtrudedAreaSolidTapered::IfcExtrudedAreaSolidTapered(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth, IfcProfileDef* v5_EndSweptArea) : IfcExtrudedAreaSolid((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)); e->setArgument(4,(v5_EndSweptArea)); entity = e; EntityBuffer::Add(this); } +IfcExtrudedAreaSolidTapered::IfcExtrudedAreaSolidTapered(IfcAbstractEntity* e) : IfcExtrudedAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcExtrudedAreaSolidTapered)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcExtrudedAreaSolidTapered::IfcExtrudedAreaSolidTapered(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth, IfcProfileDef* v5_EndSweptArea) : IfcExtrudedAreaSolid((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)); e->setArgument(4,(v5_EndSweptArea)); 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()); } -IfcTextureMap::list::ptr IfcFace::HasTextureMaps() const { return entity->getInverse(Type::IfcTextureMap, 2)->as(); } -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()); } + +IfcTextureMap::list::ptr IfcFace::HasTextureMaps() const { return data_->getInverse(Type::IfcTextureMap, 2)->as(); } + +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 || IfcFacetedBrep::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) : IfcFacetedBrep((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) : IfcFacetedBrep((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) : IfcFacetedBrep((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) : IfcFacetedBrep((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 IfcFan -bool IfcFan::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFanTypeEnum::IfcFanTypeEnum IfcFan::PredefinedType() const { return IfcFanTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFan::setPredefinedType(IfcFanTypeEnum::IfcFanTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFanTypeEnum::ToString(v)); } -bool IfcFan::is(Type::Enum v) const { return v == Type::IfcFan || IfcFlowMovingDevice::is(v); } -Type::Enum IfcFan::type() const { return Type::IfcFan; } +bool IfcFan::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFanTypeEnum::IfcFanTypeEnum IfcFan::PredefinedType() const { return IfcFanTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFan::setPredefinedType(IfcFanTypeEnum::IfcFanTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFanTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFan::declaration() const { return *IfcFan_type; } Type::Enum IfcFan::Class() { return Type::IfcFan; } -IfcFan::IfcFan(IfcAbstractEntity* e) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFan)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFan::IfcFan(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFanTypeEnum::IfcFanTypeEnum > v9_PredefinedType) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFanTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFan::IfcFan(IfcAbstractEntity* e) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFan)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFan::IfcFan(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFanTypeEnum::IfcFanTypeEnum > v9_PredefinedType) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFanTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFastenerTypeEnum::IfcFastenerTypeEnum IfcFastener::PredefinedType() const { return IfcFastenerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFastener::setPredefinedType(IfcFastenerTypeEnum::IfcFastenerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFastenerTypeEnum::ToString(v)); } -bool IfcFastener::is(Type::Enum v) const { return v == Type::IfcFastener || IfcElementComponent::is(v); } -Type::Enum IfcFastener::type() const { return Type::IfcFastener; } +bool IfcFastener::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFastenerTypeEnum::IfcFastenerTypeEnum IfcFastener::PredefinedType() const { return IfcFastenerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFastener::setPredefinedType(IfcFastenerTypeEnum::IfcFastenerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFastenerTypeEnum::ToString(v)); } + + +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, boost::optional< IfcFastenerTypeEnum::IfcFastenerTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcFastenerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcFastenerTypeEnum::IfcFastenerTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcFastenerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFastenerType -IfcFastenerTypeEnum::IfcFastenerTypeEnum IfcFastenerType::PredefinedType() const { return IfcFastenerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFastenerType::setPredefinedType(IfcFastenerTypeEnum::IfcFastenerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFastenerTypeEnum::ToString(v)); } -bool IfcFastenerType::is(Type::Enum v) const { return v == Type::IfcFastenerType || IfcElementComponentType::is(v); } -Type::Enum IfcFastenerType::type() const { return Type::IfcFastenerType; } +IfcFastenerTypeEnum::IfcFastenerTypeEnum IfcFastenerType::PredefinedType() const { return IfcFastenerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFastenerType::setPredefinedType(IfcFastenerTypeEnum::IfcFastenerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFastenerTypeEnum::ToString(v)); } + + +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, IfcFastenerTypeEnum::IfcFastenerTypeEnum v10_PredefinedType) : 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); } e->setArgument(9,v10_PredefinedType,IfcFastenerTypeEnum::ToString(v10_PredefinedType)); 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, IfcFastenerTypeEnum::IfcFastenerTypeEnum v10_PredefinedType) : 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); } e->setArgument(9,v10_PredefinedType,IfcFastenerTypeEnum::ToString(v10_PredefinedType)); 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::hasModelorDraughting() const { return !entity->getArgument(2)->isNull(); } -bool IfcFillAreaStyle::ModelorDraughting() const { return *entity->getArgument(2); } -void IfcFillAreaStyle::setModelorDraughting(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,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); } +bool IfcFillAreaStyle::hasModelorDraughting() const { return !data_->getArgument(2)->isNull(); } +bool IfcFillAreaStyle::ModelorDraughting() const { return *data_->getArgument(2); } +void IfcFillAreaStyle::setModelorDraughting(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,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, boost::optional< bool > v3_ModelorDraughting) : 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)); if (v3_ModelorDraughting) { e->setArgument(2,(*v3_ModelorDraughting)); } else { e->setArgument(2); } 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, boost::optional< bool > v3_ModelorDraughting) : 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)); if (v3_ModelorDraughting) { e->setArgument(2,(*v3_ModelorDraughting)); } else { e->setArgument(2); } 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 IfcFillAreaStyleTiles -IfcTemplatedEntityList< IfcVector >::ptr IfcFillAreaStyleTiles::TilingPattern() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcFillAreaStyleTiles::setTilingPattern(IfcTemplatedEntityList< IfcVector >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -IfcTemplatedEntityList< IfcStyledItem >::ptr IfcFillAreaStyleTiles::Tiles() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcFillAreaStyleTiles::setTiles(IfcTemplatedEntityList< IfcStyledItem >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -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; } +IfcTemplatedEntityList< IfcVector >::ptr IfcFillAreaStyleTiles::TilingPattern() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcFillAreaStyleTiles::setTilingPattern(IfcTemplatedEntityList< IfcVector >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } +IfcTemplatedEntityList< IfcStyledItem >::ptr IfcFillAreaStyleTiles::Tiles() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcFillAreaStyleTiles::setTiles(IfcTemplatedEntityList< IfcStyledItem >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +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(IfcTemplatedEntityList< IfcVector >::ptr v1_TilingPattern, IfcTemplatedEntityList< IfcStyledItem >::ptr v2_Tiles, double v3_TilingScale) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TilingPattern)->generalize()); e->setArgument(1,(v2_Tiles)->generalize()); 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(IfcTemplatedEntityList< IfcVector >::ptr v1_TilingPattern, IfcTemplatedEntityList< IfcStyledItem >::ptr v2_Tiles, double v3_TilingScale) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TilingPattern)->generalize()); e->setArgument(1,(v2_Tiles)->generalize()); e->setArgument(2,(v3_TilingScale)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFilter -bool IfcFilter::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilter::PredefinedType() const { return IfcFilterTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFilter::setPredefinedType(IfcFilterTypeEnum::IfcFilterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFilterTypeEnum::ToString(v)); } -bool IfcFilter::is(Type::Enum v) const { return v == Type::IfcFilter || IfcFlowTreatmentDevice::is(v); } -Type::Enum IfcFilter::type() const { return Type::IfcFilter; } +bool IfcFilter::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilter::PredefinedType() const { return IfcFilterTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFilter::setPredefinedType(IfcFilterTypeEnum::IfcFilterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFilterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFilter::declaration() const { return *IfcFilter_type; } Type::Enum IfcFilter::Class() { return Type::IfcFilter; } -IfcFilter::IfcFilter(IfcAbstractEntity* e) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFilter)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFilter::IfcFilter(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFilterTypeEnum::IfcFilterTypeEnum > v9_PredefinedType) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFilterTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFilter::IfcFilter(IfcAbstractEntity* e) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFilter)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFilter::IfcFilter(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFilterTypeEnum::IfcFilterTypeEnum > v9_PredefinedType) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFilterTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcFireSuppressionTerminal -bool IfcFireSuppressionTerminal::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminal::PredefinedType() const { return IfcFireSuppressionTerminalTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFireSuppressionTerminal::setPredefinedType(IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFireSuppressionTerminalTypeEnum::ToString(v)); } -bool IfcFireSuppressionTerminal::is(Type::Enum v) const { return v == Type::IfcFireSuppressionTerminal || IfcFlowTerminal::is(v); } -Type::Enum IfcFireSuppressionTerminal::type() const { return Type::IfcFireSuppressionTerminal; } +bool IfcFireSuppressionTerminal::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminal::PredefinedType() const { return IfcFireSuppressionTerminalTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFireSuppressionTerminal::setPredefinedType(IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFireSuppressionTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFireSuppressionTerminal::declaration() const { return *IfcFireSuppressionTerminal_type; } Type::Enum IfcFireSuppressionTerminal::Class() { return Type::IfcFireSuppressionTerminal; } -IfcFireSuppressionTerminal::IfcFireSuppressionTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFireSuppressionTerminal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFireSuppressionTerminal::IfcFireSuppressionTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFireSuppressionTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFireSuppressionTerminal::IfcFireSuppressionTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFireSuppressionTerminal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFireSuppressionTerminal::IfcFireSuppressionTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFireSuppressionTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcFixedReferenceSweptAreaSolid -IfcCurve* IfcFixedReferenceSweptAreaSolid::Directrix() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcFixedReferenceSweptAreaSolid::setDirectrix(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcFixedReferenceSweptAreaSolid::hasStartParam() const { return !entity->getArgument(3)->isNull(); } -double IfcFixedReferenceSweptAreaSolid::StartParam() const { return *entity->getArgument(3); } -void IfcFixedReferenceSweptAreaSolid::setStartParam(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcFixedReferenceSweptAreaSolid::hasEndParam() const { return !entity->getArgument(4)->isNull(); } -double IfcFixedReferenceSweptAreaSolid::EndParam() const { return *entity->getArgument(4); } -void IfcFixedReferenceSweptAreaSolid::setEndParam(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcDirection* IfcFixedReferenceSweptAreaSolid::FixedReference() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcFixedReferenceSweptAreaSolid::setFixedReference(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcFixedReferenceSweptAreaSolid::is(Type::Enum v) const { return v == Type::IfcFixedReferenceSweptAreaSolid || IfcSweptAreaSolid::is(v); } -Type::Enum IfcFixedReferenceSweptAreaSolid::type() const { return Type::IfcFixedReferenceSweptAreaSolid; } +IfcCurve* IfcFixedReferenceSweptAreaSolid::Directrix() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcFixedReferenceSweptAreaSolid::setDirectrix(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcFixedReferenceSweptAreaSolid::hasStartParam() const { return !data_->getArgument(3)->isNull(); } +double IfcFixedReferenceSweptAreaSolid::StartParam() const { return *data_->getArgument(3); } +void IfcFixedReferenceSweptAreaSolid::setStartParam(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcFixedReferenceSweptAreaSolid::hasEndParam() const { return !data_->getArgument(4)->isNull(); } +double IfcFixedReferenceSweptAreaSolid::EndParam() const { return *data_->getArgument(4); } +void IfcFixedReferenceSweptAreaSolid::setEndParam(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcDirection* IfcFixedReferenceSweptAreaSolid::FixedReference() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcFixedReferenceSweptAreaSolid::setFixedReference(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcFixedReferenceSweptAreaSolid::declaration() const { return *IfcFixedReferenceSweptAreaSolid_type; } Type::Enum IfcFixedReferenceSweptAreaSolid::Class() { return Type::IfcFixedReferenceSweptAreaSolid; } -IfcFixedReferenceSweptAreaSolid::IfcFixedReferenceSweptAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFixedReferenceSweptAreaSolid)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFixedReferenceSweptAreaSolid::IfcFixedReferenceSweptAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcCurve* v3_Directrix, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, IfcDirection* v6_FixedReference) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_Directrix)); if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } e->setArgument(5,(v6_FixedReference)); entity = e; EntityBuffer::Add(this); } +IfcFixedReferenceSweptAreaSolid::IfcFixedReferenceSweptAreaSolid(IfcAbstractEntity* e) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFixedReferenceSweptAreaSolid)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFixedReferenceSweptAreaSolid::IfcFixedReferenceSweptAreaSolid(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcCurve* v3_Directrix, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, IfcDirection* v6_FixedReference) : IfcSweptAreaSolid((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SweptArea)); e->setArgument(1,(v2_Position)); e->setArgument(2,(v3_Directrix)); if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } e->setArgument(5,(v6_FixedReference)); 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 IfcFlowInstrument -bool IfcFlowInstrument::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrument::PredefinedType() const { return IfcFlowInstrumentTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFlowInstrument::setPredefinedType(IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFlowInstrumentTypeEnum::ToString(v)); } -bool IfcFlowInstrument::is(Type::Enum v) const { return v == Type::IfcFlowInstrument || IfcDistributionControlElement::is(v); } -Type::Enum IfcFlowInstrument::type() const { return Type::IfcFlowInstrument; } +bool IfcFlowInstrument::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrument::PredefinedType() const { return IfcFlowInstrumentTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFlowInstrument::setPredefinedType(IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFlowInstrumentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFlowInstrument::declaration() const { return *IfcFlowInstrument_type; } Type::Enum IfcFlowInstrument::Class() { return Type::IfcFlowInstrument; } -IfcFlowInstrument::IfcFlowInstrument(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowInstrument)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowInstrument::IfcFlowInstrument(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFlowInstrumentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowInstrument::IfcFlowInstrument(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowInstrument)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowInstrument::IfcFlowInstrument(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFlowInstrumentTypeEnum::ToString(*v9_PredefinedType)); } 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 IfcFlowMeter -bool IfcFlowMeter::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeter::PredefinedType() const { return IfcFlowMeterTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFlowMeter::setPredefinedType(IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFlowMeterTypeEnum::ToString(v)); } -bool IfcFlowMeter::is(Type::Enum v) const { return v == Type::IfcFlowMeter || IfcFlowController::is(v); } -Type::Enum IfcFlowMeter::type() const { return Type::IfcFlowMeter; } +bool IfcFlowMeter::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeter::PredefinedType() const { return IfcFlowMeterTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFlowMeter::setPredefinedType(IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFlowMeterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFlowMeter::declaration() const { return *IfcFlowMeter_type; } Type::Enum IfcFlowMeter::Class() { return Type::IfcFlowMeter; } -IfcFlowMeter::IfcFlowMeter(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMeter)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFlowMeter::IfcFlowMeter(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcFlowMeterTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFlowMeter::IfcFlowMeter(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFlowMeter)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFlowMeter::IfcFlowMeter(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcFlowMeterTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcFooting -bool IfcFooting::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -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; } +bool IfcFooting::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +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, boost::optional< 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcFootingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcFootingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcFootingType -IfcFootingTypeEnum::IfcFootingTypeEnum IfcFootingType::PredefinedType() const { return IfcFootingTypeEnum::FromString(*entity->getArgument(9)); } -void IfcFootingType::setPredefinedType(IfcFootingTypeEnum::IfcFootingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcFootingTypeEnum::ToString(v)); } -bool IfcFootingType::is(Type::Enum v) const { return v == Type::IfcFootingType || IfcBuildingElementType::is(v); } -Type::Enum IfcFootingType::type() const { return Type::IfcFootingType; } +IfcFootingTypeEnum::IfcFootingTypeEnum IfcFootingType::PredefinedType() const { return IfcFootingTypeEnum::FromString(*data_->getArgument(9)); } +void IfcFootingType::setPredefinedType(IfcFootingTypeEnum::IfcFootingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcFootingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFootingType::declaration() const { return *IfcFootingType_type; } Type::Enum IfcFootingType::Class() { return Type::IfcFootingType; } -IfcFootingType::IfcFootingType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFootingType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFootingType::IfcFootingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFootingTypeEnum::IfcFootingTypeEnum 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,IfcFootingTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcFootingType::IfcFootingType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFootingType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFootingType::IfcFootingType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFootingTypeEnum::IfcFootingTypeEnum 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,IfcFootingTypeEnum::ToString(v10_PredefinedType)); 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 IfcFurniture -bool IfcFurniture::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcFurnitureTypeEnum::IfcFurnitureTypeEnum IfcFurniture::PredefinedType() const { return IfcFurnitureTypeEnum::FromString(*entity->getArgument(8)); } -void IfcFurniture::setPredefinedType(IfcFurnitureTypeEnum::IfcFurnitureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcFurnitureTypeEnum::ToString(v)); } -bool IfcFurniture::is(Type::Enum v) const { return v == Type::IfcFurniture || IfcFurnishingElement::is(v); } -Type::Enum IfcFurniture::type() const { return Type::IfcFurniture; } +bool IfcFurniture::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcFurnitureTypeEnum::IfcFurnitureTypeEnum IfcFurniture::PredefinedType() const { return IfcFurnitureTypeEnum::FromString(*data_->getArgument(8)); } +void IfcFurniture::setPredefinedType(IfcFurnitureTypeEnum::IfcFurnitureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcFurnitureTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcFurniture::declaration() const { return *IfcFurniture_type; } Type::Enum IfcFurniture::Class() { return Type::IfcFurniture; } -IfcFurniture::IfcFurniture(IfcAbstractEntity* e) : IfcFurnishingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurniture)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcFurniture::IfcFurniture(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFurnitureTypeEnum::IfcFurnitureTypeEnum > v9_PredefinedType) : IfcFurnishingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFurnitureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcFurniture::IfcFurniture(IfcAbstractEntity* e) : IfcFurnishingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcFurniture)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcFurniture::IfcFurniture(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFurnitureTypeEnum::IfcFurnitureTypeEnum > v9_PredefinedType) : IfcFurnishingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcFurnitureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcFurnitureTypeEnum::IfcFurnitureTypeEnum IfcFurnitureType::PredefinedType() const { return IfcFurnitureTypeEnum::FromString(*entity->getArgument(10)); } -void IfcFurnitureType::setPredefinedType(IfcFurnitureTypeEnum::IfcFurnitureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcFurnitureTypeEnum::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)); } +bool IfcFurnitureType::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcFurnitureTypeEnum::IfcFurnitureTypeEnum IfcFurnitureType::PredefinedType() const { return IfcFurnitureTypeEnum::FromString(*data_->getArgument(10)); } +void IfcFurnitureType::setPredefinedType(IfcFurnitureTypeEnum::IfcFurnitureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcFurnitureTypeEnum::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, boost::optional< IfcFurnitureTypeEnum::IfcFurnitureTypeEnum > v11_PredefinedType) : 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)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcFurnitureTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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, boost::optional< IfcFurnitureTypeEnum::IfcFurnitureTypeEnum > v11_PredefinedType) : 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)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcFurnitureTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeographicElement -bool IfcGeographicElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum IfcGeographicElement::PredefinedType() const { return IfcGeographicElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcGeographicElement::setPredefinedType(IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcGeographicElementTypeEnum::ToString(v)); } -bool IfcGeographicElement::is(Type::Enum v) const { return v == Type::IfcGeographicElement || IfcElement::is(v); } -Type::Enum IfcGeographicElement::type() const { return Type::IfcGeographicElement; } +bool IfcGeographicElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum IfcGeographicElement::PredefinedType() const { return IfcGeographicElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcGeographicElement::setPredefinedType(IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcGeographicElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcGeographicElement::declaration() const { return *IfcGeographicElement_type; } Type::Enum IfcGeographicElement::Class() { return Type::IfcGeographicElement; } -IfcGeographicElement::IfcGeographicElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeographicElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeographicElement::IfcGeographicElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum > v9_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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcGeographicElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcGeographicElement::IfcGeographicElement(IfcAbstractEntity* e) : IfcElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeographicElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeographicElement::IfcGeographicElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum > v9_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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcGeographicElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcGeographicElementType -IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum IfcGeographicElementType::PredefinedType() const { return IfcGeographicElementTypeEnum::FromString(*entity->getArgument(9)); } -void IfcGeographicElementType::setPredefinedType(IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcGeographicElementTypeEnum::ToString(v)); } -bool IfcGeographicElementType::is(Type::Enum v) const { return v == Type::IfcGeographicElementType || IfcElementType::is(v); } -Type::Enum IfcGeographicElementType::type() const { return Type::IfcGeographicElementType; } +IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum IfcGeographicElementType::PredefinedType() const { return IfcGeographicElementTypeEnum::FromString(*data_->getArgument(9)); } +void IfcGeographicElementType::setPredefinedType(IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcGeographicElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcGeographicElementType::declaration() const { return *IfcGeographicElementType_type; } Type::Enum IfcGeographicElementType::Class() { return Type::IfcGeographicElementType; } -IfcGeographicElementType::IfcGeographicElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeographicElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcGeographicElementType::IfcGeographicElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum 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,IfcGeographicElementTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcGeographicElementType::IfcGeographicElementType(IfcAbstractEntity* e) : IfcElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcGeographicElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcGeographicElementType::IfcGeographicElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum 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,IfcGeographicElementTypeEnum::ToString(v10_PredefinedType)); 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()); } -bool IfcGrid::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcGridTypeEnum::IfcGridTypeEnum IfcGrid::PredefinedType() const { return IfcGridTypeEnum::FromString(*entity->getArgument(10)); } -void IfcGrid::setPredefinedType(IfcGridTypeEnum::IfcGridTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcGridTypeEnum::ToString(v)); } -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()); } +bool IfcGrid::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcGridTypeEnum::IfcGridTypeEnum IfcGrid::PredefinedType() const { return IfcGridTypeEnum::FromString(*data_->getArgument(10)); } +void IfcGrid::setPredefinedType(IfcGridTypeEnum::IfcGridTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcGridTypeEnum::ToString(v)); } + +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, boost::optional< IfcGridTypeEnum::IfcGridTypeEnum > v11_PredefinedType) : 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcGridTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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, boost::optional< IfcGridTypeEnum::IfcGridTypeEnum > v11_PredefinedType) : 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcGridTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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(); } -IfcGridPlacementDirectionSelect* IfcGridPlacement::PlacementRefDirection() const { return (IfcGridPlacementDirectionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcGridPlacement::setPlacementRefDirection(IfcGridPlacementDirectionSelect* 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(); } +IfcGridPlacementDirectionSelect* IfcGridPlacement::PlacementRefDirection() const { return (IfcGridPlacementDirectionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcGridPlacement::setPlacementRefDirection(IfcGridPlacementDirectionSelect* 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, IfcGridPlacementDirectionSelect* 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, IfcGridPlacementDirectionSelect* 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 IfcHeatExchanger -bool IfcHeatExchanger::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchanger::PredefinedType() const { return IfcHeatExchangerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcHeatExchanger::setPredefinedType(IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcHeatExchangerTypeEnum::ToString(v)); } -bool IfcHeatExchanger::is(Type::Enum v) const { return v == Type::IfcHeatExchanger || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcHeatExchanger::type() const { return Type::IfcHeatExchanger; } +bool IfcHeatExchanger::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchanger::PredefinedType() const { return IfcHeatExchangerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcHeatExchanger::setPredefinedType(IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcHeatExchangerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcHeatExchanger::declaration() const { return *IfcHeatExchanger_type; } Type::Enum IfcHeatExchanger::Class() { return Type::IfcHeatExchanger; } -IfcHeatExchanger::IfcHeatExchanger(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHeatExchanger)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcHeatExchanger::IfcHeatExchanger(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcHeatExchangerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcHeatExchanger::IfcHeatExchanger(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHeatExchanger)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcHeatExchanger::IfcHeatExchanger(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcHeatExchangerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcHumidifier -bool IfcHumidifier::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifier::PredefinedType() const { return IfcHumidifierTypeEnum::FromString(*entity->getArgument(8)); } -void IfcHumidifier::setPredefinedType(IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcHumidifierTypeEnum::ToString(v)); } -bool IfcHumidifier::is(Type::Enum v) const { return v == Type::IfcHumidifier || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcHumidifier::type() const { return Type::IfcHumidifier; } +bool IfcHumidifier::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifier::PredefinedType() const { return IfcHumidifierTypeEnum::FromString(*data_->getArgument(8)); } +void IfcHumidifier::setPredefinedType(IfcHumidifierTypeEnum::IfcHumidifierTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcHumidifierTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcHumidifier::declaration() const { return *IfcHumidifier_type; } Type::Enum IfcHumidifier::Class() { return Type::IfcHumidifier; } -IfcHumidifier::IfcHumidifier(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHumidifier)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcHumidifier::IfcHumidifier(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcHumidifierTypeEnum::IfcHumidifierTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcHumidifierTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcHumidifier::IfcHumidifier(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcHumidifier)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcHumidifier::IfcHumidifier(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcHumidifierTypeEnum::IfcHumidifierTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcHumidifierTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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::hasFlangeEdgeRadius() const { return !entity->getArgument(8)->isNull(); } -double IfcIShapeProfileDef::FlangeEdgeRadius() const { return *entity->getArgument(8); } -void IfcIShapeProfileDef::setFlangeEdgeRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcIShapeProfileDef::hasFlangeSlope() const { return !entity->getArgument(9)->isNull(); } -double IfcIShapeProfileDef::FlangeSlope() const { return *entity->getArgument(9); } -void IfcIShapeProfileDef::setFlangeSlope(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,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); } +bool IfcIShapeProfileDef::hasFlangeEdgeRadius() const { return !data_->getArgument(8)->isNull(); } +double IfcIShapeProfileDef::FlangeEdgeRadius() const { return *data_->getArgument(8); } +void IfcIShapeProfileDef::setFlangeEdgeRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcIShapeProfileDef::hasFlangeSlope() const { return !data_->getArgument(9)->isNull(); } +double IfcIShapeProfileDef::FlangeSlope() const { return *data_->getArgument(9); } +void IfcIShapeProfileDef::setFlangeSlope(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,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, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_FlangeSlope) : 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); } if (v9_FlangeEdgeRadius) { e->setArgument(8,(*v9_FlangeEdgeRadius)); } else { e->setArgument(8); } if (v10_FlangeSlope) { e->setArgument(9,(*v10_FlangeSlope)); } else { e->setArgument(9); } 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, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_FlangeSlope) : 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); } if (v9_FlangeEdgeRadius) { e->setArgument(8,(*v9_FlangeEdgeRadius)); } else { e->setArgument(8); } if (v10_FlangeSlope) { e->setArgument(9,(*v10_FlangeSlope)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcImageTexture -std::string IfcImageTexture::URLReference() const { return *entity->getArgument(5); } -void IfcImageTexture::setURLReference(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,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(5); } +void IfcImageTexture::setURLReference(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_URLReference) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } e->setArgument(5,(v6_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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_URLReference) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } e->setArgument(5,(v6_URLReference)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcIndexedColourMap -IfcTessellatedFaceSet* IfcIndexedColourMap::MappedTo() const { return (IfcTessellatedFaceSet*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcIndexedColourMap::setMappedTo(IfcTessellatedFaceSet* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcIndexedColourMap::hasOverrides() const { return !entity->getArgument(1)->isNull(); } -IfcSurfaceStyleShading* IfcIndexedColourMap::Overrides() const { return (IfcSurfaceStyleShading*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcIndexedColourMap::setOverrides(IfcSurfaceStyleShading* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcColourRgbList* IfcIndexedColourMap::Colours() const { return (IfcColourRgbList*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcIndexedColourMap::setColours(IfcColourRgbList* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -std::vector< int > /*[1:?]*/ IfcIndexedColourMap::ColourIndex() const { return *entity->getArgument(3); } -void IfcIndexedColourMap::setColourIndex(std::vector< int > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcIndexedColourMap::is(Type::Enum v) const { return v == Type::IfcIndexedColourMap || IfcPresentationItem::is(v); } -Type::Enum IfcIndexedColourMap::type() const { return Type::IfcIndexedColourMap; } +IfcTessellatedFaceSet* IfcIndexedColourMap::MappedTo() const { return (IfcTessellatedFaceSet*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcIndexedColourMap::setMappedTo(IfcTessellatedFaceSet* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcIndexedColourMap::hasOverrides() const { return !data_->getArgument(1)->isNull(); } +IfcSurfaceStyleShading* IfcIndexedColourMap::Overrides() const { return (IfcSurfaceStyleShading*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcIndexedColourMap::setOverrides(IfcSurfaceStyleShading* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcColourRgbList* IfcIndexedColourMap::Colours() const { return (IfcColourRgbList*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcIndexedColourMap::setColours(IfcColourRgbList* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +std::vector< int > /*[1:?]*/ IfcIndexedColourMap::ColourIndex() const { return *data_->getArgument(3); } +void IfcIndexedColourMap::setColourIndex(std::vector< int > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcIndexedColourMap::declaration() const { return *IfcIndexedColourMap_type; } Type::Enum IfcIndexedColourMap::Class() { return Type::IfcIndexedColourMap; } -IfcIndexedColourMap::IfcIndexedColourMap(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedColourMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcIndexedColourMap::IfcIndexedColourMap(IfcTessellatedFaceSet* v1_MappedTo, IfcSurfaceStyleShading* v2_Overrides, IfcColourRgbList* v3_Colours, std::vector< int > /*[1:?]*/ v4_ColourIndex) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MappedTo)); e->setArgument(1,(v2_Overrides)); e->setArgument(2,(v3_Colours)); e->setArgument(3,(v4_ColourIndex)); entity = e; EntityBuffer::Add(this); } +IfcIndexedColourMap::IfcIndexedColourMap(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedColourMap)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcIndexedColourMap::IfcIndexedColourMap(IfcTessellatedFaceSet* v1_MappedTo, IfcSurfaceStyleShading* v2_Overrides, IfcColourRgbList* v3_Colours, std::vector< int > /*[1:?]*/ v4_ColourIndex) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MappedTo)); e->setArgument(1,(v2_Overrides)); e->setArgument(2,(v3_Colours)); e->setArgument(3,(v4_ColourIndex)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcIndexedTextureMap -IfcTessellatedFaceSet* IfcIndexedTextureMap::MappedTo() const { return (IfcTessellatedFaceSet*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcIndexedTextureMap::setMappedTo(IfcTessellatedFaceSet* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTextureVertexList* IfcIndexedTextureMap::TexCoords() const { return (IfcTextureVertexList*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcIndexedTextureMap::setTexCoords(IfcTextureVertexList* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcIndexedTextureMap::is(Type::Enum v) const { return v == Type::IfcIndexedTextureMap || IfcTextureCoordinate::is(v); } -Type::Enum IfcIndexedTextureMap::type() const { return Type::IfcIndexedTextureMap; } +IfcTessellatedFaceSet* IfcIndexedTextureMap::MappedTo() const { return (IfcTessellatedFaceSet*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcIndexedTextureMap::setMappedTo(IfcTessellatedFaceSet* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTextureVertexList* IfcIndexedTextureMap::TexCoords() const { return (IfcTextureVertexList*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcIndexedTextureMap::setTexCoords(IfcTextureVertexList* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcIndexedTextureMap::declaration() const { return *IfcIndexedTextureMap_type; } Type::Enum IfcIndexedTextureMap::Class() { return Type::IfcIndexedTextureMap; } -IfcIndexedTextureMap::IfcIndexedTextureMap(IfcAbstractEntity* e) : IfcTextureCoordinate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedTextureMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcIndexedTextureMap::IfcIndexedTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); entity = e; EntityBuffer::Add(this); } +IfcIndexedTextureMap::IfcIndexedTextureMap(IfcAbstractEntity* e) : IfcTextureCoordinate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedTextureMap)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcIndexedTextureMap::IfcIndexedTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcIndexedTriangleTextureMap -bool IfcIndexedTriangleTextureMap::hasTexCoordIndex() const { return !entity->getArgument(3)->isNull(); } -std::vector< std::vector< int > > IfcIndexedTriangleTextureMap::TexCoordIndex() const { return *entity->getArgument(3); } -void IfcIndexedTriangleTextureMap::setTexCoordIndex(std::vector< std::vector< int > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcIndexedTriangleTextureMap::is(Type::Enum v) const { return v == Type::IfcIndexedTriangleTextureMap || IfcIndexedTextureMap::is(v); } -Type::Enum IfcIndexedTriangleTextureMap::type() const { return Type::IfcIndexedTriangleTextureMap; } +bool IfcIndexedTriangleTextureMap::hasTexCoordIndex() const { return !data_->getArgument(3)->isNull(); } +std::vector< std::vector< int > > IfcIndexedTriangleTextureMap::TexCoordIndex() const { return *data_->getArgument(3); } +void IfcIndexedTriangleTextureMap::setTexCoordIndex(std::vector< std::vector< int > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcIndexedTriangleTextureMap::declaration() const { return *IfcIndexedTriangleTextureMap_type; } Type::Enum IfcIndexedTriangleTextureMap::Class() { return Type::IfcIndexedTriangleTextureMap; } -IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcAbstractEntity* e) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedTriangleTextureMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords, boost::optional< std::vector< std::vector< int > > > v4_TexCoordIndex) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); if (v4_TexCoordIndex) { e->setArgument(3,(*v4_TexCoordIndex)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcAbstractEntity* e) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedTriangleTextureMap)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords, boost::optional< std::vector< std::vector< int > > > v4_TexCoordIndex) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); if (v4_TexCoordIndex) { e->setArgument(3,(*v4_TexCoordIndex)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcInterceptor -bool IfcInterceptor::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcInterceptorTypeEnum::IfcInterceptorTypeEnum IfcInterceptor::PredefinedType() const { return IfcInterceptorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcInterceptor::setPredefinedType(IfcInterceptorTypeEnum::IfcInterceptorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcInterceptorTypeEnum::ToString(v)); } -bool IfcInterceptor::is(Type::Enum v) const { return v == Type::IfcInterceptor || IfcFlowTreatmentDevice::is(v); } -Type::Enum IfcInterceptor::type() const { return Type::IfcInterceptor; } +bool IfcInterceptor::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcInterceptorTypeEnum::IfcInterceptorTypeEnum IfcInterceptor::PredefinedType() const { return IfcInterceptorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcInterceptor::setPredefinedType(IfcInterceptorTypeEnum::IfcInterceptorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcInterceptorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcInterceptor::declaration() const { return *IfcInterceptor_type; } Type::Enum IfcInterceptor::Class() { return Type::IfcInterceptor; } -IfcInterceptor::IfcInterceptor(IfcAbstractEntity* e) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcInterceptor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcInterceptor::IfcInterceptor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcInterceptorTypeEnum::IfcInterceptorTypeEnum > v9_PredefinedType) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcInterceptorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcInterceptor::IfcInterceptor(IfcAbstractEntity* e) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcInterceptor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcInterceptor::IfcInterceptor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcInterceptorTypeEnum::IfcInterceptorTypeEnum > v9_PredefinedType) : IfcFlowTreatmentDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcInterceptorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcInterceptorType -IfcInterceptorTypeEnum::IfcInterceptorTypeEnum IfcInterceptorType::PredefinedType() const { return IfcInterceptorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcInterceptorType::setPredefinedType(IfcInterceptorTypeEnum::IfcInterceptorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcInterceptorTypeEnum::ToString(v)); } -bool IfcInterceptorType::is(Type::Enum v) const { return v == Type::IfcInterceptorType || IfcFlowTreatmentDeviceType::is(v); } -Type::Enum IfcInterceptorType::type() const { return Type::IfcInterceptorType; } +IfcInterceptorTypeEnum::IfcInterceptorTypeEnum IfcInterceptorType::PredefinedType() const { return IfcInterceptorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcInterceptorType::setPredefinedType(IfcInterceptorTypeEnum::IfcInterceptorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcInterceptorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcInterceptorType::declaration() const { return *IfcInterceptorType_type; } Type::Enum IfcInterceptorType::Class() { return Type::IfcInterceptorType; } -IfcInterceptorType::IfcInterceptorType(IfcAbstractEntity* e) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcInterceptorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcInterceptorType::IfcInterceptorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcInterceptorTypeEnum::IfcInterceptorTypeEnum 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,IfcInterceptorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcInterceptorType::IfcInterceptorType(IfcAbstractEntity* e) : IfcFlowTreatmentDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcInterceptorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcInterceptorType::IfcInterceptorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcInterceptorTypeEnum::IfcInterceptorTypeEnum 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,IfcInterceptorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcInventory -bool IfcInventory::hasPredefinedType() const { return !entity->getArgument(5)->isNull(); } -IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventory::PredefinedType() const { return IfcInventoryTypeEnum::FromString(*entity->getArgument(5)); } -void IfcInventory::setPredefinedType(IfcInventoryTypeEnum::IfcInventoryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v,IfcInventoryTypeEnum::ToString(v)); } -bool IfcInventory::hasJurisdiction() const { return !entity->getArgument(6)->isNull(); } -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); } -bool IfcInventory::hasResponsiblePersons() const { return !entity->getArgument(7)->isNull(); } -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()); } -bool IfcInventory::hasLastUpdateDate() const { return !entity->getArgument(8)->isNull(); } -std::string IfcInventory::LastUpdateDate() const { return *entity->getArgument(8); } -void IfcInventory::setLastUpdateDate(std::string 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; } +bool IfcInventory::hasPredefinedType() const { return !data_->getArgument(5)->isNull(); } +IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventory::PredefinedType() const { return IfcInventoryTypeEnum::FromString(*data_->getArgument(5)); } +void IfcInventory::setPredefinedType(IfcInventoryTypeEnum::IfcInventoryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v,IfcInventoryTypeEnum::ToString(v)); } +bool IfcInventory::hasJurisdiction() const { return !data_->getArgument(6)->isNull(); } +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); } +bool IfcInventory::hasResponsiblePersons() const { return !data_->getArgument(7)->isNull(); } +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()); } +bool IfcInventory::hasLastUpdateDate() const { return !data_->getArgument(8)->isNull(); } +std::string IfcInventory::LastUpdateDate() const { return *data_->getArgument(8); } +void IfcInventory::setLastUpdateDate(std::string 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, boost::optional< IfcInventoryTypeEnum::IfcInventoryTypeEnum > v6_PredefinedType, IfcActorSelect* v7_Jurisdiction, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_ResponsiblePersons, boost::optional< std::string > 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); } if (v6_PredefinedType) { e->setArgument(5,*v6_PredefinedType,IfcInventoryTypeEnum::ToString(*v6_PredefinedType)); } else { e->setArgument(5); } e->setArgument(6,(v7_Jurisdiction)); if (v8_ResponsiblePersons) { e->setArgument(7,(*v8_ResponsiblePersons)->generalize()); } else { e->setArgument(7); } if (v9_LastUpdateDate) { e->setArgument(8,(*v9_LastUpdateDate)); } else { e->setArgument(8); } 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, boost::optional< IfcInventoryTypeEnum::IfcInventoryTypeEnum > v6_PredefinedType, IfcActorSelect* v7_Jurisdiction, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_ResponsiblePersons, boost::optional< std::string > 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); } if (v6_PredefinedType) { e->setArgument(5,*v6_PredefinedType,IfcInventoryTypeEnum::ToString(*v6_PredefinedType)); } else { e->setArgument(5); } e->setArgument(6,(v7_Jurisdiction)); if (v8_ResponsiblePersons) { e->setArgument(7,(*v8_ResponsiblePersons)->generalize()); } else { e->setArgument(7); } if (v9_LastUpdateDate) { e->setArgument(8,(*v9_LastUpdateDate)); } else { e->setArgument(8); } 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, std::string v3_StartTime, std::string 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, std::string v3_StartTime, std::string 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 -std::string IfcIrregularTimeSeriesValue::TimeStamp() const { return *entity->getArgument(0); } -void IfcIrregularTimeSeriesValue::setTimeStamp(std::string 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; } +std::string IfcIrregularTimeSeriesValue::TimeStamp() const { return *data_->getArgument(0); } +void IfcIrregularTimeSeriesValue::setTimeStamp(std::string 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(std::string 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(std::string 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 IfcJunctionBox -bool IfcJunctionBox::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBox::PredefinedType() const { return IfcJunctionBoxTypeEnum::FromString(*entity->getArgument(8)); } -void IfcJunctionBox::setPredefinedType(IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcJunctionBoxTypeEnum::ToString(v)); } -bool IfcJunctionBox::is(Type::Enum v) const { return v == Type::IfcJunctionBox || IfcFlowFitting::is(v); } -Type::Enum IfcJunctionBox::type() const { return Type::IfcJunctionBox; } +bool IfcJunctionBox::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBox::PredefinedType() const { return IfcJunctionBoxTypeEnum::FromString(*data_->getArgument(8)); } +void IfcJunctionBox::setPredefinedType(IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcJunctionBoxTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcJunctionBox::declaration() const { return *IfcJunctionBox_type; } Type::Enum IfcJunctionBox::Class() { return Type::IfcJunctionBox; } -IfcJunctionBox::IfcJunctionBox(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcJunctionBox)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcJunctionBox::IfcJunctionBox(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcJunctionBoxTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcJunctionBox::IfcJunctionBox(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcJunctionBox)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcJunctionBox::IfcJunctionBox(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcJunctionBoxTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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::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); } + + +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) : 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); } 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) : 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); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLaborResource -bool IfcLaborResource::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum IfcLaborResource::PredefinedType() const { return IfcLaborResourceTypeEnum::FromString(*entity->getArgument(10)); } -void IfcLaborResource::setPredefinedType(IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcLaborResourceTypeEnum::ToString(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::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum IfcLaborResource::PredefinedType() const { return IfcLaborResourceTypeEnum::FromString(*data_->getArgument(10)); } +void IfcLaborResource::setPredefinedType(IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcLaborResourceTypeEnum::ToString(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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcLaborResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcLaborResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLaborResourceType -IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum IfcLaborResourceType::PredefinedType() const { return IfcLaborResourceTypeEnum::FromString(*entity->getArgument(11)); } -void IfcLaborResourceType::setPredefinedType(IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcLaborResourceTypeEnum::ToString(v)); } -bool IfcLaborResourceType::is(Type::Enum v) const { return v == Type::IfcLaborResourceType || IfcConstructionResourceType::is(v); } -Type::Enum IfcLaborResourceType::type() const { return Type::IfcLaborResourceType; } +IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum IfcLaborResourceType::PredefinedType() const { return IfcLaborResourceTypeEnum::FromString(*data_->getArgument(11)); } +void IfcLaborResourceType::setPredefinedType(IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcLaborResourceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcLaborResourceType::declaration() const { return *IfcLaborResourceType_type; } Type::Enum IfcLaborResourceType::Class() { return Type::IfcLaborResourceType; } -IfcLaborResourceType::IfcLaborResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLaborResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLaborResourceType::IfcLaborResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcLaborResourceTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcLaborResourceType::IfcLaborResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLaborResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLaborResourceType::IfcLaborResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcLaborResourceTypeEnum::ToString(v12_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLagTime -IfcTimeOrRatioSelect* IfcLagTime::LagValue() const { return (IfcTimeOrRatioSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcLagTime::setLagValue(IfcTimeOrRatioSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -IfcTaskDurationEnum::IfcTaskDurationEnum IfcLagTime::DurationType() const { return IfcTaskDurationEnum::FromString(*entity->getArgument(4)); } -void IfcLagTime::setDurationType(IfcTaskDurationEnum::IfcTaskDurationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcTaskDurationEnum::ToString(v)); } -bool IfcLagTime::is(Type::Enum v) const { return v == Type::IfcLagTime || IfcSchedulingTime::is(v); } -Type::Enum IfcLagTime::type() const { return Type::IfcLagTime; } +IfcTimeOrRatioSelect* IfcLagTime::LagValue() const { return (IfcTimeOrRatioSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcLagTime::setLagValue(IfcTimeOrRatioSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +IfcTaskDurationEnum::IfcTaskDurationEnum IfcLagTime::DurationType() const { return IfcTaskDurationEnum::FromString(*data_->getArgument(4)); } +void IfcLagTime::setDurationType(IfcTaskDurationEnum::IfcTaskDurationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcTaskDurationEnum::ToString(v)); } + + +const IfcParse::entity& IfcLagTime::declaration() const { return *IfcLagTime_type; } Type::Enum IfcLagTime::Class() { return Type::IfcLagTime; } -IfcLagTime::IfcLagTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLagTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLagTime::IfcLagTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, IfcTimeOrRatioSelect* v4_LagValue, IfcTaskDurationEnum::IfcTaskDurationEnum v5_DurationType) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } e->setArgument(3,(v4_LagValue)); e->setArgument(4,v5_DurationType,IfcTaskDurationEnum::ToString(v5_DurationType)); entity = e; EntityBuffer::Add(this); } +IfcLagTime::IfcLagTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLagTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLagTime::IfcLagTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, IfcTimeOrRatioSelect* v4_LagValue, IfcTaskDurationEnum::IfcTaskDurationEnum v5_DurationType) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } e->setArgument(3,(v4_LagValue)); e->setArgument(4,v5_DurationType,IfcTaskDurationEnum::ToString(v5_DurationType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLamp -bool IfcLamp::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcLampTypeEnum::IfcLampTypeEnum IfcLamp::PredefinedType() const { return IfcLampTypeEnum::FromString(*entity->getArgument(8)); } -void IfcLamp::setPredefinedType(IfcLampTypeEnum::IfcLampTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcLampTypeEnum::ToString(v)); } -bool IfcLamp::is(Type::Enum v) const { return v == Type::IfcLamp || IfcFlowTerminal::is(v); } -Type::Enum IfcLamp::type() const { return Type::IfcLamp; } +bool IfcLamp::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcLampTypeEnum::IfcLampTypeEnum IfcLamp::PredefinedType() const { return IfcLampTypeEnum::FromString(*data_->getArgument(8)); } +void IfcLamp::setPredefinedType(IfcLampTypeEnum::IfcLampTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcLampTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcLamp::declaration() const { return *IfcLamp_type; } Type::Enum IfcLamp::Class() { return Type::IfcLamp; } -IfcLamp::IfcLamp(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLamp)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLamp::IfcLamp(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcLampTypeEnum::IfcLampTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcLampTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcLamp::IfcLamp(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLamp)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLamp::IfcLamp(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcLampTypeEnum::IfcLampTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcLampTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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(); } -IfcActorSelect* IfcLibraryInformation::Publisher() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcLibraryInformation::setPublisher(IfcActorSelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcLibraryInformation::hasVersionDate() const { return !entity->getArgument(3)->isNull(); } -std::string IfcLibraryInformation::VersionDate() const { return *entity->getArgument(3); } -void IfcLibraryInformation::setVersionDate(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcLibraryInformation::hasLocation() const { return !entity->getArgument(4)->isNull(); } -std::string IfcLibraryInformation::Location() const { return *entity->getArgument(4); } -void IfcLibraryInformation::setLocation(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcLibraryInformation::hasDescription() const { return !entity->getArgument(5)->isNull(); } -std::string IfcLibraryInformation::Description() const { return *entity->getArgument(5); } -void IfcLibraryInformation::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcRelAssociatesLibrary::list::ptr IfcLibraryInformation::LibraryInfoForObjects() const { return entity->getInverse(Type::IfcRelAssociatesLibrary, 5)->as(); } -IfcLibraryReference::list::ptr IfcLibraryInformation::HasLibraryReferences() const { return entity->getInverse(Type::IfcLibraryReference, 5)->as(); } -bool IfcLibraryInformation::is(Type::Enum v) const { return v == Type::IfcLibraryInformation || IfcExternalInformation::is(v); } -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(); } +IfcActorSelect* IfcLibraryInformation::Publisher() const { return (IfcActorSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcLibraryInformation::setPublisher(IfcActorSelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcLibraryInformation::hasVersionDate() const { return !data_->getArgument(3)->isNull(); } +std::string IfcLibraryInformation::VersionDate() const { return *data_->getArgument(3); } +void IfcLibraryInformation::setVersionDate(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcLibraryInformation::hasLocation() const { return !data_->getArgument(4)->isNull(); } +std::string IfcLibraryInformation::Location() const { return *data_->getArgument(4); } +void IfcLibraryInformation::setLocation(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcLibraryInformation::hasDescription() const { return !data_->getArgument(5)->isNull(); } +std::string IfcLibraryInformation::Description() const { return *data_->getArgument(5); } +void IfcLibraryInformation::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcRelAssociatesLibrary::list::ptr IfcLibraryInformation::LibraryInfoForObjects() const { return data_->getInverse(Type::IfcRelAssociatesLibrary, 5)->as(); } +IfcLibraryReference::list::ptr IfcLibraryInformation::HasLibraryReferences() const { return data_->getInverse(Type::IfcLibraryReference, 5)->as(); } + +const IfcParse::entity& IfcLibraryInformation::declaration() const { return *IfcLibraryInformation_type; } Type::Enum IfcLibraryInformation::Class() { return Type::IfcLibraryInformation; } -IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntity* e) : IfcExternalInformation((IfcAbstractEntity*)0) { 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, IfcActorSelect* v3_Publisher, boost::optional< std::string > v4_VersionDate, boost::optional< std::string > v5_Location, boost::optional< std::string > v6_Description) : IfcExternalInformation((IfcAbstractEntity*)0) { 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)); if (v4_VersionDate) { e->setArgument(3,(*v4_VersionDate)); } else { e->setArgument(3); } if (v5_Location) { e->setArgument(4,(*v5_Location)); } else { e->setArgument(4); } if (v6_Description) { e->setArgument(5,(*v6_Description)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntity* e) : IfcExternalInformation((IfcAbstractEntity*)0) { 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, IfcActorSelect* v3_Publisher, boost::optional< std::string > v4_VersionDate, boost::optional< std::string > v5_Location, boost::optional< std::string > v6_Description) : IfcExternalInformation((IfcAbstractEntity*)0) { 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)); if (v4_VersionDate) { e->setArgument(3,(*v4_VersionDate)); } else { e->setArgument(3); } if (v5_Location) { e->setArgument(4,(*v5_Location)); } else { e->setArgument(4); } if (v6_Description) { e->setArgument(5,(*v6_Description)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcLibraryReference -bool IfcLibraryReference::hasDescription() const { return !entity->getArgument(3)->isNull(); } -std::string IfcLibraryReference::Description() const { return *entity->getArgument(3); } -void IfcLibraryReference::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcLibraryReference::hasLanguage() const { return !entity->getArgument(4)->isNull(); } -std::string IfcLibraryReference::Language() const { return *entity->getArgument(4); } -void IfcLibraryReference::setLanguage(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcLibraryReference::hasReferencedLibrary() const { return !entity->getArgument(5)->isNull(); } -IfcLibraryInformation* IfcLibraryReference::ReferencedLibrary() const { return (IfcLibraryInformation*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcLibraryReference::setReferencedLibrary(IfcLibraryInformation* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcRelAssociatesLibrary::list::ptr IfcLibraryReference::LibraryRefForObjects() const { return entity->getInverse(Type::IfcRelAssociatesLibrary, 5)->as(); } -bool IfcLibraryReference::is(Type::Enum v) const { return v == Type::IfcLibraryReference || IfcExternalReference::is(v); } -Type::Enum IfcLibraryReference::type() const { return Type::IfcLibraryReference; } +bool IfcLibraryReference::hasDescription() const { return !data_->getArgument(3)->isNull(); } +std::string IfcLibraryReference::Description() const { return *data_->getArgument(3); } +void IfcLibraryReference::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcLibraryReference::hasLanguage() const { return !data_->getArgument(4)->isNull(); } +std::string IfcLibraryReference::Language() const { return *data_->getArgument(4); } +void IfcLibraryReference::setLanguage(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcLibraryReference::hasReferencedLibrary() const { return !data_->getArgument(5)->isNull(); } +IfcLibraryInformation* IfcLibraryReference::ReferencedLibrary() const { return (IfcLibraryInformation*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcLibraryReference::setReferencedLibrary(IfcLibraryInformation* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcRelAssociatesLibrary::list::ptr IfcLibraryReference::LibraryRefForObjects() const { return data_->getInverse(Type::IfcRelAssociatesLibrary, 5)->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_Identification, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Language, IfcLibraryInformation* v6_ReferencedLibrary) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_Language) { e->setArgument(4,(*v5_Language)); } else { e->setArgument(4); } e->setArgument(5,(v6_ReferencedLibrary)); 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_Identification, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Language, IfcLibraryInformation* v6_ReferencedLibrary) : IfcExternalReference((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Location) { e->setArgument(0,(*v1_Location)); } else { e->setArgument(0); } if (v2_Identification) { e->setArgument(1,(*v2_Identification)); } else { e->setArgument(1); } if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_Language) { e->setArgument(4,(*v5_Language)); } else { e->setArgument(4); } e->setArgument(5,(v6_ReferencedLibrary)); 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 IfcLightFixture -bool IfcLightFixture::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixture::PredefinedType() const { return IfcLightFixtureTypeEnum::FromString(*entity->getArgument(8)); } -void IfcLightFixture::setPredefinedType(IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcLightFixtureTypeEnum::ToString(v)); } -bool IfcLightFixture::is(Type::Enum v) const { return v == Type::IfcLightFixture || IfcFlowTerminal::is(v); } -Type::Enum IfcLightFixture::type() const { return Type::IfcLightFixture; } +bool IfcLightFixture::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixture::PredefinedType() const { return IfcLightFixtureTypeEnum::FromString(*data_->getArgument(8)); } +void IfcLightFixture::setPredefinedType(IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcLightFixtureTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcLightFixture::declaration() const { return *IfcLightFixture_type; } Type::Enum IfcLightFixture::Class() { return Type::IfcLightFixture; } -IfcLightFixture::IfcLightFixture(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightFixture)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcLightFixture::IfcLightFixture(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcLightFixtureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcLightFixture::IfcLightFixture(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcLightFixture)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcLightFixture::IfcLightFixture(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcLightFixtureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 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 IfcMapConversion -double IfcMapConversion::Eastings() const { return *entity->getArgument(2); } -void IfcMapConversion::setEastings(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -double IfcMapConversion::Northings() const { return *entity->getArgument(3); } -void IfcMapConversion::setNorthings(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -double IfcMapConversion::OrthogonalHeight() const { return *entity->getArgument(4); } -void IfcMapConversion::setOrthogonalHeight(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMapConversion::hasXAxisAbscissa() const { return !entity->getArgument(5)->isNull(); } -double IfcMapConversion::XAxisAbscissa() const { return *entity->getArgument(5); } -void IfcMapConversion::setXAxisAbscissa(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcMapConversion::hasXAxisOrdinate() const { return !entity->getArgument(6)->isNull(); } -double IfcMapConversion::XAxisOrdinate() const { return *entity->getArgument(6); } -void IfcMapConversion::setXAxisOrdinate(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcMapConversion::hasScale() const { return !entity->getArgument(7)->isNull(); } -double IfcMapConversion::Scale() const { return *entity->getArgument(7); } -void IfcMapConversion::setScale(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcMapConversion::is(Type::Enum v) const { return v == Type::IfcMapConversion || IfcCoordinateOperation::is(v); } -Type::Enum IfcMapConversion::type() const { return Type::IfcMapConversion; } +double IfcMapConversion::Eastings() const { return *data_->getArgument(2); } +void IfcMapConversion::setEastings(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +double IfcMapConversion::Northings() const { return *data_->getArgument(3); } +void IfcMapConversion::setNorthings(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +double IfcMapConversion::OrthogonalHeight() const { return *data_->getArgument(4); } +void IfcMapConversion::setOrthogonalHeight(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcMapConversion::hasXAxisAbscissa() const { return !data_->getArgument(5)->isNull(); } +double IfcMapConversion::XAxisAbscissa() const { return *data_->getArgument(5); } +void IfcMapConversion::setXAxisAbscissa(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcMapConversion::hasXAxisOrdinate() const { return !data_->getArgument(6)->isNull(); } +double IfcMapConversion::XAxisOrdinate() const { return *data_->getArgument(6); } +void IfcMapConversion::setXAxisOrdinate(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcMapConversion::hasScale() const { return !data_->getArgument(7)->isNull(); } +double IfcMapConversion::Scale() const { return *data_->getArgument(7); } +void IfcMapConversion::setScale(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcMapConversion::declaration() const { return *IfcMapConversion_type; } Type::Enum IfcMapConversion::Class() { return Type::IfcMapConversion; } -IfcMapConversion::IfcMapConversion(IfcAbstractEntity* e) : IfcCoordinateOperation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMapConversion)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMapConversion::IfcMapConversion(IfcCoordinateReferenceSystemSelect* v1_SourceCRS, IfcCoordinateReferenceSystem* v2_TargetCRS, double v3_Eastings, double v4_Northings, double v5_OrthogonalHeight, boost::optional< double > v6_XAxisAbscissa, boost::optional< double > v7_XAxisOrdinate, boost::optional< double > v8_Scale) : IfcCoordinateOperation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SourceCRS)); e->setArgument(1,(v2_TargetCRS)); e->setArgument(2,(v3_Eastings)); e->setArgument(3,(v4_Northings)); e->setArgument(4,(v5_OrthogonalHeight)); if (v6_XAxisAbscissa) { e->setArgument(5,(*v6_XAxisAbscissa)); } else { e->setArgument(5); } if (v7_XAxisOrdinate) { e->setArgument(6,(*v7_XAxisOrdinate)); } else { e->setArgument(6); } if (v8_Scale) { e->setArgument(7,(*v8_Scale)); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcMapConversion::IfcMapConversion(IfcAbstractEntity* e) : IfcCoordinateOperation((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMapConversion)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMapConversion::IfcMapConversion(IfcCoordinateReferenceSystemSelect* v1_SourceCRS, IfcCoordinateReferenceSystem* v2_TargetCRS, double v3_Eastings, double v4_Northings, double v5_OrthogonalHeight, boost::optional< double > v6_XAxisAbscissa, boost::optional< double > v7_XAxisOrdinate, boost::optional< double > v8_Scale) : IfcCoordinateOperation((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SourceCRS)); e->setArgument(1,(v2_TargetCRS)); e->setArgument(2,(v3_Eastings)); e->setArgument(3,(v4_Northings)); e->setArgument(4,(v5_OrthogonalHeight)); if (v6_XAxisAbscissa) { e->setArgument(5,(*v6_XAxisAbscissa)); } else { e->setArgument(5); } if (v7_XAxisOrdinate) { e->setArgument(6,(*v7_XAxisOrdinate)); } else { e->setArgument(6); } if (v8_Scale) { e->setArgument(7,(*v8_Scale)); } else { e->setArgument(7); } 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); } -bool IfcMaterial::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcMaterial::Description() const { return *entity->getArgument(1); } -void IfcMaterial::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterial::hasCategory() const { return !entity->getArgument(2)->isNull(); } -std::string IfcMaterial::Category() const { return *entity->getArgument(2); } -void IfcMaterial::setCategory(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcMaterialDefinitionRepresentation::list::ptr IfcMaterial::HasRepresentation() const { return entity->getInverse(Type::IfcMaterialDefinitionRepresentation, 3)->as(); } -IfcMaterialRelationship::list::ptr IfcMaterial::IsRelatedWith() const { return entity->getInverse(Type::IfcMaterialRelationship, 3)->as(); } -IfcMaterialRelationship::list::ptr IfcMaterial::RelatesTo() const { return entity->getInverse(Type::IfcMaterialRelationship, 2)->as(); } -bool IfcMaterial::is(Type::Enum v) const { return v == Type::IfcMaterial || IfcMaterialDefinition::is(v); } -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); } +bool IfcMaterial::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcMaterial::Description() const { return *data_->getArgument(1); } +void IfcMaterial::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcMaterial::hasCategory() const { return !data_->getArgument(2)->isNull(); } +std::string IfcMaterial::Category() const { return *data_->getArgument(2); } +void IfcMaterial::setCategory(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcMaterialDefinitionRepresentation::list::ptr IfcMaterial::HasRepresentation() const { return data_->getInverse(Type::IfcMaterialDefinitionRepresentation, 3)->as(); } +IfcMaterialRelationship::list::ptr IfcMaterial::IsRelatedWith() const { return data_->getInverse(Type::IfcMaterialRelationship, 3)->as(); } +IfcMaterialRelationship::list::ptr IfcMaterial::RelatesTo() const { return data_->getInverse(Type::IfcMaterialRelationship, 2)->as(); } + +const IfcParse::entity& IfcMaterial::declaration() const { return *IfcMaterial_type; } Type::Enum IfcMaterial::Class() { return Type::IfcMaterial; } -IfcMaterial::IfcMaterial(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_Category) : IfcMaterialDefinition((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_Category) { e->setArgument(2,(*v3_Category)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcMaterial::IfcMaterial(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_Category) : IfcMaterialDefinition((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_Category) { e->setArgument(2,(*v3_Category)); } else { e->setArgument(2); } 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 IfcMaterialConstituent -bool IfcMaterialConstituent::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcMaterialConstituent::Name() const { return *entity->getArgument(0); } -void IfcMaterialConstituent::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMaterialConstituent::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcMaterialConstituent::Description() const { return *entity->getArgument(1); } -void IfcMaterialConstituent::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcMaterial* IfcMaterialConstituent::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcMaterialConstituent::setMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcMaterialConstituent::hasFraction() const { return !entity->getArgument(3)->isNull(); } -double IfcMaterialConstituent::Fraction() const { return *entity->getArgument(3); } -void IfcMaterialConstituent::setFraction(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialConstituent::hasCategory() const { return !entity->getArgument(4)->isNull(); } -std::string IfcMaterialConstituent::Category() const { return *entity->getArgument(4); } -void IfcMaterialConstituent::setCategory(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcMaterialConstituentSet::list::ptr IfcMaterialConstituent::ToMaterialConstituentSet() const { return entity->getInverse(Type::IfcMaterialConstituentSet, 2)->as(); } -bool IfcMaterialConstituent::is(Type::Enum v) const { return v == Type::IfcMaterialConstituent || IfcMaterialDefinition::is(v); } -Type::Enum IfcMaterialConstituent::type() const { return Type::IfcMaterialConstituent; } +bool IfcMaterialConstituent::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcMaterialConstituent::Name() const { return *data_->getArgument(0); } +void IfcMaterialConstituent::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcMaterialConstituent::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcMaterialConstituent::Description() const { return *data_->getArgument(1); } +void IfcMaterialConstituent::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcMaterial* IfcMaterialConstituent::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcMaterialConstituent::setMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcMaterialConstituent::hasFraction() const { return !data_->getArgument(3)->isNull(); } +double IfcMaterialConstituent::Fraction() const { return *data_->getArgument(3); } +void IfcMaterialConstituent::setFraction(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcMaterialConstituent::hasCategory() const { return !data_->getArgument(4)->isNull(); } +std::string IfcMaterialConstituent::Category() const { return *data_->getArgument(4); } +void IfcMaterialConstituent::setCategory(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + +IfcMaterialConstituentSet::list::ptr IfcMaterialConstituent::ToMaterialConstituentSet() const { return data_->getInverse(Type::IfcMaterialConstituentSet, 2)->as(); } + +const IfcParse::entity& IfcMaterialConstituent::declaration() const { return *IfcMaterialConstituent_type; } Type::Enum IfcMaterialConstituent::Class() { return Type::IfcMaterialConstituent; } -IfcMaterialConstituent::IfcMaterialConstituent(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialConstituent)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialConstituent::IfcMaterialConstituent(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, boost::optional< double > v4_Fraction, boost::optional< std::string > v5_Category) : IfcMaterialDefinition((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_Material)); if (v4_Fraction) { e->setArgument(3,(*v4_Fraction)); } else { e->setArgument(3); } if (v5_Category) { e->setArgument(4,(*v5_Category)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcMaterialConstituent::IfcMaterialConstituent(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialConstituent)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialConstituent::IfcMaterialConstituent(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, boost::optional< double > v4_Fraction, boost::optional< std::string > v5_Category) : IfcMaterialDefinition((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_Material)); if (v4_Fraction) { e->setArgument(3,(*v4_Fraction)); } else { e->setArgument(3); } if (v5_Category) { e->setArgument(4,(*v5_Category)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialConstituentSet -bool IfcMaterialConstituentSet::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcMaterialConstituentSet::Name() const { return *entity->getArgument(0); } -void IfcMaterialConstituentSet::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMaterialConstituentSet::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcMaterialConstituentSet::Description() const { return *entity->getArgument(1); } -void IfcMaterialConstituentSet::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterialConstituentSet::hasMaterialConstituents() const { return !entity->getArgument(2)->isNull(); } -IfcTemplatedEntityList< IfcMaterialConstituent >::ptr IfcMaterialConstituentSet::MaterialConstituents() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcMaterialConstituentSet::setMaterialConstituents(IfcTemplatedEntityList< IfcMaterialConstituent >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcMaterialConstituentSet::is(Type::Enum v) const { return v == Type::IfcMaterialConstituentSet || IfcMaterialDefinition::is(v); } -Type::Enum IfcMaterialConstituentSet::type() const { return Type::IfcMaterialConstituentSet; } +bool IfcMaterialConstituentSet::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcMaterialConstituentSet::Name() const { return *data_->getArgument(0); } +void IfcMaterialConstituentSet::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcMaterialConstituentSet::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcMaterialConstituentSet::Description() const { return *data_->getArgument(1); } +void IfcMaterialConstituentSet::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcMaterialConstituentSet::hasMaterialConstituents() const { return !data_->getArgument(2)->isNull(); } +IfcTemplatedEntityList< IfcMaterialConstituent >::ptr IfcMaterialConstituentSet::MaterialConstituents() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcMaterialConstituentSet::setMaterialConstituents(IfcTemplatedEntityList< IfcMaterialConstituent >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } + + +const IfcParse::entity& IfcMaterialConstituentSet::declaration() const { return *IfcMaterialConstituentSet_type; } Type::Enum IfcMaterialConstituentSet::Class() { return Type::IfcMaterialConstituentSet; } -IfcMaterialConstituentSet::IfcMaterialConstituentSet(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialConstituentSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialConstituentSet::IfcMaterialConstituentSet(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, boost::optional< IfcTemplatedEntityList< IfcMaterialConstituent >::ptr > v3_MaterialConstituents) : IfcMaterialDefinition((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); } if (v3_MaterialConstituents) { e->setArgument(2,(*v3_MaterialConstituents)->generalize()); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcMaterialConstituentSet::IfcMaterialConstituentSet(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialConstituentSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialConstituentSet::IfcMaterialConstituentSet(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, boost::optional< IfcTemplatedEntityList< IfcMaterialConstituent >::ptr > v3_MaterialConstituents) : IfcMaterialDefinition((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); } if (v3_MaterialConstituents) { e->setArgument(2,(*v3_MaterialConstituents)->generalize()); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialDefinition -IfcRelAssociatesMaterial::list::ptr IfcMaterialDefinition::AssociatedTo() const { return entity->getInverse(Type::IfcRelAssociatesMaterial, 5)->as(); } -IfcExternalReferenceRelationship::list::ptr IfcMaterialDefinition::HasExternalReferences() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -IfcMaterialProperties::list::ptr IfcMaterialDefinition::HasProperties() const { return entity->getInverse(Type::IfcMaterialProperties, 3)->as(); } -bool IfcMaterialDefinition::is(Type::Enum v) const { return v == Type::IfcMaterialDefinition; } -Type::Enum IfcMaterialDefinition::type() const { return Type::IfcMaterialDefinition; } + +IfcRelAssociatesMaterial::list::ptr IfcMaterialDefinition::AssociatedTo() const { return data_->getInverse(Type::IfcRelAssociatesMaterial, 5)->as(); } +IfcExternalReferenceRelationship::list::ptr IfcMaterialDefinition::HasExternalReferences() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } +IfcMaterialProperties::list::ptr IfcMaterialDefinition::HasProperties() const { return data_->getInverse(Type::IfcMaterialProperties, 3)->as(); } + +const IfcParse::entity& IfcMaterialDefinition::declaration() const { return *IfcMaterialDefinition_type; } Type::Enum IfcMaterialDefinition::Class() { return Type::IfcMaterialDefinition; } -IfcMaterialDefinition::IfcMaterialDefinition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialDefinition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialDefinition::IfcMaterialDefinition() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcMaterialDefinition::IfcMaterialDefinition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialDefinition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialDefinition::IfcMaterialDefinition() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); 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); } -bool IfcMaterialLayer::hasName() const { return !entity->getArgument(3)->isNull(); } -std::string IfcMaterialLayer::Name() const { return *entity->getArgument(3); } -void IfcMaterialLayer::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialLayer::hasDescription() const { return !entity->getArgument(4)->isNull(); } -std::string IfcMaterialLayer::Description() const { return *entity->getArgument(4); } -void IfcMaterialLayer::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMaterialLayer::hasCategory() const { return !entity->getArgument(5)->isNull(); } -std::string IfcMaterialLayer::Category() const { return *entity->getArgument(5); } -void IfcMaterialLayer::setCategory(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcMaterialLayer::hasPriority() const { return !entity->getArgument(6)->isNull(); } -double IfcMaterialLayer::Priority() const { return *entity->getArgument(6); } -void IfcMaterialLayer::setPriority(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,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 || IfcMaterialDefinition::is(v); } -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); } +bool IfcMaterialLayer::hasName() const { return !data_->getArgument(3)->isNull(); } +std::string IfcMaterialLayer::Name() const { return *data_->getArgument(3); } +void IfcMaterialLayer::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcMaterialLayer::hasDescription() const { return !data_->getArgument(4)->isNull(); } +std::string IfcMaterialLayer::Description() const { return *data_->getArgument(4); } +void IfcMaterialLayer::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcMaterialLayer::hasCategory() const { return !data_->getArgument(5)->isNull(); } +std::string IfcMaterialLayer::Category() const { return *data_->getArgument(5); } +void IfcMaterialLayer::setCategory(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcMaterialLayer::hasPriority() const { return !data_->getArgument(6)->isNull(); } +double IfcMaterialLayer::Priority() const { return *data_->getArgument(6); } +void IfcMaterialLayer::setPriority(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,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) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Category, boost::optional< double > v7_Priority) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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); } if (v4_Name) { e->setArgument(3,(*v4_Name)); } else { e->setArgument(3); } if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } if (v7_Priority) { e->setArgument(6,(*v7_Priority)); } else { e->setArgument(6); } entity = e; EntityBuffer::Add(this); } +IfcMaterialLayer::IfcMaterialLayer(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Category, boost::optional< double > v7_Priority) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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); } if (v4_Name) { e->setArgument(3,(*v4_Name)); } else { e->setArgument(3); } if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } if (v7_Priority) { e->setArgument(6,(*v7_Priority)); } else { e->setArgument(6); } 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::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcMaterialLayerSet::Description() const { return *entity->getArgument(2); } -void IfcMaterialLayerSet::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcMaterialLayerSet::is(Type::Enum v) const { return v == Type::IfcMaterialLayerSet || IfcMaterialDefinition::is(v); } -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); } +bool IfcMaterialLayerSet::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcMaterialLayerSet::Description() const { return *data_->getArgument(2); } +void IfcMaterialLayerSet::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcMaterialLayerSet::declaration() const { return *IfcMaterialLayerSet_type; } Type::Enum IfcMaterialLayerSet::Class() { return Type::IfcMaterialLayerSet; } -IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v3_Description) : IfcMaterialDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MaterialLayers)->generalize()); if (v2_LayerSetName) { e->setArgument(1,(*v2_LayerSetName)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v3_Description) : IfcMaterialDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_MaterialLayers)->generalize()); if (v2_LayerSetName) { e->setArgument(1,(*v2_LayerSetName)); } else { e->setArgument(1); } if (v3_Description) { e->setArgument(2,(*v3_Description)); } else { e->setArgument(2); } 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::hasReferenceExtent() const { return !entity->getArgument(4)->isNull(); } -double IfcMaterialLayerSetUsage::ReferenceExtent() const { return *entity->getArgument(4); } -void IfcMaterialLayerSetUsage::setReferenceExtent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMaterialLayerSetUsage::is(Type::Enum v) const { return v == Type::IfcMaterialLayerSetUsage || IfcMaterialUsageDefinition::is(v); } -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); } +bool IfcMaterialLayerSetUsage::hasReferenceExtent() const { return !data_->getArgument(4)->isNull(); } +double IfcMaterialLayerSetUsage::ReferenceExtent() const { return *data_->getArgument(4); } +void IfcMaterialLayerSetUsage::setReferenceExtent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcMaterialLayerSetUsage::declaration() const { return *IfcMaterialLayerSetUsage_type; } Type::Enum IfcMaterialLayerSetUsage::Class() { return Type::IfcMaterialLayerSetUsage; } -IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntity* e) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { 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, boost::optional< double > v5_ReferenceExtent) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { 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)); if (v5_ReferenceExtent) { e->setArgument(4,(*v5_ReferenceExtent)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntity* e) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { 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, boost::optional< double > v5_ReferenceExtent) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { 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)); if (v5_ReferenceExtent) { e->setArgument(4,(*v5_ReferenceExtent)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialLayerWithOffsets -IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcMaterialLayerWithOffsets::OffsetDirection() const { return IfcLayerSetDirectionEnum::FromString(*entity->getArgument(7)); } -void IfcMaterialLayerWithOffsets::setOffsetDirection(IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcLayerSetDirectionEnum::ToString(v)); } -std::vector< double > /*[1:2]*/ IfcMaterialLayerWithOffsets::OffsetValues() const { return *entity->getArgument(8); } -void IfcMaterialLayerWithOffsets::setOffsetValues(std::vector< double > /*[1:2]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcMaterialLayerWithOffsets::is(Type::Enum v) const { return v == Type::IfcMaterialLayerWithOffsets || IfcMaterialLayer::is(v); } -Type::Enum IfcMaterialLayerWithOffsets::type() const { return Type::IfcMaterialLayerWithOffsets; } +IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcMaterialLayerWithOffsets::OffsetDirection() const { return IfcLayerSetDirectionEnum::FromString(*data_->getArgument(7)); } +void IfcMaterialLayerWithOffsets::setOffsetDirection(IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcLayerSetDirectionEnum::ToString(v)); } +std::vector< double > /*[1:2]*/ IfcMaterialLayerWithOffsets::OffsetValues() const { return *data_->getArgument(8); } +void IfcMaterialLayerWithOffsets::setOffsetValues(std::vector< double > /*[1:2]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcMaterialLayerWithOffsets::declaration() const { return *IfcMaterialLayerWithOffsets_type; } Type::Enum IfcMaterialLayerWithOffsets::Class() { return Type::IfcMaterialLayerWithOffsets; } -IfcMaterialLayerWithOffsets::IfcMaterialLayerWithOffsets(IfcAbstractEntity* e) : IfcMaterialLayer((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialLayerWithOffsets)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialLayerWithOffsets::IfcMaterialLayerWithOffsets(IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< bool > v3_IsVentilated, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Category, boost::optional< double > v7_Priority, IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v8_OffsetDirection, std::vector< double > /*[1:2]*/ v9_OffsetValues) : IfcMaterialLayer((IfcAbstractEntity*)0) { 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); } if (v4_Name) { e->setArgument(3,(*v4_Name)); } else { e->setArgument(3); } if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } if (v7_Priority) { e->setArgument(6,(*v7_Priority)); } else { e->setArgument(6); } e->setArgument(7,v8_OffsetDirection,IfcLayerSetDirectionEnum::ToString(v8_OffsetDirection)); e->setArgument(8,(v9_OffsetValues)); entity = e; EntityBuffer::Add(this); } +IfcMaterialLayerWithOffsets::IfcMaterialLayerWithOffsets(IfcAbstractEntity* e) : IfcMaterialLayer((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialLayerWithOffsets)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialLayerWithOffsets::IfcMaterialLayerWithOffsets(IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< bool > v3_IsVentilated, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Category, boost::optional< double > v7_Priority, IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v8_OffsetDirection, std::vector< double > /*[1:2]*/ v9_OffsetValues) : IfcMaterialLayer((IfcAbstractEntity*)0) { 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); } if (v4_Name) { e->setArgument(3,(*v4_Name)); } else { e->setArgument(3); } if (v5_Description) { e->setArgument(4,(*v5_Description)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } if (v7_Priority) { e->setArgument(6,(*v7_Priority)); } else { e->setArgument(6); } e->setArgument(7,v8_OffsetDirection,IfcLayerSetDirectionEnum::ToString(v8_OffsetDirection)); e->setArgument(8,(v9_OffsetValues)); 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 IfcMaterialProfile -bool IfcMaterialProfile::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcMaterialProfile::Name() const { return *entity->getArgument(0); } -void IfcMaterialProfile::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMaterialProfile::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcMaterialProfile::Description() const { return *entity->getArgument(1); } -void IfcMaterialProfile::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterialProfile::hasMaterial() const { return !entity->getArgument(2)->isNull(); } -IfcMaterial* IfcMaterialProfile::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcMaterialProfile::setMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcProfileDef* IfcMaterialProfile::Profile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcMaterialProfile::setProfile(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialProfile::hasPriority() const { return !entity->getArgument(4)->isNull(); } -double IfcMaterialProfile::Priority() const { return *entity->getArgument(4); } -void IfcMaterialProfile::setPriority(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMaterialProfile::hasCategory() const { return !entity->getArgument(5)->isNull(); } -std::string IfcMaterialProfile::Category() const { return *entity->getArgument(5); } -void IfcMaterialProfile::setCategory(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcMaterialProfileSet::list::ptr IfcMaterialProfile::ToMaterialProfileSet() const { return entity->getInverse(Type::IfcMaterialProfileSet, 2)->as(); } -bool IfcMaterialProfile::is(Type::Enum v) const { return v == Type::IfcMaterialProfile || IfcMaterialDefinition::is(v); } -Type::Enum IfcMaterialProfile::type() const { return Type::IfcMaterialProfile; } +bool IfcMaterialProfile::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcMaterialProfile::Name() const { return *data_->getArgument(0); } +void IfcMaterialProfile::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcMaterialProfile::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcMaterialProfile::Description() const { return *data_->getArgument(1); } +void IfcMaterialProfile::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcMaterialProfile::hasMaterial() const { return !data_->getArgument(2)->isNull(); } +IfcMaterial* IfcMaterialProfile::Material() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcMaterialProfile::setMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcProfileDef* IfcMaterialProfile::Profile() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcMaterialProfile::setProfile(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcMaterialProfile::hasPriority() const { return !data_->getArgument(4)->isNull(); } +double IfcMaterialProfile::Priority() const { return *data_->getArgument(4); } +void IfcMaterialProfile::setPriority(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcMaterialProfile::hasCategory() const { return !data_->getArgument(5)->isNull(); } +std::string IfcMaterialProfile::Category() const { return *data_->getArgument(5); } +void IfcMaterialProfile::setCategory(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + +IfcMaterialProfileSet::list::ptr IfcMaterialProfile::ToMaterialProfileSet() const { return data_->getInverse(Type::IfcMaterialProfileSet, 2)->as(); } + +const IfcParse::entity& IfcMaterialProfile::declaration() const { return *IfcMaterialProfile_type; } Type::Enum IfcMaterialProfile::Class() { return Type::IfcMaterialProfile; } -IfcMaterialProfile::IfcMaterialProfile(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfile)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProfile::IfcMaterialProfile(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, IfcProfileDef* v4_Profile, boost::optional< double > v5_Priority, boost::optional< std::string > v6_Category) : IfcMaterialDefinition((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_Material)); e->setArgument(3,(v4_Profile)); if (v5_Priority) { e->setArgument(4,(*v5_Priority)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcMaterialProfile::IfcMaterialProfile(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfile)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProfile::IfcMaterialProfile(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, IfcProfileDef* v4_Profile, boost::optional< double > v5_Priority, boost::optional< std::string > v6_Category) : IfcMaterialDefinition((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_Material)); e->setArgument(3,(v4_Profile)); if (v5_Priority) { e->setArgument(4,(*v5_Priority)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialProfileSet -bool IfcMaterialProfileSet::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcMaterialProfileSet::Name() const { return *entity->getArgument(0); } -void IfcMaterialProfileSet::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMaterialProfileSet::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcMaterialProfileSet::Description() const { return *entity->getArgument(1); } -void IfcMaterialProfileSet::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -IfcTemplatedEntityList< IfcMaterialProfile >::ptr IfcMaterialProfileSet::MaterialProfiles() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcMaterialProfileSet::setMaterialProfiles(IfcTemplatedEntityList< IfcMaterialProfile >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcMaterialProfileSet::hasCompositeProfile() const { return !entity->getArgument(3)->isNull(); } -IfcCompositeProfileDef* IfcMaterialProfileSet::CompositeProfile() const { return (IfcCompositeProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcMaterialProfileSet::setCompositeProfile(IfcCompositeProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialProfileSet::is(Type::Enum v) const { return v == Type::IfcMaterialProfileSet || IfcMaterialDefinition::is(v); } -Type::Enum IfcMaterialProfileSet::type() const { return Type::IfcMaterialProfileSet; } +bool IfcMaterialProfileSet::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcMaterialProfileSet::Name() const { return *data_->getArgument(0); } +void IfcMaterialProfileSet::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcMaterialProfileSet::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcMaterialProfileSet::Description() const { return *data_->getArgument(1); } +void IfcMaterialProfileSet::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +IfcTemplatedEntityList< IfcMaterialProfile >::ptr IfcMaterialProfileSet::MaterialProfiles() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcMaterialProfileSet::setMaterialProfiles(IfcTemplatedEntityList< IfcMaterialProfile >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v->generalize()); } +bool IfcMaterialProfileSet::hasCompositeProfile() const { return !data_->getArgument(3)->isNull(); } +IfcCompositeProfileDef* IfcMaterialProfileSet::CompositeProfile() const { return (IfcCompositeProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcMaterialProfileSet::setCompositeProfile(IfcCompositeProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcMaterialProfileSet::declaration() const { return *IfcMaterialProfileSet_type; } Type::Enum IfcMaterialProfileSet::Class() { return Type::IfcMaterialProfileSet; } -IfcMaterialProfileSet::IfcMaterialProfileSet(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProfileSet::IfcMaterialProfileSet(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcMaterialProfile >::ptr v3_MaterialProfiles, IfcCompositeProfileDef* v4_CompositeProfile) : IfcMaterialDefinition((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_MaterialProfiles)->generalize()); e->setArgument(3,(v4_CompositeProfile)); entity = e; EntityBuffer::Add(this); } +IfcMaterialProfileSet::IfcMaterialProfileSet(IfcAbstractEntity* e) : IfcMaterialDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProfileSet::IfcMaterialProfileSet(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcMaterialProfile >::ptr v3_MaterialProfiles, IfcCompositeProfileDef* v4_CompositeProfile) : IfcMaterialDefinition((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_MaterialProfiles)->generalize()); e->setArgument(3,(v4_CompositeProfile)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialProfileSetUsage -IfcMaterialProfileSet* IfcMaterialProfileSetUsage::ForProfileSet() const { return (IfcMaterialProfileSet*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcMaterialProfileSetUsage::setForProfileSet(IfcMaterialProfileSet* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMaterialProfileSetUsage::hasCardinalPoint() const { return !entity->getArgument(1)->isNull(); } -int IfcMaterialProfileSetUsage::CardinalPoint() const { return *entity->getArgument(1); } -void IfcMaterialProfileSetUsage::setCardinalPoint(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcMaterialProfileSetUsage::hasReferenceExtent() const { return !entity->getArgument(2)->isNull(); } -double IfcMaterialProfileSetUsage::ReferenceExtent() const { return *entity->getArgument(2); } -void IfcMaterialProfileSetUsage::setReferenceExtent(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcMaterialProfileSetUsage::is(Type::Enum v) const { return v == Type::IfcMaterialProfileSetUsage || IfcMaterialUsageDefinition::is(v); } -Type::Enum IfcMaterialProfileSetUsage::type() const { return Type::IfcMaterialProfileSetUsage; } +IfcMaterialProfileSet* IfcMaterialProfileSetUsage::ForProfileSet() const { return (IfcMaterialProfileSet*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcMaterialProfileSetUsage::setForProfileSet(IfcMaterialProfileSet* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcMaterialProfileSetUsage::hasCardinalPoint() const { return !data_->getArgument(1)->isNull(); } +int IfcMaterialProfileSetUsage::CardinalPoint() const { return *data_->getArgument(1); } +void IfcMaterialProfileSetUsage::setCardinalPoint(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcMaterialProfileSetUsage::hasReferenceExtent() const { return !data_->getArgument(2)->isNull(); } +double IfcMaterialProfileSetUsage::ReferenceExtent() const { return *data_->getArgument(2); } +void IfcMaterialProfileSetUsage::setReferenceExtent(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcMaterialProfileSetUsage::declaration() const { return *IfcMaterialProfileSetUsage_type; } Type::Enum IfcMaterialProfileSetUsage::Class() { return Type::IfcMaterialProfileSetUsage; } -IfcMaterialProfileSetUsage::IfcMaterialProfileSetUsage(IfcAbstractEntity* e) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileSetUsage)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProfileSetUsage::IfcMaterialProfileSetUsage(IfcMaterialProfileSet* v1_ForProfileSet, boost::optional< int > v2_CardinalPoint, boost::optional< double > v3_ReferenceExtent) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ForProfileSet)); if (v2_CardinalPoint) { e->setArgument(1,(*v2_CardinalPoint)); } else { e->setArgument(1); } if (v3_ReferenceExtent) { e->setArgument(2,(*v3_ReferenceExtent)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcMaterialProfileSetUsage::IfcMaterialProfileSetUsage(IfcAbstractEntity* e) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileSetUsage)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProfileSetUsage::IfcMaterialProfileSetUsage(IfcMaterialProfileSet* v1_ForProfileSet, boost::optional< int > v2_CardinalPoint, boost::optional< double > v3_ReferenceExtent) : IfcMaterialUsageDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ForProfileSet)); if (v2_CardinalPoint) { e->setArgument(1,(*v2_CardinalPoint)); } else { e->setArgument(1); } if (v3_ReferenceExtent) { e->setArgument(2,(*v3_ReferenceExtent)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialProfileSetUsageTapering -IfcMaterialProfileSet* IfcMaterialProfileSetUsageTapering::ForProfileEndSet() const { return (IfcMaterialProfileSet*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcMaterialProfileSetUsageTapering::setForProfileEndSet(IfcMaterialProfileSet* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialProfileSetUsageTapering::hasCardinalEndPoint() const { return !entity->getArgument(4)->isNull(); } -int IfcMaterialProfileSetUsageTapering::CardinalEndPoint() const { return *entity->getArgument(4); } -void IfcMaterialProfileSetUsageTapering::setCardinalEndPoint(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMaterialProfileSetUsageTapering::is(Type::Enum v) const { return v == Type::IfcMaterialProfileSetUsageTapering || IfcMaterialProfileSetUsage::is(v); } -Type::Enum IfcMaterialProfileSetUsageTapering::type() const { return Type::IfcMaterialProfileSetUsageTapering; } +IfcMaterialProfileSet* IfcMaterialProfileSetUsageTapering::ForProfileEndSet() const { return (IfcMaterialProfileSet*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcMaterialProfileSetUsageTapering::setForProfileEndSet(IfcMaterialProfileSet* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcMaterialProfileSetUsageTapering::hasCardinalEndPoint() const { return !data_->getArgument(4)->isNull(); } +int IfcMaterialProfileSetUsageTapering::CardinalEndPoint() const { return *data_->getArgument(4); } +void IfcMaterialProfileSetUsageTapering::setCardinalEndPoint(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcMaterialProfileSetUsageTapering::declaration() const { return *IfcMaterialProfileSetUsageTapering_type; } Type::Enum IfcMaterialProfileSetUsageTapering::Class() { return Type::IfcMaterialProfileSetUsageTapering; } -IfcMaterialProfileSetUsageTapering::IfcMaterialProfileSetUsageTapering(IfcAbstractEntity* e) : IfcMaterialProfileSetUsage((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileSetUsageTapering)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProfileSetUsageTapering::IfcMaterialProfileSetUsageTapering(IfcMaterialProfileSet* v1_ForProfileSet, boost::optional< int > v2_CardinalPoint, boost::optional< double > v3_ReferenceExtent, IfcMaterialProfileSet* v4_ForProfileEndSet, boost::optional< int > v5_CardinalEndPoint) : IfcMaterialProfileSetUsage((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ForProfileSet)); if (v2_CardinalPoint) { e->setArgument(1,(*v2_CardinalPoint)); } else { e->setArgument(1); } if (v3_ReferenceExtent) { e->setArgument(2,(*v3_ReferenceExtent)); } else { e->setArgument(2); } e->setArgument(3,(v4_ForProfileEndSet)); if (v5_CardinalEndPoint) { e->setArgument(4,(*v5_CardinalEndPoint)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcMaterialProfileSetUsageTapering::IfcMaterialProfileSetUsageTapering(IfcAbstractEntity* e) : IfcMaterialProfileSetUsage((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileSetUsageTapering)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProfileSetUsageTapering::IfcMaterialProfileSetUsageTapering(IfcMaterialProfileSet* v1_ForProfileSet, boost::optional< int > v2_CardinalPoint, boost::optional< double > v3_ReferenceExtent, IfcMaterialProfileSet* v4_ForProfileEndSet, boost::optional< int > v5_CardinalEndPoint) : IfcMaterialProfileSetUsage((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ForProfileSet)); if (v2_CardinalPoint) { e->setArgument(1,(*v2_CardinalPoint)); } else { e->setArgument(1); } if (v3_ReferenceExtent) { e->setArgument(2,(*v3_ReferenceExtent)); } else { e->setArgument(2); } e->setArgument(3,(v4_ForProfileEndSet)); if (v5_CardinalEndPoint) { e->setArgument(4,(*v5_CardinalEndPoint)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialProfileWithOffsets -std::vector< double > /*[1:2]*/ IfcMaterialProfileWithOffsets::OffsetValues() const { return *entity->getArgument(6); } -void IfcMaterialProfileWithOffsets::setOffsetValues(std::vector< double > /*[1:2]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcMaterialProfileWithOffsets::is(Type::Enum v) const { return v == Type::IfcMaterialProfileWithOffsets || IfcMaterialProfile::is(v); } -Type::Enum IfcMaterialProfileWithOffsets::type() const { return Type::IfcMaterialProfileWithOffsets; } +std::vector< double > /*[1:2]*/ IfcMaterialProfileWithOffsets::OffsetValues() const { return *data_->getArgument(6); } +void IfcMaterialProfileWithOffsets::setOffsetValues(std::vector< double > /*[1:2]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcMaterialProfileWithOffsets::declaration() const { return *IfcMaterialProfileWithOffsets_type; } Type::Enum IfcMaterialProfileWithOffsets::Class() { return Type::IfcMaterialProfileWithOffsets; } -IfcMaterialProfileWithOffsets::IfcMaterialProfileWithOffsets(IfcAbstractEntity* e) : IfcMaterialProfile((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileWithOffsets)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProfileWithOffsets::IfcMaterialProfileWithOffsets(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, IfcProfileDef* v4_Profile, boost::optional< double > v5_Priority, boost::optional< std::string > v6_Category, std::vector< double > /*[1:2]*/ v7_OffsetValues) : IfcMaterialProfile((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_Material)); e->setArgument(3,(v4_Profile)); if (v5_Priority) { e->setArgument(4,(*v5_Priority)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } e->setArgument(6,(v7_OffsetValues)); entity = e; EntityBuffer::Add(this); } +IfcMaterialProfileWithOffsets::IfcMaterialProfileWithOffsets(IfcAbstractEntity* e) : IfcMaterialProfile((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProfileWithOffsets)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProfileWithOffsets::IfcMaterialProfileWithOffsets(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, IfcProfileDef* v4_Profile, boost::optional< double > v5_Priority, boost::optional< std::string > v6_Category, std::vector< double > /*[1:2]*/ v7_OffsetValues) : IfcMaterialProfile((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_Material)); e->setArgument(3,(v4_Profile)); if (v5_Priority) { e->setArgument(4,(*v5_Priority)); } else { e->setArgument(4); } if (v6_Category) { e->setArgument(5,(*v6_Category)); } else { e->setArgument(5); } e->setArgument(6,(v7_OffsetValues)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialProperties -IfcMaterialDefinition* IfcMaterialProperties::Material() const { return (IfcMaterialDefinition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcMaterialProperties::setMaterial(IfcMaterialDefinition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcMaterialProperties::is(Type::Enum v) const { return v == Type::IfcMaterialProperties || IfcExtendedProperties::is(v); } -Type::Enum IfcMaterialProperties::type() const { return Type::IfcMaterialProperties; } +IfcMaterialDefinition* IfcMaterialProperties::Material() const { return (IfcMaterialDefinition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcMaterialProperties::setMaterial(IfcMaterialDefinition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcMaterialProperties::declaration() const { return *IfcMaterialProperties_type; } Type::Enum IfcMaterialProperties::Class() { return Type::IfcMaterialProperties; } -IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntity* e) : IfcExtendedProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialProperties::IfcMaterialProperties(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties, IfcMaterialDefinition* v4_Material) : IfcExtendedProperties((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_Properties)->generalize()); e->setArgument(3,(v4_Material)); entity = e; EntityBuffer::Add(this); } +IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntity* e) : IfcExtendedProperties((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialProperties::IfcMaterialProperties(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties, IfcMaterialDefinition* v4_Material) : IfcExtendedProperties((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_Properties)->generalize()); e->setArgument(3,(v4_Material)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialRelationship -IfcMaterial* IfcMaterialRelationship::RelatingMaterial() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcMaterialRelationship::setRelatingMaterial(IfcMaterial* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcTemplatedEntityList< IfcMaterial >::ptr IfcMaterialRelationship::RelatedMaterials() const { IfcEntityList::ptr es = *entity->getArgument(3); return es->as(); } -void IfcMaterialRelationship::setRelatedMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v->generalize()); } -bool IfcMaterialRelationship::hasExpression() const { return !entity->getArgument(4)->isNull(); } -std::string IfcMaterialRelationship::Expression() const { return *entity->getArgument(4); } -void IfcMaterialRelationship::setExpression(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcMaterialRelationship::is(Type::Enum v) const { return v == Type::IfcMaterialRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcMaterialRelationship::type() const { return Type::IfcMaterialRelationship; } +IfcMaterial* IfcMaterialRelationship::RelatingMaterial() const { return (IfcMaterial*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcMaterialRelationship::setRelatingMaterial(IfcMaterial* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcTemplatedEntityList< IfcMaterial >::ptr IfcMaterialRelationship::RelatedMaterials() const { IfcEntityList::ptr es = *data_->getArgument(3); return es->as(); } +void IfcMaterialRelationship::setRelatedMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v->generalize()); } +bool IfcMaterialRelationship::hasExpression() const { return !data_->getArgument(4)->isNull(); } +std::string IfcMaterialRelationship::Expression() const { return *data_->getArgument(4); } +void IfcMaterialRelationship::setExpression(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcMaterialRelationship::declaration() const { return *IfcMaterialRelationship_type; } Type::Enum IfcMaterialRelationship::Class() { return Type::IfcMaterialRelationship; } -IfcMaterialRelationship::IfcMaterialRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialRelationship::IfcMaterialRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_RelatingMaterial, IfcTemplatedEntityList< IfcMaterial >::ptr v4_RelatedMaterials, boost::optional< std::string > v5_Expression) : IfcResourceLevelRelationship((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_RelatingMaterial)); e->setArgument(3,(v4_RelatedMaterials)->generalize()); if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcMaterialRelationship::IfcMaterialRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMaterialRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialRelationship::IfcMaterialRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_RelatingMaterial, IfcTemplatedEntityList< IfcMaterial >::ptr v4_RelatedMaterials, boost::optional< std::string > v5_Expression) : IfcResourceLevelRelationship((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_RelatingMaterial)); e->setArgument(3,(v4_RelatedMaterials)->generalize()); if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMaterialUsageDefinition -IfcRelAssociatesMaterial::list::ptr IfcMaterialUsageDefinition::AssociatedTo() const { return entity->getInverse(Type::IfcRelAssociatesMaterial, 5)->as(); } -bool IfcMaterialUsageDefinition::is(Type::Enum v) const { return v == Type::IfcMaterialUsageDefinition; } -Type::Enum IfcMaterialUsageDefinition::type() const { return Type::IfcMaterialUsageDefinition; } + +IfcRelAssociatesMaterial::list::ptr IfcMaterialUsageDefinition::AssociatedTo() const { return data_->getInverse(Type::IfcRelAssociatesMaterial, 5)->as(); } + +const IfcParse::entity& IfcMaterialUsageDefinition::declaration() const { return *IfcMaterialUsageDefinition_type; } Type::Enum IfcMaterialUsageDefinition::Class() { return Type::IfcMaterialUsageDefinition; } -IfcMaterialUsageDefinition::IfcMaterialUsageDefinition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialUsageDefinition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMaterialUsageDefinition::IfcMaterialUsageDefinition() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcMaterialUsageDefinition::IfcMaterialUsageDefinition(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcMaterialUsageDefinition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMaterialUsageDefinition::IfcMaterialUsageDefinition() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); 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 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::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum IfcMechanicalFastener::PredefinedType() const { return IfcMechanicalFastenerTypeEnum::FromString(*entity->getArgument(10)); } -void IfcMechanicalFastener::setPredefinedType(IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcMechanicalFastenerTypeEnum::ToString(v)); } -bool IfcMechanicalFastener::is(Type::Enum v) const { return v == Type::IfcMechanicalFastener || IfcElementComponent::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); } +bool IfcMechanicalFastener::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum IfcMechanicalFastener::PredefinedType() const { return IfcMechanicalFastenerTypeEnum::FromString(*data_->getArgument(10)); } +void IfcMechanicalFastener::setPredefinedType(IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcMechanicalFastenerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcMechanicalFastener::declaration() const { return *IfcMechanicalFastener_type; } Type::Enum IfcMechanicalFastener::Class() { return Type::IfcMechanicalFastener; } -IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntity* e) : IfcElementComponent((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, boost::optional< IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum > v11_PredefinedType) : 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); } if (v9_NominalDiameter) { e->setArgument(8,(*v9_NominalDiameter)); } else { e->setArgument(8); } if (v10_NominalLength) { e->setArgument(9,(*v10_NominalLength)); } else { e->setArgument(9); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcMechanicalFastenerTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntity* e) : IfcElementComponent((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, boost::optional< IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum > v11_PredefinedType) : 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); } if (v9_NominalDiameter) { e->setArgument(8,(*v9_NominalDiameter)); } else { e->setArgument(8); } if (v10_NominalLength) { e->setArgument(9,(*v10_NominalLength)); } else { e->setArgument(9); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcMechanicalFastenerTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMechanicalFastenerType -IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum IfcMechanicalFastenerType::PredefinedType() const { return IfcMechanicalFastenerTypeEnum::FromString(*entity->getArgument(9)); } -void IfcMechanicalFastenerType::setPredefinedType(IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcMechanicalFastenerTypeEnum::ToString(v)); } -bool IfcMechanicalFastenerType::hasNominalDiameter() const { return !entity->getArgument(10)->isNull(); } -double IfcMechanicalFastenerType::NominalDiameter() const { return *entity->getArgument(10); } -void IfcMechanicalFastenerType::setNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcMechanicalFastenerType::hasNominalLength() const { return !entity->getArgument(11)->isNull(); } -double IfcMechanicalFastenerType::NominalLength() const { return *entity->getArgument(11); } -void IfcMechanicalFastenerType::setNominalLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcMechanicalFastenerType::is(Type::Enum v) const { return v == Type::IfcMechanicalFastenerType || IfcElementComponentType::is(v); } -Type::Enum IfcMechanicalFastenerType::type() const { return Type::IfcMechanicalFastenerType; } +IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum IfcMechanicalFastenerType::PredefinedType() const { return IfcMechanicalFastenerTypeEnum::FromString(*data_->getArgument(9)); } +void IfcMechanicalFastenerType::setPredefinedType(IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcMechanicalFastenerTypeEnum::ToString(v)); } +bool IfcMechanicalFastenerType::hasNominalDiameter() const { return !data_->getArgument(10)->isNull(); } +double IfcMechanicalFastenerType::NominalDiameter() const { return *data_->getArgument(10); } +void IfcMechanicalFastenerType::setNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcMechanicalFastenerType::hasNominalLength() const { return !data_->getArgument(11)->isNull(); } +double IfcMechanicalFastenerType::NominalLength() const { return *data_->getArgument(11); } +void IfcMechanicalFastenerType::setNominalLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } + + +const IfcParse::entity& IfcMechanicalFastenerType::declaration() const { return *IfcMechanicalFastenerType_type; } Type::Enum IfcMechanicalFastenerType::Class() { return Type::IfcMechanicalFastenerType; } -IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntity* e) : IfcElementComponentType((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, IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_NominalLength) : 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); } e->setArgument(9,v10_PredefinedType,IfcMechanicalFastenerTypeEnum::ToString(v10_PredefinedType)); if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_NominalLength) { e->setArgument(11,(*v12_NominalLength)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntity* e) : IfcElementComponentType((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, IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_NominalLength) : 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); } e->setArgument(9,v10_PredefinedType,IfcMechanicalFastenerTypeEnum::ToString(v10_PredefinedType)); if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_NominalLength) { e->setArgument(11,(*v12_NominalLength)); } else { e->setArgument(11); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMedicalDevice -bool IfcMedicalDevice::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum IfcMedicalDevice::PredefinedType() const { return IfcMedicalDeviceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcMedicalDevice::setPredefinedType(IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcMedicalDeviceTypeEnum::ToString(v)); } -bool IfcMedicalDevice::is(Type::Enum v) const { return v == Type::IfcMedicalDevice || IfcFlowTerminal::is(v); } -Type::Enum IfcMedicalDevice::type() const { return Type::IfcMedicalDevice; } +bool IfcMedicalDevice::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum IfcMedicalDevice::PredefinedType() const { return IfcMedicalDeviceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcMedicalDevice::setPredefinedType(IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcMedicalDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcMedicalDevice::declaration() const { return *IfcMedicalDevice_type; } Type::Enum IfcMedicalDevice::Class() { return Type::IfcMedicalDevice; } -IfcMedicalDevice::IfcMedicalDevice(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMedicalDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMedicalDevice::IfcMedicalDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcMedicalDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcMedicalDevice::IfcMedicalDevice(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMedicalDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMedicalDevice::IfcMedicalDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcMedicalDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMedicalDeviceType -IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum IfcMedicalDeviceType::PredefinedType() const { return IfcMedicalDeviceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcMedicalDeviceType::setPredefinedType(IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcMedicalDeviceTypeEnum::ToString(v)); } -bool IfcMedicalDeviceType::is(Type::Enum v) const { return v == Type::IfcMedicalDeviceType || IfcFlowTerminalType::is(v); } -Type::Enum IfcMedicalDeviceType::type() const { return Type::IfcMedicalDeviceType; } +IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum IfcMedicalDeviceType::PredefinedType() const { return IfcMedicalDeviceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcMedicalDeviceType::setPredefinedType(IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcMedicalDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcMedicalDeviceType::declaration() const { return *IfcMedicalDeviceType_type; } Type::Enum IfcMedicalDeviceType::Class() { return Type::IfcMedicalDeviceType; } -IfcMedicalDeviceType::IfcMedicalDeviceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMedicalDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMedicalDeviceType::IfcMedicalDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum 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,IfcMedicalDeviceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcMedicalDeviceType::IfcMedicalDeviceType(IfcAbstractEntity* e) : IfcFlowTerminalType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMedicalDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMedicalDeviceType::IfcMedicalDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum 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,IfcMedicalDeviceTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMember -bool IfcMember::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcMemberTypeEnum::IfcMemberTypeEnum IfcMember::PredefinedType() const { return IfcMemberTypeEnum::FromString(*entity->getArgument(8)); } -void IfcMember::setPredefinedType(IfcMemberTypeEnum::IfcMemberTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcMemberTypeEnum::ToString(v)); } -bool IfcMember::is(Type::Enum v) const { return v == Type::IfcMember || IfcBuildingElement::is(v); } -Type::Enum IfcMember::type() const { return Type::IfcMember; } +bool IfcMember::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcMemberTypeEnum::IfcMemberTypeEnum IfcMember::PredefinedType() const { return IfcMemberTypeEnum::FromString(*data_->getArgument(8)); } +void IfcMember::setPredefinedType(IfcMemberTypeEnum::IfcMemberTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcMemberTypeEnum::ToString(v)); } + + +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, boost::optional< IfcMemberTypeEnum::IfcMemberTypeEnum > 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,IfcMemberTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcMemberTypeEnum::IfcMemberTypeEnum > 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,IfcMemberTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMemberStandardCase -bool IfcMemberStandardCase::is(Type::Enum v) const { return v == Type::IfcMemberStandardCase || IfcMember::is(v); } -Type::Enum IfcMemberStandardCase::type() const { return Type::IfcMemberStandardCase; } + + +const IfcParse::entity& IfcMemberStandardCase::declaration() const { return *IfcMemberStandardCase_type; } Type::Enum IfcMemberStandardCase::Class() { return Type::IfcMemberStandardCase; } -IfcMemberStandardCase::IfcMemberStandardCase(IfcAbstractEntity* e) : IfcMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMemberStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMemberStandardCase::IfcMemberStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMemberTypeEnum::IfcMemberTypeEnum > v9_PredefinedType) : IfcMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcMemberTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcMemberStandardCase::IfcMemberStandardCase(IfcAbstractEntity* e) : IfcMember((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMemberStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMemberStandardCase::IfcMemberStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMemberTypeEnum::IfcMemberTypeEnum > v9_PredefinedType) : IfcMember((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcMemberTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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::hasReferencePath() const { return !entity->getArgument(10)->isNull(); } -IfcReference* IfcMetric::ReferencePath() const { return (IfcReference*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcMetric::setReferencePath(IfcReference* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,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); } +bool IfcMetric::hasReferencePath() const { return !data_->getArgument(10)->isNull(); } +IfcReference* IfcMetric::ReferencePath() const { return (IfcReference*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcMetric::setReferencePath(IfcReference* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcBenchmarkEnum::IfcBenchmarkEnum v8_Benchmark, boost::optional< std::string > v9_ValueSource, IfcMetricValueSelect* v10_DataValue, IfcReference* v11_ReferencePath) : 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)); if (v6_CreationTime) { e->setArgument(5,(*v6_CreationTime)); } else { e->setArgument(5); } 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)); e->setArgument(10,(v11_ReferencePath)); 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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcBenchmarkEnum::IfcBenchmarkEnum v8_Benchmark, boost::optional< std::string > v9_ValueSource, IfcMetricValueSelect* v10_DataValue, IfcReference* v11_ReferencePath) : 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)); if (v6_CreationTime) { e->setArgument(5,(*v6_CreationTime)); } else { e->setArgument(5); } 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)); e->setArgument(10,(v11_ReferencePath)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMirroredProfileDef -bool IfcMirroredProfileDef::is(Type::Enum v) const { return v == Type::IfcMirroredProfileDef || IfcDerivedProfileDef::is(v); } -Type::Enum IfcMirroredProfileDef::type() const { return Type::IfcMirroredProfileDef; } + + +const IfcParse::entity& IfcMirroredProfileDef::declaration() const { return *IfcMirroredProfileDef_type; } Type::Enum IfcMirroredProfileDef::Class() { return Type::IfcMirroredProfileDef; } -IfcMirroredProfileDef::IfcMirroredProfileDef(IfcAbstractEntity* e) : IfcDerivedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMirroredProfileDef)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMirroredProfileDef::IfcMirroredProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcProfileDef* v3_ParentProfile, boost::optional< std::string > v5_Label) : IfcDerivedProfileDef((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->setArgumentDerived(3); if (v5_Label) { e->setArgument(4,(*v5_Label)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcMirroredProfileDef::IfcMirroredProfileDef(IfcAbstractEntity* e) : IfcDerivedProfileDef((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMirroredProfileDef)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMirroredProfileDef::IfcMirroredProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcProfileDef* v3_ParentProfile, boost::optional< std::string > v5_Label) : IfcDerivedProfileDef((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->setArgumentDerived(3); if (v5_Label) { e->setArgument(4,(*v5_Label)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMonetaryUnit -std::string IfcMonetaryUnit::Currency() const { return *entity->getArgument(0); } -void IfcMonetaryUnit::setCurrency(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcMonetaryUnit::is(Type::Enum v) const { return v == Type::IfcMonetaryUnit; } -Type::Enum IfcMonetaryUnit::type() const { return Type::IfcMonetaryUnit; } +std::string IfcMonetaryUnit::Currency() const { return *data_->getArgument(0); } +void IfcMonetaryUnit::setCurrency(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,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(std::string v1_Currency) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(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(std::string v1_Currency) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Currency)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcMotorConnection -bool IfcMotorConnection::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnection::PredefinedType() const { return IfcMotorConnectionTypeEnum::FromString(*entity->getArgument(8)); } -void IfcMotorConnection::setPredefinedType(IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcMotorConnectionTypeEnum::ToString(v)); } -bool IfcMotorConnection::is(Type::Enum v) const { return v == Type::IfcMotorConnection || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcMotorConnection::type() const { return Type::IfcMotorConnection; } +bool IfcMotorConnection::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnection::PredefinedType() const { return IfcMotorConnectionTypeEnum::FromString(*data_->getArgument(8)); } +void IfcMotorConnection::setPredefinedType(IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcMotorConnectionTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcMotorConnection::declaration() const { return *IfcMotorConnection_type; } Type::Enum IfcMotorConnection::Class() { return Type::IfcMotorConnection; } -IfcMotorConnection::IfcMotorConnection(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMotorConnection)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcMotorConnection::IfcMotorConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcMotorConnectionTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcMotorConnection::IfcMotorConnection(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcMotorConnection)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcMotorConnection::IfcMotorConnection(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcMotorConnectionTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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); } -IfcRelDefinesByObject::list::ptr IfcObject::IsDeclaredBy() const { return entity->getInverse(Type::IfcRelDefinesByObject, 4)->as(); } -IfcRelDefinesByObject::list::ptr IfcObject::Declares() const { return entity->getInverse(Type::IfcRelDefinesByObject, 5)->as(); } -IfcRelDefinesByType::list::ptr IfcObject::IsTypedBy() const { return entity->getInverse(Type::IfcRelDefinesByType, 4)->as(); } -IfcRelDefinesByProperties::list::ptr IfcObject::IsDefinedBy() const { return entity->getInverse(Type::IfcRelDefinesByProperties, 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); } + +IfcRelDefinesByObject::list::ptr IfcObject::IsDeclaredBy() const { return data_->getInverse(Type::IfcRelDefinesByObject, 4)->as(); } +IfcRelDefinesByObject::list::ptr IfcObject::Declares() const { return data_->getInverse(Type::IfcRelDefinesByObject, 5)->as(); } +IfcRelDefinesByType::list::ptr IfcObject::IsTypedBy() const { return data_->getInverse(Type::IfcRelDefinesByType, 4)->as(); } +IfcRelDefinesByProperties::list::ptr IfcObject::IsDefinedBy() const { return data_->getInverse(Type::IfcRelDefinesByProperties, 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(); } -IfcRelNests::list::ptr IfcObjectDefinition::Nests() const { return entity->getInverse(Type::IfcRelNests, 5)->as(); } -IfcRelNests::list::ptr IfcObjectDefinition::IsNestedBy() const { return entity->getInverse(Type::IfcRelNests, 4)->as(); } -IfcRelDeclares::list::ptr IfcObjectDefinition::HasContext() const { return entity->getInverse(Type::IfcRelDeclares, 5)->as(); } -IfcRelAggregates::list::ptr IfcObjectDefinition::IsDecomposedBy() const { return entity->getInverse(Type::IfcRelAggregates, 4)->as(); } -IfcRelAggregates::list::ptr IfcObjectDefinition::Decomposes() const { return entity->getInverse(Type::IfcRelAggregates, 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(); } +IfcRelNests::list::ptr IfcObjectDefinition::Nests() const { return data_->getInverse(Type::IfcRelNests, 5)->as(); } +IfcRelNests::list::ptr IfcObjectDefinition::IsNestedBy() const { return data_->getInverse(Type::IfcRelNests, 4)->as(); } +IfcRelDeclares::list::ptr IfcObjectDefinition::HasContext() const { return data_->getInverse(Type::IfcRelDeclares, 5)->as(); } +IfcRelAggregates::list::ptr IfcObjectDefinition::IsDecomposedBy() const { return data_->getInverse(Type::IfcRelAggregates, 4)->as(); } +IfcRelAggregates::list::ptr IfcObjectDefinition::Decomposes() const { return data_->getInverse(Type::IfcRelAggregates, 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(); } -IfcTemplatedEntityList< IfcConstraint >::ptr IfcObjective::BenchmarkValues() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcObjective::setBenchmarkValues(IfcTemplatedEntityList< IfcConstraint >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcObjective::hasLogicalAggregator() const { return !entity->getArgument(8)->isNull(); } -IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcObjective::LogicalAggregator() const { return IfcLogicalOperatorEnum::FromString(*entity->getArgument(8)); } -void IfcObjective::setLogicalAggregator(IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcLogicalOperatorEnum::ToString(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(); } +IfcTemplatedEntityList< IfcConstraint >::ptr IfcObjective::BenchmarkValues() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcObjective::setBenchmarkValues(IfcTemplatedEntityList< IfcConstraint >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcObjective::hasLogicalAggregator() const { return !data_->getArgument(8)->isNull(); } +IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcObjective::LogicalAggregator() const { return IfcLogicalOperatorEnum::FromString(*data_->getArgument(8)); } +void IfcObjective::setLogicalAggregator(IfcLogicalOperatorEnum::IfcLogicalOperatorEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcLogicalOperatorEnum::ToString(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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, boost::optional< IfcTemplatedEntityList< IfcConstraint >::ptr > v8_BenchmarkValues, boost::optional< IfcLogicalOperatorEnum::IfcLogicalOperatorEnum > v9_LogicalAggregator, 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)); if (v6_CreationTime) { e->setArgument(5,(*v6_CreationTime)); } else { e->setArgument(5); } if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } if (v8_BenchmarkValues) { e->setArgument(7,(*v8_BenchmarkValues)->generalize()); } else { e->setArgument(7); } if (v9_LogicalAggregator) { e->setArgument(8,*v9_LogicalAggregator,IfcLogicalOperatorEnum::ToString(*v9_LogicalAggregator)); } else { e->setArgument(8); } 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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, boost::optional< IfcTemplatedEntityList< IfcConstraint >::ptr > v8_BenchmarkValues, boost::optional< IfcLogicalOperatorEnum::IfcLogicalOperatorEnum > v9_LogicalAggregator, 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)); if (v6_CreationTime) { e->setArgument(5,(*v6_CreationTime)); } else { e->setArgument(5); } if (v7_UserDefinedGrade) { e->setArgument(6,(*v7_UserDefinedGrade)); } else { e->setArgument(6); } if (v8_BenchmarkValues) { e->setArgument(7,(*v8_BenchmarkValues)->generalize()); } else { e->setArgument(7); } if (v9_LogicalAggregator) { e->setArgument(8,*v9_LogicalAggregator,IfcLogicalOperatorEnum::ToString(*v9_LogicalAggregator)); } else { e->setArgument(8); } 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 -bool IfcOccupant::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -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; } +bool IfcOccupant::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +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, boost::optional< 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)); if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcOccupantTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } 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, boost::optional< 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)); if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcOccupantTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } 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 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 -bool IfcOpeningElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum IfcOpeningElement::PredefinedType() const { return IfcOpeningElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcOpeningElement::setPredefinedType(IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcOpeningElementTypeEnum::ToString(v)); } -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; } +bool IfcOpeningElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum IfcOpeningElement::PredefinedType() const { return IfcOpeningElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcOpeningElement::setPredefinedType(IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcOpeningElementTypeEnum::ToString(v)); } + +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, boost::optional< IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum > v9_PredefinedType) : 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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcOpeningElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum > v9_PredefinedType) : 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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcOpeningElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOpeningStandardCase -bool IfcOpeningStandardCase::is(Type::Enum v) const { return v == Type::IfcOpeningStandardCase || IfcOpeningElement::is(v); } -Type::Enum IfcOpeningStandardCase::type() const { return Type::IfcOpeningStandardCase; } + + +const IfcParse::entity& IfcOpeningStandardCase::declaration() const { return *IfcOpeningStandardCase_type; } Type::Enum IfcOpeningStandardCase::Class() { return Type::IfcOpeningStandardCase; } -IfcOpeningStandardCase::IfcOpeningStandardCase(IfcAbstractEntity* e) : IfcOpeningElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpeningStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOpeningStandardCase::IfcOpeningStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum > v9_PredefinedType) : IfcOpeningElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcOpeningElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcOpeningStandardCase::IfcOpeningStandardCase(IfcAbstractEntity* e) : IfcOpeningElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOpeningStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOpeningStandardCase::IfcOpeningStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum > v9_PredefinedType) : IfcOpeningElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcOpeningElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcOrganization -bool IfcOrganization::hasIdentification() const { return !entity->getArgument(0)->isNull(); } -std::string IfcOrganization::Identification() const { return *entity->getArgument(0); } -void IfcOrganization::setIdentification(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::hasIdentification() const { return !data_->getArgument(0)->isNull(); } +std::string IfcOrganization::Identification() const { return *data_->getArgument(0); } +void IfcOrganization::setIdentification(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_Identification, 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_Identification) { e->setArgument(0,(*v1_Identification)); } 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_Identification, 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_Identification) { e->setArgument(0,(*v1_Identification)); } 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 -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 || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcOrganizationRelationship::type() const { return Type::IfcOrganizationRelationship; } +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) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOrganizationRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOrganizationRelationship::IfcOrganizationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcOrganization* v3_RelatingOrganization, IfcTemplatedEntityList< IfcOrganization >::ptr v4_RelatedOrganizations) : IfcResourceLevelRelationship((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_RelatingOrganization)); e->setArgument(3,(v4_RelatedOrganizations)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcOrganizationRelationship::IfcOrganizationRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOrganizationRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOrganizationRelationship::IfcOrganizationRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcOrganization* v3_RelatingOrganization, IfcTemplatedEntityList< IfcOrganization >::ptr v4_RelatedOrganizations) : IfcResourceLevelRelationship((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_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 IfcOuterBoundaryCurve -bool IfcOuterBoundaryCurve::is(Type::Enum v) const { return v == Type::IfcOuterBoundaryCurve || IfcBoundaryCurve::is(v); } -Type::Enum IfcOuterBoundaryCurve::type() const { return Type::IfcOuterBoundaryCurve; } + + +const IfcParse::entity& IfcOuterBoundaryCurve::declaration() const { return *IfcOuterBoundaryCurve_type; } Type::Enum IfcOuterBoundaryCurve::Class() { return Type::IfcOuterBoundaryCurve; } -IfcOuterBoundaryCurve::IfcOuterBoundaryCurve(IfcAbstractEntity* e) : IfcBoundaryCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOuterBoundaryCurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOuterBoundaryCurve::IfcOuterBoundaryCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcBoundaryCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Segments)->generalize()); e->setArgument(1,(v2_SelfIntersect)); entity = e; EntityBuffer::Add(this); } +IfcOuterBoundaryCurve::IfcOuterBoundaryCurve(IfcAbstractEntity* e) : IfcBoundaryCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOuterBoundaryCurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOuterBoundaryCurve::IfcOuterBoundaryCurve(IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect) : IfcBoundaryCurve((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 IfcOutlet -bool IfcOutlet::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutlet::PredefinedType() const { return IfcOutletTypeEnum::FromString(*entity->getArgument(8)); } -void IfcOutlet::setPredefinedType(IfcOutletTypeEnum::IfcOutletTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcOutletTypeEnum::ToString(v)); } -bool IfcOutlet::is(Type::Enum v) const { return v == Type::IfcOutlet || IfcFlowTerminal::is(v); } -Type::Enum IfcOutlet::type() const { return Type::IfcOutlet; } +bool IfcOutlet::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutlet::PredefinedType() const { return IfcOutletTypeEnum::FromString(*data_->getArgument(8)); } +void IfcOutlet::setPredefinedType(IfcOutletTypeEnum::IfcOutletTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcOutletTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcOutlet::declaration() const { return *IfcOutlet_type; } Type::Enum IfcOutlet::Class() { return Type::IfcOutlet; } -IfcOutlet::IfcOutlet(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOutlet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcOutlet::IfcOutlet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcOutletTypeEnum::IfcOutletTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcOutletTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcOutlet::IfcOutlet(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcOutlet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcOutlet::IfcOutlet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcOutletTypeEnum::IfcOutletTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcOutletTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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)); } -bool IfcOwnerHistory::hasChangeAction() const { return !entity->getArgument(3)->isNull(); } -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)); } +bool IfcOwnerHistory::hasChangeAction() const { return !data_->getArgument(3)->isNull(); } +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, boost::optional< 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); } if (v4_ChangeAction) { e->setArgument(3,*v4_ChangeAction,IfcChangeActionEnum::ToString(*v4_ChangeAction)); } else { e->setArgument(3); } 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, boost::optional< 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); } if (v4_ChangeAction) { e->setArgument(3,*v4_ChangeAction,IfcChangeActionEnum::ToString(*v4_ChangeAction)); } else { e->setArgument(3); } 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 -bool IfcParameterizedProfileDef::hasPosition() const { return !entity->getArgument(2)->isNull(); } -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; } +bool IfcParameterizedProfileDef::hasPosition() const { return !data_->getArgument(2)->isNull(); } +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 IfcPcurve -IfcSurface* IfcPcurve::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcPcurve::setBasisSurface(IfcSurface* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -IfcCurve* IfcPcurve::ReferenceCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcPcurve::setReferenceCurve(IfcCurve* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcPcurve::is(Type::Enum v) const { return v == Type::IfcPcurve || IfcCurve::is(v); } -Type::Enum IfcPcurve::type() const { return Type::IfcPcurve; } +IfcSurface* IfcPcurve::BasisSurface() const { return (IfcSurface*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcPcurve::setBasisSurface(IfcSurface* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +IfcCurve* IfcPcurve::ReferenceCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcPcurve::setReferenceCurve(IfcCurve* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcPcurve::declaration() const { return *IfcPcurve_type; } Type::Enum IfcPcurve::Class() { return Type::IfcPcurve; } -IfcPcurve::IfcPcurve(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPcurve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPcurve::IfcPcurve(IfcSurface* v1_BasisSurface, IfcCurve* v2_ReferenceCurve) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_ReferenceCurve)); entity = e; EntityBuffer::Add(this); } +IfcPcurve::IfcPcurve(IfcAbstractEntity* e) : IfcCurve((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPcurve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPcurve::IfcPcurve(IfcSurface* v1_BasisSurface, IfcCurve* v2_ReferenceCurve) : IfcCurve((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_BasisSurface)); e->setArgument(1,(v2_ReferenceCurve)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPerformanceHistory -std::string IfcPerformanceHistory::LifeCyclePhase() const { return *entity->getArgument(6); } -void IfcPerformanceHistory::setLifeCyclePhase(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcPerformanceHistory::hasPredefinedType() const { return !entity->getArgument(7)->isNull(); } -IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum IfcPerformanceHistory::PredefinedType() const { return IfcPerformanceHistoryTypeEnum::FromString(*entity->getArgument(7)); } -void IfcPerformanceHistory::setPredefinedType(IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcPerformanceHistoryTypeEnum::ToString(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(6); } +void IfcPerformanceHistory::setLifeCyclePhase(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcPerformanceHistory::hasPredefinedType() const { return !data_->getArgument(7)->isNull(); } +IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum IfcPerformanceHistory::PredefinedType() const { return IfcPerformanceHistoryTypeEnum::FromString(*data_->getArgument(7)); } +void IfcPerformanceHistory::setPredefinedType(IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcPerformanceHistoryTypeEnum::ToString(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, boost::optional< std::string > v6_Identification, std::string v7_LifeCyclePhase, boost::optional< IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum > v8_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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } e->setArgument(6,(v7_LifeCyclePhase)); if (v8_PredefinedType) { e->setArgument(7,*v8_PredefinedType,IfcPerformanceHistoryTypeEnum::ToString(*v8_PredefinedType)); } else { e->setArgument(7); } 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, boost::optional< std::string > v6_Identification, std::string v7_LifeCyclePhase, boost::optional< IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum > v8_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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } e->setArgument(6,(v7_LifeCyclePhase)); if (v8_PredefinedType) { e->setArgument(7,*v8_PredefinedType,IfcPerformanceHistoryTypeEnum::ToString(*v8_PredefinedType)); } else { e->setArgument(7); } 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 || IfcPreDefinedPropertySet::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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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 -bool IfcPermit::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -IfcPermitTypeEnum::IfcPermitTypeEnum IfcPermit::PredefinedType() const { return IfcPermitTypeEnum::FromString(*entity->getArgument(6)); } -void IfcPermit::setPredefinedType(IfcPermitTypeEnum::IfcPermitTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v,IfcPermitTypeEnum::ToString(v)); } -bool IfcPermit::hasStatus() const { return !entity->getArgument(7)->isNull(); } -std::string IfcPermit::Status() const { return *entity->getArgument(7); } -void IfcPermit::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcPermit::hasLongDescription() const { return !entity->getArgument(8)->isNull(); } -std::string IfcPermit::LongDescription() const { return *entity->getArgument(8); } -void IfcPermit::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcPermit::is(Type::Enum v) const { return v == Type::IfcPermit || IfcControl::is(v); } -Type::Enum IfcPermit::type() const { return Type::IfcPermit; } +bool IfcPermit::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +IfcPermitTypeEnum::IfcPermitTypeEnum IfcPermit::PredefinedType() const { return IfcPermitTypeEnum::FromString(*data_->getArgument(6)); } +void IfcPermit::setPredefinedType(IfcPermitTypeEnum::IfcPermitTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v,IfcPermitTypeEnum::ToString(v)); } +bool IfcPermit::hasStatus() const { return !data_->getArgument(7)->isNull(); } +std::string IfcPermit::Status() const { return *data_->getArgument(7); } +void IfcPermit::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcPermit::hasLongDescription() const { return !data_->getArgument(8)->isNull(); } +std::string IfcPermit::LongDescription() const { return *data_->getArgument(8); } +void IfcPermit::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, boost::optional< std::string > v6_Identification, boost::optional< IfcPermitTypeEnum::IfcPermitTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcPermitTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_LongDescription) { e->setArgument(8,(*v9_LongDescription)); } else { e->setArgument(8); } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcPermitTypeEnum::IfcPermitTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcPermitTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_LongDescription) { e->setArgument(8,(*v9_LongDescription)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPerson -bool IfcPerson::hasIdentification() const { return !entity->getArgument(0)->isNull(); } -std::string IfcPerson::Identification() const { return *entity->getArgument(0); } -void IfcPerson::setIdentification(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::hasIdentification() const { return !data_->getArgument(0)->isNull(); } +std::string IfcPerson::Identification() const { return *data_->getArgument(0); } +void IfcPerson::setIdentification(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_Identification, 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_Identification) { e->setArgument(0,(*v1_Identification)); } 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_Identification, 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_Identification) { e->setArgument(0,(*v1_Identification)); } 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); } -IfcExternalReferenceRelationship::list::ptr IfcPhysicalQuantity::HasExternalReferences() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -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); } + +IfcExternalReferenceRelationship::list::ptr IfcPhysicalQuantity::HasExternalReferences() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } +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 -bool IfcPile::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -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; } +bool IfcPile::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +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, boost::optional< 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcPileTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcPileTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } if (v10_ConstructionType) { e->setArgument(9,*v10_ConstructionType,IfcPileConstructionEnum::ToString(*v10_ConstructionType)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPileType -IfcPileTypeEnum::IfcPileTypeEnum IfcPileType::PredefinedType() const { return IfcPileTypeEnum::FromString(*entity->getArgument(9)); } -void IfcPileType::setPredefinedType(IfcPileTypeEnum::IfcPileTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcPileTypeEnum::ToString(v)); } -bool IfcPileType::is(Type::Enum v) const { return v == Type::IfcPileType || IfcBuildingElementType::is(v); } -Type::Enum IfcPileType::type() const { return Type::IfcPileType; } +IfcPileTypeEnum::IfcPileTypeEnum IfcPileType::PredefinedType() const { return IfcPileTypeEnum::FromString(*data_->getArgument(9)); } +void IfcPileType::setPredefinedType(IfcPileTypeEnum::IfcPileTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcPileTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPileType::declaration() const { return *IfcPileType_type; } Type::Enum IfcPileType::Class() { return Type::IfcPileType; } -IfcPileType::IfcPileType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPileType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPileType::IfcPileType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPileTypeEnum::IfcPileTypeEnum 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,IfcPileTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcPileType::IfcPileType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPileType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPileType::IfcPileType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPileTypeEnum::IfcPileTypeEnum 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,IfcPileTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPipeFitting -bool IfcPipeFitting::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFitting::PredefinedType() const { return IfcPipeFittingTypeEnum::FromString(*entity->getArgument(8)); } -void IfcPipeFitting::setPredefinedType(IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcPipeFittingTypeEnum::ToString(v)); } -bool IfcPipeFitting::is(Type::Enum v) const { return v == Type::IfcPipeFitting || IfcFlowFitting::is(v); } -Type::Enum IfcPipeFitting::type() const { return Type::IfcPipeFitting; } +bool IfcPipeFitting::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFitting::PredefinedType() const { return IfcPipeFittingTypeEnum::FromString(*data_->getArgument(8)); } +void IfcPipeFitting::setPredefinedType(IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcPipeFittingTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPipeFitting::declaration() const { return *IfcPipeFitting_type; } Type::Enum IfcPipeFitting::Class() { return Type::IfcPipeFitting; } -IfcPipeFitting::IfcPipeFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeFitting)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPipeFitting::IfcPipeFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPipeFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcPipeFitting::IfcPipeFitting(IfcAbstractEntity* e) : IfcFlowFitting((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeFitting)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPipeFitting::IfcPipeFitting(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum > v9_PredefinedType) : IfcFlowFitting((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPipeFittingTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcPipeSegment -bool IfcPipeSegment::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegment::PredefinedType() const { return IfcPipeSegmentTypeEnum::FromString(*entity->getArgument(8)); } -void IfcPipeSegment::setPredefinedType(IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcPipeSegmentTypeEnum::ToString(v)); } -bool IfcPipeSegment::is(Type::Enum v) const { return v == Type::IfcPipeSegment || IfcFlowSegment::is(v); } -Type::Enum IfcPipeSegment::type() const { return Type::IfcPipeSegment; } +bool IfcPipeSegment::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegment::PredefinedType() const { return IfcPipeSegmentTypeEnum::FromString(*data_->getArgument(8)); } +void IfcPipeSegment::setPredefinedType(IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcPipeSegmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPipeSegment::declaration() const { return *IfcPipeSegment_type; } Type::Enum IfcPipeSegment::Class() { return Type::IfcPipeSegment; } -IfcPipeSegment::IfcPipeSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPipeSegment::IfcPipeSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPipeSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcPipeSegment::IfcPipeSegment(IfcAbstractEntity* e) : IfcFlowSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPipeSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPipeSegment::IfcPipeSegment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum > v9_PredefinedType) : IfcFlowSegment((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPipeSegmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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(5); } -void IfcPixelTexture::setWidth(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -int IfcPixelTexture::Height() const { return *entity->getArgument(6); } -void IfcPixelTexture::setHeight(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -int IfcPixelTexture::ColourComponents() const { return *entity->getArgument(7); } -void IfcPixelTexture::setColourComponents(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -std::vector< boost::dynamic_bitset<> > /*[1:?]*/ IfcPixelTexture::Pixel() const { return *entity->getArgument(8); } -void IfcPixelTexture::setPixel(std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,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(5); } +void IfcPixelTexture::setWidth(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +int IfcPixelTexture::Height() const { return *data_->getArgument(6); } +void IfcPixelTexture::setHeight(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +int IfcPixelTexture::ColourComponents() const { return *data_->getArgument(7); } +void IfcPixelTexture::setColourComponents(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +std::vector< boost::dynamic_bitset<> > /*[1:?]*/ IfcPixelTexture::Pixel() const { return *data_->getArgument(8); } +void IfcPixelTexture::setPixel(std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, int v6_Width, int v7_Height, int v8_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v9_Pixel) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } e->setArgument(5,(v6_Width)); e->setArgument(6,(v7_Height)); e->setArgument(7,(v8_ColourComponents)); e->setArgument(8,(v9_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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, int v6_Width, int v7_Height, int v8_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v9_Pixel) : IfcSurfaceTexture((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } e->setArgument(5,(v6_Width)); e->setArgument(6,(v7_Height)); e->setArgument(7,(v8_ColourComponents)); e->setArgument(8,(v9_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::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlate::PredefinedType() const { return IfcPlateTypeEnum::FromString(*entity->getArgument(8)); } -void IfcPlate::setPredefinedType(IfcPlateTypeEnum::IfcPlateTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcPlateTypeEnum::ToString(v)); } -bool IfcPlate::is(Type::Enum v) const { return v == Type::IfcPlate || IfcBuildingElement::is(v); } -Type::Enum IfcPlate::type() const { return Type::IfcPlate; } +bool IfcPlate::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlate::PredefinedType() const { return IfcPlateTypeEnum::FromString(*data_->getArgument(8)); } +void IfcPlate::setPredefinedType(IfcPlateTypeEnum::IfcPlateTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcPlateTypeEnum::ToString(v)); } + + +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, boost::optional< IfcPlateTypeEnum::IfcPlateTypeEnum > 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,IfcPlateTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcPlateTypeEnum::IfcPlateTypeEnum > 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,IfcPlateTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPlateStandardCase -bool IfcPlateStandardCase::is(Type::Enum v) const { return v == Type::IfcPlateStandardCase || IfcPlate::is(v); } -Type::Enum IfcPlateStandardCase::type() const { return Type::IfcPlateStandardCase; } + + +const IfcParse::entity& IfcPlateStandardCase::declaration() const { return *IfcPlateStandardCase_type; } Type::Enum IfcPlateStandardCase::Class() { return Type::IfcPlateStandardCase; } -IfcPlateStandardCase::IfcPlateStandardCase(IfcAbstractEntity* e) : IfcPlate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlateStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPlateStandardCase::IfcPlateStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPlateTypeEnum::IfcPlateTypeEnum > v9_PredefinedType) : IfcPlate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPlateTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcPlateStandardCase::IfcPlateStandardCase(IfcAbstractEntity* e) : IfcPlate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPlateStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPlateStandardCase::IfcPlateStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPlateTypeEnum::IfcPlateTypeEnum > v9_PredefinedType) : IfcPlate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPlateTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedItem::IfcPreDefinedItem(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Name)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedProperties -bool IfcPreDefinedProperties::is(Type::Enum v) const { return v == Type::IfcPreDefinedProperties || IfcPropertyAbstraction::is(v); } -Type::Enum IfcPreDefinedProperties::type() const { return Type::IfcPreDefinedProperties; } + + +const IfcParse::entity& IfcPreDefinedProperties::declaration() const { return *IfcPreDefinedProperties_type; } Type::Enum IfcPreDefinedProperties::Class() { return Type::IfcPreDefinedProperties; } -IfcPreDefinedProperties::IfcPreDefinedProperties(IfcAbstractEntity* e) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedProperties)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedProperties::IfcPreDefinedProperties() : IfcPropertyAbstraction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcPreDefinedProperties::IfcPreDefinedProperties(IfcAbstractEntity* e) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedProperties)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedProperties::IfcPreDefinedProperties() : IfcPropertyAbstraction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPreDefinedPropertySet -bool IfcPreDefinedPropertySet::is(Type::Enum v) const { return v == Type::IfcPreDefinedPropertySet || IfcPropertySetDefinition::is(v); } -Type::Enum IfcPreDefinedPropertySet::type() const { return Type::IfcPreDefinedPropertySet; } + + +const IfcParse::entity& IfcPreDefinedPropertySet::declaration() const { return *IfcPreDefinedPropertySet_type; } Type::Enum IfcPreDefinedPropertySet::Class() { return Type::IfcPreDefinedPropertySet; } -IfcPreDefinedPropertySet::IfcPreDefinedPropertySet(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedPropertySet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPreDefinedPropertySet::IfcPreDefinedPropertySet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : 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); } entity = e; EntityBuffer::Add(this); } +IfcPreDefinedPropertySet::IfcPreDefinedPropertySet(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPreDefinedPropertySet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPreDefinedPropertySet::IfcPreDefinedPropertySet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : 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); } 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 IfcPresentationItem -bool IfcPresentationItem::is(Type::Enum v) const { return v == Type::IfcPresentationItem; } -Type::Enum IfcPresentationItem::type() const { return Type::IfcPresentationItem; } + + +const IfcParse::entity& IfcPresentationItem::declaration() const { return *IfcPresentationItem_type; } Type::Enum IfcPresentationItem::Class() { return Type::IfcPresentationItem; } -IfcPresentationItem::IfcPresentationItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPresentationItem::IfcPresentationItem() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcPresentationItem::IfcPresentationItem(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPresentationItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPresentationItem::IfcPresentationItem() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); 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); } -IfcTemplatedEntityList< IfcPresentationStyle >::ptr IfcPresentationLayerWithStyle::LayerStyles() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcPresentationLayerWithStyle::setLayerStyles(IfcTemplatedEntityList< IfcPresentationStyle >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -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); } +IfcTemplatedEntityList< IfcPresentationStyle >::ptr IfcPresentationLayerWithStyle::LayerStyles() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcPresentationLayerWithStyle::setLayerStyles(IfcTemplatedEntityList< IfcPresentationStyle >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } + + +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, IfcTemplatedEntityList< IfcPresentationStyle >::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)->generalize()); 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, IfcTemplatedEntityList< IfcPresentationStyle >::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)->generalize()); 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 -bool IfcProcedure::hasPredefinedType() const { return !entity->getArgument(7)->isNull(); } -IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedure::PredefinedType() const { return IfcProcedureTypeEnum::FromString(*entity->getArgument(7)); } -void IfcProcedure::setPredefinedType(IfcProcedureTypeEnum::IfcProcedureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcProcedureTypeEnum::ToString(v)); } -bool IfcProcedure::is(Type::Enum v) const { return v == Type::IfcProcedure || IfcProcess::is(v); } -Type::Enum IfcProcedure::type() const { return Type::IfcProcedure; } +bool IfcProcedure::hasPredefinedType() const { return !data_->getArgument(7)->isNull(); } +IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedure::PredefinedType() const { return IfcProcedureTypeEnum::FromString(*data_->getArgument(7)); } +void IfcProcedure::setPredefinedType(IfcProcedureTypeEnum::IfcProcedureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcProcedureTypeEnum::ToString(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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< IfcProcedureTypeEnum::IfcProcedureTypeEnum > v8_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } if (v8_PredefinedType) { e->setArgument(7,*v8_PredefinedType,IfcProcedureTypeEnum::ToString(*v8_PredefinedType)); } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< IfcProcedureTypeEnum::IfcProcedureTypeEnum > v8_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } if (v8_PredefinedType) { e->setArgument(7,*v8_PredefinedType,IfcProcedureTypeEnum::ToString(*v8_PredefinedType)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProcedureType -IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedureType::PredefinedType() const { return IfcProcedureTypeEnum::FromString(*entity->getArgument(9)); } -void IfcProcedureType::setPredefinedType(IfcProcedureTypeEnum::IfcProcedureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcProcedureTypeEnum::ToString(v)); } -bool IfcProcedureType::is(Type::Enum v) const { return v == Type::IfcProcedureType || IfcTypeProcess::is(v); } -Type::Enum IfcProcedureType::type() const { return Type::IfcProcedureType; } +IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedureType::PredefinedType() const { return IfcProcedureTypeEnum::FromString(*data_->getArgument(9)); } +void IfcProcedureType::setPredefinedType(IfcProcedureTypeEnum::IfcProcedureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcProcedureTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcProcedureType::declaration() const { return *IfcProcedureType_type; } Type::Enum IfcProcedureType::Class() { return Type::IfcProcedureType; } -IfcProcedureType::IfcProcedureType(IfcAbstractEntity* e) : IfcTypeProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProcedureType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProcedureType::IfcProcedureType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcProcedureTypeEnum::IfcProcedureTypeEnum v10_PredefinedType) : IfcTypeProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcProcedureTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcProcedureType::IfcProcedureType(IfcAbstractEntity* e) : IfcTypeProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProcedureType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProcedureType::IfcProcedureType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcProcedureTypeEnum::IfcProcedureTypeEnum v10_PredefinedType) : IfcTypeProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcProcedureTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProcess -bool IfcProcess::hasIdentification() const { return !entity->getArgument(5)->isNull(); } -std::string IfcProcess::Identification() const { return *entity->getArgument(5); } -void IfcProcess::setIdentification(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcProcess::hasLongDescription() const { return !entity->getArgument(6)->isNull(); } -std::string IfcProcess::LongDescription() const { return *entity->getArgument(6); } -void IfcProcess::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -IfcRelSequence::list::ptr IfcProcess::IsPredecessorTo() const { return entity->getInverse(Type::IfcRelSequence, 4)->as(); } -IfcRelSequence::list::ptr IfcProcess::IsSuccessorFrom() const { return entity->getInverse(Type::IfcRelSequence, 5)->as(); } -IfcRelAssignsToProcess::list::ptr IfcProcess::OperatesOn() const { return entity->getInverse(Type::IfcRelAssignsToProcess, 6)->as(); } -bool IfcProcess::is(Type::Enum v) const { return v == Type::IfcProcess || IfcObject::is(v); } -Type::Enum IfcProcess::type() const { return Type::IfcProcess; } +bool IfcProcess::hasIdentification() const { return !data_->getArgument(5)->isNull(); } +std::string IfcProcess::Identification() const { return *data_->getArgument(5); } +void IfcProcess::setIdentification(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcProcess::hasLongDescription() const { return !data_->getArgument(6)->isNull(); } +std::string IfcProcess::LongDescription() const { return *data_->getArgument(6); } +void IfcProcess::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + +IfcRelSequence::list::ptr IfcProcess::IsPredecessorTo() const { return data_->getInverse(Type::IfcRelSequence, 4)->as(); } +IfcRelSequence::list::ptr IfcProcess::IsSuccessorFrom() const { return data_->getInverse(Type::IfcRelSequence, 5)->as(); } +IfcRelAssignsToProcess::list::ptr IfcProcess::OperatesOn() const { return data_->getInverse(Type::IfcRelAssignsToProcess, 6)->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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } 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 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); } -IfcExternalReferenceRelationship::list::ptr IfcProfileDef::HasExternalReference() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -IfcProfileProperties::list::ptr IfcProfileDef::HasProperties() const { return entity->getInverse(Type::IfcProfileProperties, 3)->as(); } -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); } + +IfcExternalReferenceRelationship::list::ptr IfcProfileDef::HasExternalReference() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } +IfcProfileProperties::list::ptr IfcProfileDef::HasProperties() const { return data_->getInverse(Type::IfcProfileProperties, 3)->as(); } + +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 -IfcProfileDef* IfcProfileProperties::ProfileDefinition() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcProfileProperties::setProfileDefinition(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcProfileProperties::is(Type::Enum v) const { return v == Type::IfcProfileProperties || IfcExtendedProperties::is(v); } -Type::Enum IfcProfileProperties::type() const { return Type::IfcProfileProperties; } +IfcProfileDef* IfcProfileProperties::ProfileDefinition() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcProfileProperties::setProfileDefinition(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcProfileProperties::declaration() const { return *IfcProfileProperties_type; } Type::Enum IfcProfileProperties::Class() { return Type::IfcProfileProperties; } -IfcProfileProperties::IfcProfileProperties(IfcAbstractEntity* e) : IfcExtendedProperties((IfcAbstractEntity*)0) { 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_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties, IfcProfileDef* v4_ProfileDefinition) : IfcExtendedProperties((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_Properties)->generalize()); e->setArgument(3,(v4_ProfileDefinition)); entity = e; EntityBuffer::Add(this); } +IfcProfileProperties::IfcProfileProperties(IfcAbstractEntity* e) : IfcExtendedProperties((IfcAbstractEntity*)0) { 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_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties, IfcProfileDef* v4_ProfileDefinition) : IfcExtendedProperties((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_Properties)->generalize()); e->setArgument(3,(v4_ProfileDefinition)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProject -bool IfcProject::is(Type::Enum v) const { return v == Type::IfcProject || IfcContext::is(v); } -Type::Enum IfcProject::type() const { return Type::IfcProject; } + + +const IfcParse::entity& IfcProject::declaration() const { return *IfcProject_type; } Type::Enum IfcProject::Class() { return Type::IfcProject; } -IfcProject::IfcProject(IfcAbstractEntity* e) : IfcContext((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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : IfcContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v8_RepresentationContexts) { e->setArgument(7,(*v8_RepresentationContexts)->generalize()); } else { e->setArgument(7); } e->setArgument(8,(v9_UnitsInContext)); entity = e; EntityBuffer::Add(this); } +IfcProject::IfcProject(IfcAbstractEntity* e) : IfcContext((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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : IfcContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v8_RepresentationContexts) { e->setArgument(7,(*v8_RepresentationContexts)->generalize()); } else { e->setArgument(7); } e->setArgument(8,(v9_UnitsInContext)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectLibrary -bool IfcProjectLibrary::is(Type::Enum v) const { return v == Type::IfcProjectLibrary || IfcContext::is(v); } -Type::Enum IfcProjectLibrary::type() const { return Type::IfcProjectLibrary; } + + +const IfcParse::entity& IfcProjectLibrary::declaration() const { return *IfcProjectLibrary_type; } Type::Enum IfcProjectLibrary::Class() { return Type::IfcProjectLibrary; } -IfcProjectLibrary::IfcProjectLibrary(IfcAbstractEntity* e) : IfcContext((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectLibrary)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProjectLibrary::IfcProjectLibrary(std::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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : IfcContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v8_RepresentationContexts) { e->setArgument(7,(*v8_RepresentationContexts)->generalize()); } else { e->setArgument(7); } e->setArgument(8,(v9_UnitsInContext)); entity = e; EntityBuffer::Add(this); } +IfcProjectLibrary::IfcProjectLibrary(IfcAbstractEntity* e) : IfcContext((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectLibrary)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProjectLibrary::IfcProjectLibrary(std::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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext) : IfcContext((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v8_RepresentationContexts) { e->setArgument(7,(*v8_RepresentationContexts)->generalize()); } else { e->setArgument(7); } e->setArgument(8,(v9_UnitsInContext)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectOrder -bool IfcProjectOrder::hasPredefinedType() const { return !entity->getArgument(6)->isNull(); } -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::hasLongDescription() const { return !entity->getArgument(8)->isNull(); } -std::string IfcProjectOrder::LongDescription() const { return *entity->getArgument(8); } -void IfcProjectOrder::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcProjectOrder::is(Type::Enum v) const { return v == Type::IfcProjectOrder || IfcControl::is(v); } -Type::Enum IfcProjectOrder::type() const { return Type::IfcProjectOrder; } +bool IfcProjectOrder::hasPredefinedType() const { return !data_->getArgument(6)->isNull(); } +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); } +bool IfcProjectOrder::hasLongDescription() const { return !data_->getArgument(8)->isNull(); } +std::string IfcProjectOrder::LongDescription() const { return *data_->getArgument(8); } +void IfcProjectOrder::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, boost::optional< std::string > v6_Identification, boost::optional< IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcProjectOrderTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_LongDescription) { e->setArgument(8,(*v9_LongDescription)); } else { e->setArgument(8); } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_PredefinedType) { e->setArgument(6,*v7_PredefinedType,IfcProjectOrderTypeEnum::ToString(*v7_PredefinedType)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_LongDescription) { e->setArgument(8,(*v9_LongDescription)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectedCRS -bool IfcProjectedCRS::hasMapProjection() const { return !entity->getArgument(4)->isNull(); } -std::string IfcProjectedCRS::MapProjection() const { return *entity->getArgument(4); } -void IfcProjectedCRS::setMapProjection(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcProjectedCRS::hasMapZone() const { return !entity->getArgument(5)->isNull(); } -std::string IfcProjectedCRS::MapZone() const { return *entity->getArgument(5); } -void IfcProjectedCRS::setMapZone(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcProjectedCRS::hasMapUnit() const { return !entity->getArgument(6)->isNull(); } -IfcNamedUnit* IfcProjectedCRS::MapUnit() const { return (IfcNamedUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcProjectedCRS::setMapUnit(IfcNamedUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcProjectedCRS::is(Type::Enum v) const { return v == Type::IfcProjectedCRS || IfcCoordinateReferenceSystem::is(v); } -Type::Enum IfcProjectedCRS::type() const { return Type::IfcProjectedCRS; } +bool IfcProjectedCRS::hasMapProjection() const { return !data_->getArgument(4)->isNull(); } +std::string IfcProjectedCRS::MapProjection() const { return *data_->getArgument(4); } +void IfcProjectedCRS::setMapProjection(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcProjectedCRS::hasMapZone() const { return !data_->getArgument(5)->isNull(); } +std::string IfcProjectedCRS::MapZone() const { return *data_->getArgument(5); } +void IfcProjectedCRS::setMapZone(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcProjectedCRS::hasMapUnit() const { return !data_->getArgument(6)->isNull(); } +IfcNamedUnit* IfcProjectedCRS::MapUnit() const { return (IfcNamedUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcProjectedCRS::setMapUnit(IfcNamedUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + + +const IfcParse::entity& IfcProjectedCRS::declaration() const { return *IfcProjectedCRS_type; } Type::Enum IfcProjectedCRS::Class() { return Type::IfcProjectedCRS; } -IfcProjectedCRS::IfcProjectedCRS(IfcAbstractEntity* e) : IfcCoordinateReferenceSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectedCRS)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProjectedCRS::IfcProjectedCRS(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, std::string v3_GeodeticDatum, boost::optional< std::string > v4_VerticalDatum, boost::optional< std::string > v5_MapProjection, boost::optional< std::string > v6_MapZone, IfcNamedUnit* v7_MapUnit) : IfcCoordinateReferenceSystem((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_GeodeticDatum)); if (v4_VerticalDatum) { e->setArgument(3,(*v4_VerticalDatum)); } else { e->setArgument(3); } if (v5_MapProjection) { e->setArgument(4,(*v5_MapProjection)); } else { e->setArgument(4); } if (v6_MapZone) { e->setArgument(5,(*v6_MapZone)); } else { e->setArgument(5); } e->setArgument(6,(v7_MapUnit)); entity = e; EntityBuffer::Add(this); } +IfcProjectedCRS::IfcProjectedCRS(IfcAbstractEntity* e) : IfcCoordinateReferenceSystem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProjectedCRS)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProjectedCRS::IfcProjectedCRS(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, std::string v3_GeodeticDatum, boost::optional< std::string > v4_VerticalDatum, boost::optional< std::string > v5_MapProjection, boost::optional< std::string > v6_MapZone, IfcNamedUnit* v7_MapUnit) : IfcCoordinateReferenceSystem((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_GeodeticDatum)); if (v4_VerticalDatum) { e->setArgument(3,(*v4_VerticalDatum)); } else { e->setArgument(3); } if (v5_MapProjection) { e->setArgument(4,(*v5_MapProjection)); } else { e->setArgument(4); } if (v6_MapZone) { e->setArgument(5,(*v6_MapZone)); } else { e->setArgument(5); } e->setArgument(6,(v7_MapUnit)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProjectionElement -bool IfcProjectionElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum IfcProjectionElement::PredefinedType() const { return IfcProjectionElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcProjectionElement::setPredefinedType(IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcProjectionElementTypeEnum::ToString(v)); } -bool IfcProjectionElement::is(Type::Enum v) const { return v == Type::IfcProjectionElement || IfcFeatureElementAddition::is(v); } -Type::Enum IfcProjectionElement::type() const { return Type::IfcProjectionElement; } +bool IfcProjectionElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum IfcProjectionElement::PredefinedType() const { return IfcProjectionElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcProjectionElement::setPredefinedType(IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcProjectionElementTypeEnum::ToString(v)); } + + +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, boost::optional< IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcProjectionElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcProjectionElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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); } -IfcPropertySet::list::ptr IfcProperty::PartOfPset() const { return entity->getInverse(Type::IfcPropertySet, 4)->as(); } -IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyForDependance() const { return entity->getInverse(Type::IfcPropertyDependencyRelationship, 2)->as(); } -IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyDependsOn() const { return entity->getInverse(Type::IfcPropertyDependencyRelationship, 3)->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 || IfcPropertyAbstraction::is(v); } -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); } + +IfcPropertySet::list::ptr IfcProperty::PartOfPset() const { return data_->getInverse(Type::IfcPropertySet, 4)->as(); } +IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyForDependance() const { return data_->getInverse(Type::IfcPropertyDependencyRelationship, 2)->as(); } +IfcPropertyDependencyRelationship::list::ptr IfcProperty::PropertyDependsOn() const { return data_->getInverse(Type::IfcPropertyDependencyRelationship, 3)->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) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { 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) : IfcPropertyAbstraction((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); } +IfcProperty::IfcProperty(IfcAbstractEntity* e) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { 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) : IfcPropertyAbstraction((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 IfcPropertyAbstraction -IfcExternalReferenceRelationship::list::ptr IfcPropertyAbstraction::HasExternalReferences() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } -bool IfcPropertyAbstraction::is(Type::Enum v) const { return v == Type::IfcPropertyAbstraction; } -Type::Enum IfcPropertyAbstraction::type() const { return Type::IfcPropertyAbstraction; } + +IfcExternalReferenceRelationship::list::ptr IfcPropertyAbstraction::HasExternalReferences() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->as(); } + +const IfcParse::entity& IfcPropertyAbstraction::declaration() const { return *IfcPropertyAbstraction_type; } Type::Enum IfcPropertyAbstraction::Class() { return Type::IfcPropertyAbstraction; } -IfcPropertyAbstraction::IfcPropertyAbstraction(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyAbstraction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyAbstraction::IfcPropertyAbstraction() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcPropertyAbstraction::IfcPropertyAbstraction(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcPropertyAbstraction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyAbstraction::IfcPropertyAbstraction() : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); 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::hasSetPointValue() const { return !entity->getArgument(5)->isNull(); } -IfcValue* IfcPropertyBoundedValue::SetPointValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcPropertyBoundedValue::setSetPointValue(IfcValue* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,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); } +bool IfcPropertyBoundedValue::hasSetPointValue() const { return !data_->getArgument(5)->isNull(); } +IfcValue* IfcPropertyBoundedValue::SetPointValue() const { return (IfcValue*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcPropertyBoundedValue::setSetPointValue(IfcValue* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,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, IfcValue* v6_SetPointValue) : 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)); e->setArgument(5,(v6_SetPointValue)); 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, IfcValue* v6_SetPointValue) : 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)); e->setArgument(5,(v6_SetPointValue)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyDefinition -IfcRelDeclares::list::ptr IfcPropertyDefinition::HasContext() const { return entity->getInverse(Type::IfcRelDeclares, 5)->as(); } -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; } + +IfcRelDeclares::list::ptr IfcPropertyDefinition::HasContext() const { return data_->getInverse(Type::IfcRelDeclares, 5)->as(); } +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(2))); } -void IfcPropertyDependencyRelationship::setDependingProperty(IfcProperty* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcProperty* IfcPropertyDependencyRelationship::DependantProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcPropertyDependencyRelationship::setDependantProperty(IfcProperty* 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 || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcPropertyDependencyRelationship::type() const { return Type::IfcPropertyDependencyRelationship; } +IfcProperty* IfcPropertyDependencyRelationship::DependingProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcPropertyDependencyRelationship::setDependingProperty(IfcProperty* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcProperty* IfcPropertyDependencyRelationship::DependantProperty() const { return (IfcProperty*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcPropertyDependencyRelationship::setDependantProperty(IfcProperty* 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) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyDependencyRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcProperty* v3_DependingProperty, IfcProperty* v4_DependantProperty, boost::optional< std::string > v5_Expression) : IfcResourceLevelRelationship((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_DependingProperty)); e->setArgument(3,(v4_DependantProperty)); if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyDependencyRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcProperty* v3_DependingProperty, IfcProperty* v4_DependantProperty, boost::optional< std::string > v5_Expression) : IfcResourceLevelRelationship((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_DependingProperty)); e->setArgument(3,(v4_DependantProperty)); if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyEnumeratedValue -bool IfcPropertyEnumeratedValue::hasEnumerationValues() const { return !entity->getArgument(2)->isNull(); } -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; } +bool IfcPropertyEnumeratedValue::hasEnumerationValues() const { return !data_->getArgument(2)->isNull(); } +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, boost::optional< 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); } if (v3_EnumerationValues) { e->setArgument(2,(*v3_EnumerationValues)); } else { e->setArgument(2); } 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, boost::optional< 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); } if (v3_EnumerationValues) { e->setArgument(2,(*v3_EnumerationValues)); } else { e->setArgument(2); } 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 || IfcPropertyAbstraction::is(v); } -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) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { 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) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { 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) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { 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) : IfcPropertyAbstraction((IfcAbstractEntity*)0) { 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 -bool IfcPropertyListValue::hasListValues() const { return !entity->getArgument(2)->isNull(); } -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; } +bool IfcPropertyListValue::hasListValues() const { return !data_->getArgument(2)->isNull(); } +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, boost::optional< 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); } if (v3_ListValues) { e->setArgument(2,(*v3_ListValues)); } else { e->setArgument(2); } 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, boost::optional< 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); } if (v3_ListValues) { e->setArgument(2,(*v3_ListValues)); } else { e->setArgument(2); } 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); } -bool IfcPropertyReferenceValue::hasPropertyReference() const { return !entity->getArgument(3)->isNull(); } -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); } +bool IfcPropertyReferenceValue::hasPropertyReference() const { return !data_->getArgument(3)->isNull(); } +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 -IfcTypeObject::list::ptr IfcPropertySetDefinition::DefinesType() const { return entity->getInverse(Type::IfcTypeObject, 5)->as(); } -IfcRelDefinesByTemplate::list::ptr IfcPropertySetDefinition::IsDefinedBy() const { return entity->getInverse(Type::IfcRelDefinesByTemplate, 4)->as(); } -IfcRelDefinesByProperties::list::ptr IfcPropertySetDefinition::DefinesOccurrence() const { return entity->getInverse(Type::IfcRelDefinesByProperties, 5)->as(); } -bool IfcPropertySetDefinition::is(Type::Enum v) const { return v == Type::IfcPropertySetDefinition || IfcPropertyDefinition::is(v); } -Type::Enum IfcPropertySetDefinition::type() const { return Type::IfcPropertySetDefinition; } + +IfcTypeObject::list::ptr IfcPropertySetDefinition::DefinesType() const { return data_->getInverse(Type::IfcTypeObject, 5)->as(); } +IfcRelDefinesByTemplate::list::ptr IfcPropertySetDefinition::IsDefinedBy() const { return data_->getInverse(Type::IfcRelDefinesByTemplate, 4)->as(); } +IfcRelDefinesByProperties::list::ptr IfcPropertySetDefinition::DefinesOccurrence() const { return data_->getInverse(Type::IfcRelDefinesByProperties, 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 IfcPropertySetTemplate -bool IfcPropertySetTemplate::hasTemplateType() const { return !entity->getArgument(4)->isNull(); } -IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum IfcPropertySetTemplate::TemplateType() const { return IfcPropertySetTemplateTypeEnum::FromString(*entity->getArgument(4)); } -void IfcPropertySetTemplate::setTemplateType(IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcPropertySetTemplateTypeEnum::ToString(v)); } -bool IfcPropertySetTemplate::hasApplicableEntity() const { return !entity->getArgument(5)->isNull(); } -std::string IfcPropertySetTemplate::ApplicableEntity() const { return *entity->getArgument(5); } -void IfcPropertySetTemplate::setApplicableEntity(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -IfcTemplatedEntityList< IfcPropertyTemplate >::ptr IfcPropertySetTemplate::HasPropertyTemplates() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcPropertySetTemplate::setHasPropertyTemplates(IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -IfcRelDefinesByTemplate::list::ptr IfcPropertySetTemplate::Defines() const { return entity->getInverse(Type::IfcRelDefinesByTemplate, 5)->as(); } -bool IfcPropertySetTemplate::is(Type::Enum v) const { return v == Type::IfcPropertySetTemplate || IfcPropertyTemplateDefinition::is(v); } -Type::Enum IfcPropertySetTemplate::type() const { return Type::IfcPropertySetTemplate; } +bool IfcPropertySetTemplate::hasTemplateType() const { return !data_->getArgument(4)->isNull(); } +IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum IfcPropertySetTemplate::TemplateType() const { return IfcPropertySetTemplateTypeEnum::FromString(*data_->getArgument(4)); } +void IfcPropertySetTemplate::setTemplateType(IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcPropertySetTemplateTypeEnum::ToString(v)); } +bool IfcPropertySetTemplate::hasApplicableEntity() const { return !data_->getArgument(5)->isNull(); } +std::string IfcPropertySetTemplate::ApplicableEntity() const { return *data_->getArgument(5); } +void IfcPropertySetTemplate::setApplicableEntity(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +IfcTemplatedEntityList< IfcPropertyTemplate >::ptr IfcPropertySetTemplate::HasPropertyTemplates() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcPropertySetTemplate::setHasPropertyTemplates(IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } + +IfcRelDefinesByTemplate::list::ptr IfcPropertySetTemplate::Defines() const { return data_->getInverse(Type::IfcRelDefinesByTemplate, 5)->as(); } + +const IfcParse::entity& IfcPropertySetTemplate::declaration() const { return *IfcPropertySetTemplate_type; } Type::Enum IfcPropertySetTemplate::Class() { return Type::IfcPropertySetTemplate; } -IfcPropertySetTemplate::IfcPropertySetTemplate(IfcAbstractEntity* e) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySetTemplate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertySetTemplate::IfcPropertySetTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum > v5_TemplateType, boost::optional< std::string > v6_ApplicableEntity, IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v7_HasPropertyTemplates) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_TemplateType) { e->setArgument(4,*v5_TemplateType,IfcPropertySetTemplateTypeEnum::ToString(*v5_TemplateType)); } else { e->setArgument(4); } if (v6_ApplicableEntity) { e->setArgument(5,(*v6_ApplicableEntity)); } else { e->setArgument(5); } e->setArgument(6,(v7_HasPropertyTemplates)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcPropertySetTemplate::IfcPropertySetTemplate(IfcAbstractEntity* e) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertySetTemplate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertySetTemplate::IfcPropertySetTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum > v5_TemplateType, boost::optional< std::string > v6_ApplicableEntity, IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v7_HasPropertyTemplates) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_TemplateType) { e->setArgument(4,*v5_TemplateType,IfcPropertySetTemplateTypeEnum::ToString(*v5_TemplateType)); } else { e->setArgument(4); } if (v6_ApplicableEntity) { e->setArgument(5,(*v6_ApplicableEntity)); } else { e->setArgument(5); } e->setArgument(6,(v7_HasPropertyTemplates)->generalize()); 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 -bool IfcPropertyTableValue::hasDefiningValues() const { return !entity->getArgument(2)->isNull(); } -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); } -bool IfcPropertyTableValue::hasDefinedValues() const { return !entity->getArgument(3)->isNull(); } -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::hasCurveInterpolation() const { return !entity->getArgument(7)->isNull(); } -IfcCurveInterpolationEnum::IfcCurveInterpolationEnum IfcPropertyTableValue::CurveInterpolation() const { return IfcCurveInterpolationEnum::FromString(*entity->getArgument(7)); } -void IfcPropertyTableValue::setCurveInterpolation(IfcCurveInterpolationEnum::IfcCurveInterpolationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcCurveInterpolationEnum::ToString(v)); } -bool IfcPropertyTableValue::is(Type::Enum v) const { return v == Type::IfcPropertyTableValue || IfcSimpleProperty::is(v); } -Type::Enum IfcPropertyTableValue::type() const { return Type::IfcPropertyTableValue; } +bool IfcPropertyTableValue::hasDefiningValues() const { return !data_->getArgument(2)->isNull(); } +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); } +bool IfcPropertyTableValue::hasDefinedValues() const { return !data_->getArgument(3)->isNull(); } +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); } +bool IfcPropertyTableValue::hasCurveInterpolation() const { return !data_->getArgument(7)->isNull(); } +IfcCurveInterpolationEnum::IfcCurveInterpolationEnum IfcPropertyTableValue::CurveInterpolation() const { return IfcCurveInterpolationEnum::FromString(*data_->getArgument(7)); } +void IfcPropertyTableValue::setCurveInterpolation(IfcCurveInterpolationEnum::IfcCurveInterpolationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcCurveInterpolationEnum::ToString(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, boost::optional< IfcEntityList::ptr > v3_DefiningValues, boost::optional< IfcEntityList::ptr > v4_DefinedValues, boost::optional< std::string > v5_Expression, IfcUnit* v6_DefiningUnit, IfcUnit* v7_DefinedUnit, boost::optional< IfcCurveInterpolationEnum::IfcCurveInterpolationEnum > v8_CurveInterpolation) : 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_DefiningValues) { e->setArgument(2,(*v3_DefiningValues)); } else { e->setArgument(2); } if (v4_DefinedValues) { e->setArgument(3,(*v4_DefinedValues)); } else { e->setArgument(3); } if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } e->setArgument(5,(v6_DefiningUnit)); e->setArgument(6,(v7_DefinedUnit)); if (v8_CurveInterpolation) { e->setArgument(7,*v8_CurveInterpolation,IfcCurveInterpolationEnum::ToString(*v8_CurveInterpolation)); } else { e->setArgument(7); } 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, boost::optional< IfcEntityList::ptr > v3_DefiningValues, boost::optional< IfcEntityList::ptr > v4_DefinedValues, boost::optional< std::string > v5_Expression, IfcUnit* v6_DefiningUnit, IfcUnit* v7_DefinedUnit, boost::optional< IfcCurveInterpolationEnum::IfcCurveInterpolationEnum > v8_CurveInterpolation) : 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_DefiningValues) { e->setArgument(2,(*v3_DefiningValues)); } else { e->setArgument(2); } if (v4_DefinedValues) { e->setArgument(3,(*v4_DefinedValues)); } else { e->setArgument(3); } if (v5_Expression) { e->setArgument(4,(*v5_Expression)); } else { e->setArgument(4); } e->setArgument(5,(v6_DefiningUnit)); e->setArgument(6,(v7_DefinedUnit)); if (v8_CurveInterpolation) { e->setArgument(7,*v8_CurveInterpolation,IfcCurveInterpolationEnum::ToString(*v8_CurveInterpolation)); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcPropertyTemplate -IfcComplexPropertyTemplate::list::ptr IfcPropertyTemplate::PartOfComplexTemplate() const { return entity->getInverse(Type::IfcComplexPropertyTemplate, 6)->as(); } -IfcPropertySetTemplate::list::ptr IfcPropertyTemplate::PartOfPsetTemplate() const { return entity->getInverse(Type::IfcPropertySetTemplate, 6)->as(); } -bool IfcPropertyTemplate::is(Type::Enum v) const { return v == Type::IfcPropertyTemplate || IfcPropertyTemplateDefinition::is(v); } -Type::Enum IfcPropertyTemplate::type() const { return Type::IfcPropertyTemplate; } + +IfcComplexPropertyTemplate::list::ptr IfcPropertyTemplate::PartOfComplexTemplate() const { return data_->getInverse(Type::IfcComplexPropertyTemplate, 6)->as(); } +IfcPropertySetTemplate::list::ptr IfcPropertyTemplate::PartOfPsetTemplate() const { return data_->getInverse(Type::IfcPropertySetTemplate, 6)->as(); } + +const IfcParse::entity& IfcPropertyTemplate::declaration() const { return *IfcPropertyTemplate_type; } Type::Enum IfcPropertyTemplate::Class() { return Type::IfcPropertyTemplate; } -IfcPropertyTemplate::IfcPropertyTemplate(IfcAbstractEntity* e) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyTemplate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyTemplate::IfcPropertyTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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); } +IfcPropertyTemplate::IfcPropertyTemplate(IfcAbstractEntity* e) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyTemplate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyTemplate::IfcPropertyTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : IfcPropertyTemplateDefinition((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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 IfcPropertyTemplateDefinition -bool IfcPropertyTemplateDefinition::is(Type::Enum v) const { return v == Type::IfcPropertyTemplateDefinition || IfcPropertyDefinition::is(v); } -Type::Enum IfcPropertyTemplateDefinition::type() const { return Type::IfcPropertyTemplateDefinition; } + + +const IfcParse::entity& IfcPropertyTemplateDefinition::declaration() const { return *IfcPropertyTemplateDefinition_type; } Type::Enum IfcPropertyTemplateDefinition::Class() { return Type::IfcPropertyTemplateDefinition; } -IfcPropertyTemplateDefinition::IfcPropertyTemplateDefinition(IfcAbstractEntity* e) : IfcPropertyDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyTemplateDefinition)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPropertyTemplateDefinition::IfcPropertyTemplateDefinition(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); } +IfcPropertyTemplateDefinition::IfcPropertyTemplateDefinition(IfcAbstractEntity* e) : IfcPropertyDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPropertyTemplateDefinition)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPropertyTemplateDefinition::IfcPropertyTemplateDefinition(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 IfcProtectiveDevice -bool IfcProtectiveDevice::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDevice::PredefinedType() const { return IfcProtectiveDeviceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcProtectiveDevice::setPredefinedType(IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcProtectiveDeviceTypeEnum::ToString(v)); } -bool IfcProtectiveDevice::is(Type::Enum v) const { return v == Type::IfcProtectiveDevice || IfcFlowController::is(v); } -Type::Enum IfcProtectiveDevice::type() const { return Type::IfcProtectiveDevice; } +bool IfcProtectiveDevice::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDevice::PredefinedType() const { return IfcProtectiveDeviceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcProtectiveDevice::setPredefinedType(IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcProtectiveDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcProtectiveDevice::declaration() const { return *IfcProtectiveDevice_type; } Type::Enum IfcProtectiveDevice::Class() { return Type::IfcProtectiveDevice; } -IfcProtectiveDevice::IfcProtectiveDevice(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProtectiveDevice::IfcProtectiveDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcProtectiveDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcProtectiveDevice::IfcProtectiveDevice(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProtectiveDevice::IfcProtectiveDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcProtectiveDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProtectiveDeviceTrippingUnit -bool IfcProtectiveDeviceTrippingUnit::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum IfcProtectiveDeviceTrippingUnit::PredefinedType() const { return IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(*entity->getArgument(8)); } -void IfcProtectiveDeviceTrippingUnit::setPredefinedType(IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(v)); } -bool IfcProtectiveDeviceTrippingUnit::is(Type::Enum v) const { return v == Type::IfcProtectiveDeviceTrippingUnit || IfcDistributionControlElement::is(v); } -Type::Enum IfcProtectiveDeviceTrippingUnit::type() const { return Type::IfcProtectiveDeviceTrippingUnit; } +bool IfcProtectiveDeviceTrippingUnit::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum IfcProtectiveDeviceTrippingUnit::PredefinedType() const { return IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(*data_->getArgument(8)); } +void IfcProtectiveDeviceTrippingUnit::setPredefinedType(IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcProtectiveDeviceTrippingUnit::declaration() const { return *IfcProtectiveDeviceTrippingUnit_type; } Type::Enum IfcProtectiveDeviceTrippingUnit::Class() { return Type::IfcProtectiveDeviceTrippingUnit; } -IfcProtectiveDeviceTrippingUnit::IfcProtectiveDeviceTrippingUnit(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDeviceTrippingUnit)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProtectiveDeviceTrippingUnit::IfcProtectiveDeviceTrippingUnit(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcProtectiveDeviceTrippingUnit::IfcProtectiveDeviceTrippingUnit(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDeviceTrippingUnit)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProtectiveDeviceTrippingUnit::IfcProtectiveDeviceTrippingUnit(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcProtectiveDeviceTrippingUnitType -IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum IfcProtectiveDeviceTrippingUnitType::PredefinedType() const { return IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(*entity->getArgument(9)); } -void IfcProtectiveDeviceTrippingUnitType::setPredefinedType(IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(v)); } -bool IfcProtectiveDeviceTrippingUnitType::is(Type::Enum v) const { return v == Type::IfcProtectiveDeviceTrippingUnitType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcProtectiveDeviceTrippingUnitType::type() const { return Type::IfcProtectiveDeviceTrippingUnitType; } +IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum IfcProtectiveDeviceTrippingUnitType::PredefinedType() const { return IfcProtectiveDeviceTrippingUnitTypeEnum::FromString(*data_->getArgument(9)); } +void IfcProtectiveDeviceTrippingUnitType::setPredefinedType(IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcProtectiveDeviceTrippingUnitType::declaration() const { return *IfcProtectiveDeviceTrippingUnitType_type; } Type::Enum IfcProtectiveDeviceTrippingUnitType::Class() { return Type::IfcProtectiveDeviceTrippingUnitType; } -IfcProtectiveDeviceTrippingUnitType::IfcProtectiveDeviceTrippingUnitType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDeviceTrippingUnitType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcProtectiveDeviceTrippingUnitType::IfcProtectiveDeviceTrippingUnitType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum 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,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcProtectiveDeviceTrippingUnitType::IfcProtectiveDeviceTrippingUnitType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcProtectiveDeviceTrippingUnitType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcProtectiveDeviceTrippingUnitType::IfcProtectiveDeviceTrippingUnitType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum 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,IfcProtectiveDeviceTrippingUnitTypeEnum::ToString(v10_PredefinedType)); 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 IfcPump -bool IfcPump::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcPumpTypeEnum::IfcPumpTypeEnum IfcPump::PredefinedType() const { return IfcPumpTypeEnum::FromString(*entity->getArgument(8)); } -void IfcPump::setPredefinedType(IfcPumpTypeEnum::IfcPumpTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcPumpTypeEnum::ToString(v)); } -bool IfcPump::is(Type::Enum v) const { return v == Type::IfcPump || IfcFlowMovingDevice::is(v); } -Type::Enum IfcPump::type() const { return Type::IfcPump; } +bool IfcPump::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcPumpTypeEnum::IfcPumpTypeEnum IfcPump::PredefinedType() const { return IfcPumpTypeEnum::FromString(*data_->getArgument(8)); } +void IfcPump::setPredefinedType(IfcPumpTypeEnum::IfcPumpTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcPumpTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcPump::declaration() const { return *IfcPump_type; } Type::Enum IfcPump::Class() { return Type::IfcPump; } -IfcPump::IfcPump(IfcAbstractEntity* e) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPump)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcPump::IfcPump(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPumpTypeEnum::IfcPumpTypeEnum > v9_PredefinedType) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPumpTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcPump::IfcPump(IfcAbstractEntity* e) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcPump)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcPump::IfcPump(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPumpTypeEnum::IfcPumpTypeEnum > v9_PredefinedType) : IfcFlowMovingDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcPumpTypeEnum::ToString(*v9_PredefinedType)); } 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::hasFormula() const { return !entity->getArgument(4)->isNull(); } -std::string IfcQuantityArea::Formula() const { return *entity->getArgument(4); } -void IfcQuantityArea::setFormula(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcQuantityArea::hasFormula() const { return !data_->getArgument(4)->isNull(); } +std::string IfcQuantityArea::Formula() const { return *data_->getArgument(4); } +void IfcQuantityArea::setFormula(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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::hasFormula() const { return !entity->getArgument(4)->isNull(); } -std::string IfcQuantityCount::Formula() const { return *entity->getArgument(4); } -void IfcQuantityCount::setFormula(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcQuantityCount::hasFormula() const { return !data_->getArgument(4)->isNull(); } +std::string IfcQuantityCount::Formula() const { return *data_->getArgument(4); } +void IfcQuantityCount::setFormula(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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::hasFormula() const { return !entity->getArgument(4)->isNull(); } -std::string IfcQuantityLength::Formula() const { return *entity->getArgument(4); } -void IfcQuantityLength::setFormula(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcQuantityLength::hasFormula() const { return !data_->getArgument(4)->isNull(); } +std::string IfcQuantityLength::Formula() const { return *data_->getArgument(4); } +void IfcQuantityLength::setFormula(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcQuantitySet -bool IfcQuantitySet::is(Type::Enum v) const { return v == Type::IfcQuantitySet || IfcPropertySetDefinition::is(v); } -Type::Enum IfcQuantitySet::type() const { return Type::IfcQuantitySet; } + + +const IfcParse::entity& IfcQuantitySet::declaration() const { return *IfcQuantitySet_type; } Type::Enum IfcQuantitySet::Class() { return Type::IfcQuantitySet; } -IfcQuantitySet::IfcQuantitySet(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantitySet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcQuantitySet::IfcQuantitySet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : 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); } entity = e; EntityBuffer::Add(this); } +IfcQuantitySet::IfcQuantitySet(IfcAbstractEntity* e) : IfcPropertySetDefinition((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcQuantitySet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcQuantitySet::IfcQuantitySet(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description) : 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); } 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::hasFormula() const { return !entity->getArgument(4)->isNull(); } -std::string IfcQuantityTime::Formula() const { return *entity->getArgument(4); } -void IfcQuantityTime::setFormula(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcQuantityTime::hasFormula() const { return !data_->getArgument(4)->isNull(); } +std::string IfcQuantityTime::Formula() const { return *data_->getArgument(4); } +void IfcQuantityTime::setFormula(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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::hasFormula() const { return !entity->getArgument(4)->isNull(); } -std::string IfcQuantityVolume::Formula() const { return *entity->getArgument(4); } -void IfcQuantityVolume::setFormula(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcQuantityVolume::hasFormula() const { return !data_->getArgument(4)->isNull(); } +std::string IfcQuantityVolume::Formula() const { return *data_->getArgument(4); } +void IfcQuantityVolume::setFormula(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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::hasFormula() const { return !entity->getArgument(4)->isNull(); } -std::string IfcQuantityWeight::Formula() const { return *entity->getArgument(4); } -void IfcQuantityWeight::setFormula(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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); } +bool IfcQuantityWeight::hasFormula() const { return !data_->getArgument(4)->isNull(); } +std::string IfcQuantityWeight::Formula() const { return *data_->getArgument(4); } +void IfcQuantityWeight::setFormula(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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, boost::optional< std::string > v5_Formula) : 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)); if (v5_Formula) { e->setArgument(4,(*v5_Formula)); } else { e->setArgument(4); } 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 -bool IfcRamp::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcRampTypeEnum::IfcRampTypeEnum IfcRamp::PredefinedType() const { return IfcRampTypeEnum::FromString(*entity->getArgument(8)); } -void IfcRamp::setPredefinedType(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; } +bool IfcRamp::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcRampTypeEnum::IfcRampTypeEnum IfcRamp::PredefinedType() const { return IfcRampTypeEnum::FromString(*data_->getArgument(8)); } +void IfcRamp::setPredefinedType(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, boost::optional< IfcRampTypeEnum::IfcRampTypeEnum > 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,IfcRampTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcRampTypeEnum::IfcRampTypeEnum > 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,IfcRampTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRampFlight -bool IfcRampFlight::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlight::PredefinedType() const { return IfcRampFlightTypeEnum::FromString(*entity->getArgument(8)); } -void IfcRampFlight::setPredefinedType(IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcRampFlightTypeEnum::ToString(v)); } -bool IfcRampFlight::is(Type::Enum v) const { return v == Type::IfcRampFlight || IfcBuildingElement::is(v); } -Type::Enum IfcRampFlight::type() const { return Type::IfcRampFlight; } +bool IfcRampFlight::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlight::PredefinedType() const { return IfcRampFlightTypeEnum::FromString(*data_->getArgument(8)); } +void IfcRampFlight::setPredefinedType(IfcRampFlightTypeEnum::IfcRampFlightTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcRampFlightTypeEnum::ToString(v)); } + + +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, boost::optional< IfcRampFlightTypeEnum::IfcRampFlightTypeEnum > 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,IfcRampFlightTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcRampFlightTypeEnum::IfcRampFlightTypeEnum > 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,IfcRampFlightTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcRampType -IfcRampTypeEnum::IfcRampTypeEnum IfcRampType::PredefinedType() const { return IfcRampTypeEnum::FromString(*entity->getArgument(9)); } -void IfcRampType::setPredefinedType(IfcRampTypeEnum::IfcRampTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcRampTypeEnum::ToString(v)); } -bool IfcRampType::is(Type::Enum v) const { return v == Type::IfcRampType || IfcBuildingElementType::is(v); } -Type::Enum IfcRampType::type() const { return Type::IfcRampType; } +IfcRampTypeEnum::IfcRampTypeEnum IfcRampType::PredefinedType() const { return IfcRampTypeEnum::FromString(*data_->getArgument(9)); } +void IfcRampType::setPredefinedType(IfcRampTypeEnum::IfcRampTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcRampTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRampType::declaration() const { return *IfcRampType_type; } Type::Enum IfcRampType::Class() { return Type::IfcRampType; } -IfcRampType::IfcRampType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRampType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRampType::IfcRampType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRampTypeEnum::IfcRampTypeEnum 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,IfcRampTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcRampType::IfcRampType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRampType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRampType::IfcRampType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRampTypeEnum::IfcRampTypeEnum 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,IfcRampTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRationalBSplineCurveWithKnots -std::vector< double > /*[2:?]*/ IfcRationalBSplineCurveWithKnots::WeightsData() const { return *entity->getArgument(8); } -void IfcRationalBSplineCurveWithKnots::setWeightsData(std::vector< double > /*[2:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcRationalBSplineCurveWithKnots::is(Type::Enum v) const { return v == Type::IfcRationalBSplineCurveWithKnots || IfcBSplineCurveWithKnots::is(v); } -Type::Enum IfcRationalBSplineCurveWithKnots::type() const { return Type::IfcRationalBSplineCurveWithKnots; } +std::vector< double > /*[2:?]*/ IfcRationalBSplineCurveWithKnots::WeightsData() const { return *data_->getArgument(8); } +void IfcRationalBSplineCurveWithKnots::setWeightsData(std::vector< double > /*[2:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcRationalBSplineCurveWithKnots::declaration() const { return *IfcRationalBSplineCurveWithKnots_type; } Type::Enum IfcRationalBSplineCurveWithKnots::Class() { return Type::IfcRationalBSplineCurveWithKnots; } -IfcRationalBSplineCurveWithKnots::IfcRationalBSplineCurveWithKnots(IfcAbstractEntity* e) : IfcBSplineCurveWithKnots((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBSplineCurveWithKnots)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRationalBSplineCurveWithKnots::IfcRationalBSplineCurveWithKnots(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec, std::vector< double > /*[2:?]*/ v9_WeightsData) : IfcBSplineCurveWithKnots((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_KnotMultiplicities)); e->setArgument(6,(v7_Knots)); e->setArgument(7,v8_KnotSpec,IfcKnotType::ToString(v8_KnotSpec)); e->setArgument(8,(v9_WeightsData)); entity = e; EntityBuffer::Add(this); } +IfcRationalBSplineCurveWithKnots::IfcRationalBSplineCurveWithKnots(IfcAbstractEntity* e) : IfcBSplineCurveWithKnots((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBSplineCurveWithKnots)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRationalBSplineCurveWithKnots::IfcRationalBSplineCurveWithKnots(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec, std::vector< double > /*[2:?]*/ v9_WeightsData) : IfcBSplineCurveWithKnots((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_KnotMultiplicities)); e->setArgument(6,(v7_Knots)); e->setArgument(7,v8_KnotSpec,IfcKnotType::ToString(v8_KnotSpec)); e->setArgument(8,(v9_WeightsData)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRationalBSplineSurfaceWithKnots -std::vector< std::vector< double > > IfcRationalBSplineSurfaceWithKnots::WeightsData() const { return *entity->getArgument(12); } -void IfcRationalBSplineSurfaceWithKnots::setWeightsData(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcRationalBSplineSurfaceWithKnots::is(Type::Enum v) const { return v == Type::IfcRationalBSplineSurfaceWithKnots || IfcBSplineSurfaceWithKnots::is(v); } -Type::Enum IfcRationalBSplineSurfaceWithKnots::type() const { return Type::IfcRationalBSplineSurfaceWithKnots; } +std::vector< std::vector< double > > IfcRationalBSplineSurfaceWithKnots::WeightsData() const { return *data_->getArgument(12); } +void IfcRationalBSplineSurfaceWithKnots::setWeightsData(std::vector< std::vector< double > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcRationalBSplineSurfaceWithKnots::declaration() const { return *IfcRationalBSplineSurfaceWithKnots_type; } Type::Enum IfcRationalBSplineSurfaceWithKnots::Class() { return Type::IfcRationalBSplineSurfaceWithKnots; } -IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(IfcAbstractEntity* e) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBSplineSurfaceWithKnots)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec, std::vector< std::vector< double > > v13_WeightsData) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); e->setArgument(7,(v8_UMultiplicities)); e->setArgument(8,(v9_VMultiplicities)); e->setArgument(9,(v10_UKnots)); e->setArgument(10,(v11_VKnots)); e->setArgument(11,v12_KnotSpec,IfcKnotType::ToString(v12_KnotSpec)); e->setArgument(12,(v13_WeightsData)); entity = e; EntityBuffer::Add(this); } +IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(IfcAbstractEntity* e) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBSplineSurfaceWithKnots)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec, std::vector< std::vector< double > > v13_WeightsData) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); e->setArgument(7,(v8_UMultiplicities)); e->setArgument(8,(v9_VMultiplicities)); e->setArgument(9,(v10_UKnots)); e->setArgument(10,(v11_VKnots)); e->setArgument(11,v12_KnotSpec,IfcKnotType::ToString(v12_KnotSpec)); e->setArgument(12,(v13_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 IfcRecurrencePattern -IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum IfcRecurrencePattern::RecurrenceType() const { return IfcRecurrenceTypeEnum::FromString(*entity->getArgument(0)); } -void IfcRecurrencePattern::setRecurrenceType(IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v,IfcRecurrenceTypeEnum::ToString(v)); } -bool IfcRecurrencePattern::hasDayComponent() const { return !entity->getArgument(1)->isNull(); } -std::vector< int > /*[1:?]*/ IfcRecurrencePattern::DayComponent() const { return *entity->getArgument(1); } -void IfcRecurrencePattern::setDayComponent(std::vector< int > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcRecurrencePattern::hasWeekdayComponent() const { return !entity->getArgument(2)->isNull(); } -std::vector< int > /*[1:?]*/ IfcRecurrencePattern::WeekdayComponent() const { return *entity->getArgument(2); } -void IfcRecurrencePattern::setWeekdayComponent(std::vector< int > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcRecurrencePattern::hasMonthComponent() const { return !entity->getArgument(3)->isNull(); } -std::vector< int > /*[1:?]*/ IfcRecurrencePattern::MonthComponent() const { return *entity->getArgument(3); } -void IfcRecurrencePattern::setMonthComponent(std::vector< int > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcRecurrencePattern::hasPosition() const { return !entity->getArgument(4)->isNull(); } -int IfcRecurrencePattern::Position() const { return *entity->getArgument(4); } -void IfcRecurrencePattern::setPosition(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRecurrencePattern::hasInterval() const { return !entity->getArgument(5)->isNull(); } -int IfcRecurrencePattern::Interval() const { return *entity->getArgument(5); } -void IfcRecurrencePattern::setInterval(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRecurrencePattern::hasOccurrences() const { return !entity->getArgument(6)->isNull(); } -int IfcRecurrencePattern::Occurrences() const { return *entity->getArgument(6); } -void IfcRecurrencePattern::setOccurrences(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRecurrencePattern::hasTimePeriods() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcTimePeriod >::ptr IfcRecurrencePattern::TimePeriods() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcRecurrencePattern::setTimePeriods(IfcTemplatedEntityList< IfcTimePeriod >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcRecurrencePattern::is(Type::Enum v) const { return v == Type::IfcRecurrencePattern; } -Type::Enum IfcRecurrencePattern::type() const { return Type::IfcRecurrencePattern; } +IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum IfcRecurrencePattern::RecurrenceType() const { return IfcRecurrenceTypeEnum::FromString(*data_->getArgument(0)); } +void IfcRecurrencePattern::setRecurrenceType(IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v,IfcRecurrenceTypeEnum::ToString(v)); } +bool IfcRecurrencePattern::hasDayComponent() const { return !data_->getArgument(1)->isNull(); } +std::vector< int > /*[1:?]*/ IfcRecurrencePattern::DayComponent() const { return *data_->getArgument(1); } +void IfcRecurrencePattern::setDayComponent(std::vector< int > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcRecurrencePattern::hasWeekdayComponent() const { return !data_->getArgument(2)->isNull(); } +std::vector< int > /*[1:?]*/ IfcRecurrencePattern::WeekdayComponent() const { return *data_->getArgument(2); } +void IfcRecurrencePattern::setWeekdayComponent(std::vector< int > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcRecurrencePattern::hasMonthComponent() const { return !data_->getArgument(3)->isNull(); } +std::vector< int > /*[1:?]*/ IfcRecurrencePattern::MonthComponent() const { return *data_->getArgument(3); } +void IfcRecurrencePattern::setMonthComponent(std::vector< int > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcRecurrencePattern::hasPosition() const { return !data_->getArgument(4)->isNull(); } +int IfcRecurrencePattern::Position() const { return *data_->getArgument(4); } +void IfcRecurrencePattern::setPosition(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcRecurrencePattern::hasInterval() const { return !data_->getArgument(5)->isNull(); } +int IfcRecurrencePattern::Interval() const { return *data_->getArgument(5); } +void IfcRecurrencePattern::setInterval(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRecurrencePattern::hasOccurrences() const { return !data_->getArgument(6)->isNull(); } +int IfcRecurrencePattern::Occurrences() const { return *data_->getArgument(6); } +void IfcRecurrencePattern::setOccurrences(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRecurrencePattern::hasTimePeriods() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcTimePeriod >::ptr IfcRecurrencePattern::TimePeriods() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcRecurrencePattern::setTimePeriods(IfcTemplatedEntityList< IfcTimePeriod >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } + + +const IfcParse::entity& IfcRecurrencePattern::declaration() const { return *IfcRecurrencePattern_type; } Type::Enum IfcRecurrencePattern::Class() { return Type::IfcRecurrencePattern; } -IfcRecurrencePattern::IfcRecurrencePattern(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRecurrencePattern)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRecurrencePattern::IfcRecurrencePattern(IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum v1_RecurrenceType, boost::optional< std::vector< int > /*[1:?]*/ > v2_DayComponent, boost::optional< std::vector< int > /*[1:?]*/ > v3_WeekdayComponent, boost::optional< std::vector< int > /*[1:?]*/ > v4_MonthComponent, boost::optional< int > v5_Position, boost::optional< int > v6_Interval, boost::optional< int > v7_Occurrences, boost::optional< IfcTemplatedEntityList< IfcTimePeriod >::ptr > v8_TimePeriods) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_RecurrenceType,IfcRecurrenceTypeEnum::ToString(v1_RecurrenceType)); if (v2_DayComponent) { e->setArgument(1,(*v2_DayComponent)); } else { e->setArgument(1); } if (v3_WeekdayComponent) { e->setArgument(2,(*v3_WeekdayComponent)); } else { e->setArgument(2); } if (v4_MonthComponent) { e->setArgument(3,(*v4_MonthComponent)); } else { e->setArgument(3); } if (v5_Position) { e->setArgument(4,(*v5_Position)); } else { e->setArgument(4); } if (v6_Interval) { e->setArgument(5,(*v6_Interval)); } else { e->setArgument(5); } if (v7_Occurrences) { e->setArgument(6,(*v7_Occurrences)); } else { e->setArgument(6); } if (v8_TimePeriods) { e->setArgument(7,(*v8_TimePeriods)->generalize()); } else { e->setArgument(7); } entity = e; EntityBuffer::Add(this); } +IfcRecurrencePattern::IfcRecurrencePattern(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcRecurrencePattern)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRecurrencePattern::IfcRecurrencePattern(IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum v1_RecurrenceType, boost::optional< std::vector< int > /*[1:?]*/ > v2_DayComponent, boost::optional< std::vector< int > /*[1:?]*/ > v3_WeekdayComponent, boost::optional< std::vector< int > /*[1:?]*/ > v4_MonthComponent, boost::optional< int > v5_Position, boost::optional< int > v6_Interval, boost::optional< int > v7_Occurrences, boost::optional< IfcTemplatedEntityList< IfcTimePeriod >::ptr > v8_TimePeriods) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_RecurrenceType,IfcRecurrenceTypeEnum::ToString(v1_RecurrenceType)); if (v2_DayComponent) { e->setArgument(1,(*v2_DayComponent)); } else { e->setArgument(1); } if (v3_WeekdayComponent) { e->setArgument(2,(*v3_WeekdayComponent)); } else { e->setArgument(2); } if (v4_MonthComponent) { e->setArgument(3,(*v4_MonthComponent)); } else { e->setArgument(3); } if (v5_Position) { e->setArgument(4,(*v5_Position)); } else { e->setArgument(4); } if (v6_Interval) { e->setArgument(5,(*v6_Interval)); } else { e->setArgument(5); } if (v7_Occurrences) { e->setArgument(6,(*v7_Occurrences)); } else { e->setArgument(6); } if (v8_TimePeriods) { e->setArgument(7,(*v8_TimePeriods)->generalize()); } else { e->setArgument(7); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReference -bool IfcReference::hasTypeIdentifier() const { return !entity->getArgument(0)->isNull(); } -std::string IfcReference::TypeIdentifier() const { return *entity->getArgument(0); } -void IfcReference::setTypeIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcReference::hasAttributeIdentifier() const { return !entity->getArgument(1)->isNull(); } -std::string IfcReference::AttributeIdentifier() const { return *entity->getArgument(1); } -void IfcReference::setAttributeIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcReference::hasInstanceName() const { return !entity->getArgument(2)->isNull(); } -std::string IfcReference::InstanceName() const { return *entity->getArgument(2); } -void IfcReference::setInstanceName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcReference::hasListPositions() const { return !entity->getArgument(3)->isNull(); } -std::vector< int > /*[1:?]*/ IfcReference::ListPositions() const { return *entity->getArgument(3); } -void IfcReference::setListPositions(std::vector< int > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcReference::hasInnerReference() const { return !entity->getArgument(4)->isNull(); } -IfcReference* IfcReference::InnerReference() const { return (IfcReference*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcReference::setInnerReference(IfcReference* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcReference::is(Type::Enum v) const { return v == Type::IfcReference; } -Type::Enum IfcReference::type() const { return Type::IfcReference; } +bool IfcReference::hasTypeIdentifier() const { return !data_->getArgument(0)->isNull(); } +std::string IfcReference::TypeIdentifier() const { return *data_->getArgument(0); } +void IfcReference::setTypeIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcReference::hasAttributeIdentifier() const { return !data_->getArgument(1)->isNull(); } +std::string IfcReference::AttributeIdentifier() const { return *data_->getArgument(1); } +void IfcReference::setAttributeIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcReference::hasInstanceName() const { return !data_->getArgument(2)->isNull(); } +std::string IfcReference::InstanceName() const { return *data_->getArgument(2); } +void IfcReference::setInstanceName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcReference::hasListPositions() const { return !data_->getArgument(3)->isNull(); } +std::vector< int > /*[1:?]*/ IfcReference::ListPositions() const { return *data_->getArgument(3); } +void IfcReference::setListPositions(std::vector< int > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcReference::hasInnerReference() const { return !data_->getArgument(4)->isNull(); } +IfcReference* IfcReference::InnerReference() const { return (IfcReference*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcReference::setInnerReference(IfcReference* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcReference::declaration() const { return *IfcReference_type; } Type::Enum IfcReference::Class() { return Type::IfcReference; } -IfcReference::IfcReference(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcReference)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReference::IfcReference(boost::optional< std::string > v1_TypeIdentifier, boost::optional< std::string > v2_AttributeIdentifier, boost::optional< std::string > v3_InstanceName, boost::optional< std::vector< int > /*[1:?]*/ > v4_ListPositions, IfcReference* v5_InnerReference) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_TypeIdentifier) { e->setArgument(0,(*v1_TypeIdentifier)); } else { e->setArgument(0); } if (v2_AttributeIdentifier) { e->setArgument(1,(*v2_AttributeIdentifier)); } else { e->setArgument(1); } if (v3_InstanceName) { e->setArgument(2,(*v3_InstanceName)); } else { e->setArgument(2); } if (v4_ListPositions) { e->setArgument(3,(*v4_ListPositions)); } else { e->setArgument(3); } e->setArgument(4,(v5_InnerReference)); entity = e; EntityBuffer::Add(this); } +IfcReference::IfcReference(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcReference)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReference::IfcReference(boost::optional< std::string > v1_TypeIdentifier, boost::optional< std::string > v2_AttributeIdentifier, boost::optional< std::string > v3_InstanceName, boost::optional< std::vector< int > /*[1:?]*/ > v4_ListPositions, IfcReference* v5_InnerReference) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_TypeIdentifier) { e->setArgument(0,(*v1_TypeIdentifier)); } else { e->setArgument(0); } if (v2_AttributeIdentifier) { e->setArgument(1,(*v2_AttributeIdentifier)); } else { e->setArgument(1); } if (v3_InstanceName) { e->setArgument(2,(*v3_InstanceName)); } else { e->setArgument(2); } if (v4_ListPositions) { e->setArgument(3,(*v4_ListPositions)); } else { e->setArgument(3); } e->setArgument(4,(v5_InnerReference)); 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, std::string v3_StartTime, std::string 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, std::string v3_StartTime, std::string 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 || IfcPreDefinedProperties::is(v); } -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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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 || IfcPreDefinedPropertySet::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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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 -bool IfcReinforcingBar::hasNominalDiameter() const { return !entity->getArgument(9)->isNull(); } -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); } -bool IfcReinforcingBar::hasCrossSectionArea() const { return !entity->getArgument(10)->isNull(); } -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); } -bool IfcReinforcingBar::hasPredefinedType() const { return !entity->getArgument(12)->isNull(); } -IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum IfcReinforcingBar::PredefinedType() const { return IfcReinforcingBarTypeEnum::FromString(*entity->getArgument(12)); } -void IfcReinforcingBar::setPredefinedType(IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v,IfcReinforcingBarTypeEnum::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; } +bool IfcReinforcingBar::hasNominalDiameter() const { return !data_->getArgument(9)->isNull(); } +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); } +bool IfcReinforcingBar::hasCrossSectionArea() const { return !data_->getArgument(10)->isNull(); } +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); } +bool IfcReinforcingBar::hasPredefinedType() const { return !data_->getArgument(12)->isNull(); } +IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum IfcReinforcingBar::PredefinedType() const { return IfcReinforcingBarTypeEnum::FromString(*data_->getArgument(12)); } +void IfcReinforcingBar::setPredefinedType(IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v,IfcReinforcingBarTypeEnum::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, boost::optional< double > v10_NominalDiameter, boost::optional< double > v11_CrossSectionArea, boost::optional< double > v12_BarLength, boost::optional< IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum > v13_PredefinedType, 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); } if (v10_NominalDiameter) { e->setArgument(9,(*v10_NominalDiameter)); } else { e->setArgument(9); } if (v11_CrossSectionArea) { e->setArgument(10,(*v11_CrossSectionArea)); } else { e->setArgument(10); } if (v12_BarLength) { e->setArgument(11,(*v12_BarLength)); } else { e->setArgument(11); } if (v13_PredefinedType) { e->setArgument(12,*v13_PredefinedType,IfcReinforcingBarTypeEnum::ToString(*v13_PredefinedType)); } else { e->setArgument(12); } 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, boost::optional< double > v10_NominalDiameter, boost::optional< double > v11_CrossSectionArea, boost::optional< double > v12_BarLength, boost::optional< IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum > v13_PredefinedType, 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); } if (v10_NominalDiameter) { e->setArgument(9,(*v10_NominalDiameter)); } else { e->setArgument(9); } if (v11_CrossSectionArea) { e->setArgument(10,(*v11_CrossSectionArea)); } else { e->setArgument(10); } if (v12_BarLength) { e->setArgument(11,(*v12_BarLength)); } else { e->setArgument(11); } if (v13_PredefinedType) { e->setArgument(12,*v13_PredefinedType,IfcReinforcingBarTypeEnum::ToString(*v13_PredefinedType)); } else { e->setArgument(12); } if (v14_BarSurface) { e->setArgument(13,*v14_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v14_BarSurface)); } else { e->setArgument(13); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcingBarType -IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum IfcReinforcingBarType::PredefinedType() const { return IfcReinforcingBarTypeEnum::FromString(*entity->getArgument(9)); } -void IfcReinforcingBarType::setPredefinedType(IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcReinforcingBarTypeEnum::ToString(v)); } -bool IfcReinforcingBarType::hasNominalDiameter() const { return !entity->getArgument(10)->isNull(); } -double IfcReinforcingBarType::NominalDiameter() const { return *entity->getArgument(10); } -void IfcReinforcingBarType::setNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcReinforcingBarType::hasCrossSectionArea() const { return !entity->getArgument(11)->isNull(); } -double IfcReinforcingBarType::CrossSectionArea() const { return *entity->getArgument(11); } -void IfcReinforcingBarType::setCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcReinforcingBarType::hasBarLength() const { return !entity->getArgument(12)->isNull(); } -double IfcReinforcingBarType::BarLength() const { return *entity->getArgument(12); } -void IfcReinforcingBarType::setBarLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcReinforcingBarType::hasBarSurface() const { return !entity->getArgument(13)->isNull(); } -IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBarType::BarSurface() const { return IfcReinforcingBarSurfaceEnum::FromString(*entity->getArgument(13)); } -void IfcReinforcingBarType::setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v,IfcReinforcingBarSurfaceEnum::ToString(v)); } -bool IfcReinforcingBarType::hasBendingShapeCode() const { return !entity->getArgument(14)->isNull(); } -std::string IfcReinforcingBarType::BendingShapeCode() const { return *entity->getArgument(14); } -void IfcReinforcingBarType::setBendingShapeCode(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcReinforcingBarType::hasBendingParameters() const { return !entity->getArgument(15)->isNull(); } -IfcEntityList::ptr IfcReinforcingBarType::BendingParameters() const { return *entity->getArgument(15); } -void IfcReinforcingBarType::setBendingParameters(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcReinforcingBarType::is(Type::Enum v) const { return v == Type::IfcReinforcingBarType || IfcReinforcingElementType::is(v); } -Type::Enum IfcReinforcingBarType::type() const { return Type::IfcReinforcingBarType; } +IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum IfcReinforcingBarType::PredefinedType() const { return IfcReinforcingBarTypeEnum::FromString(*data_->getArgument(9)); } +void IfcReinforcingBarType::setPredefinedType(IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcReinforcingBarTypeEnum::ToString(v)); } +bool IfcReinforcingBarType::hasNominalDiameter() const { return !data_->getArgument(10)->isNull(); } +double IfcReinforcingBarType::NominalDiameter() const { return *data_->getArgument(10); } +void IfcReinforcingBarType::setNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcReinforcingBarType::hasCrossSectionArea() const { return !data_->getArgument(11)->isNull(); } +double IfcReinforcingBarType::CrossSectionArea() const { return *data_->getArgument(11); } +void IfcReinforcingBarType::setCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcReinforcingBarType::hasBarLength() const { return !data_->getArgument(12)->isNull(); } +double IfcReinforcingBarType::BarLength() const { return *data_->getArgument(12); } +void IfcReinforcingBarType::setBarLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcReinforcingBarType::hasBarSurface() const { return !data_->getArgument(13)->isNull(); } +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBarType::BarSurface() const { return IfcReinforcingBarSurfaceEnum::FromString(*data_->getArgument(13)); } +void IfcReinforcingBarType::setBarSurface(IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v,IfcReinforcingBarSurfaceEnum::ToString(v)); } +bool IfcReinforcingBarType::hasBendingShapeCode() const { return !data_->getArgument(14)->isNull(); } +std::string IfcReinforcingBarType::BendingShapeCode() const { return *data_->getArgument(14); } +void IfcReinforcingBarType::setBendingShapeCode(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcReinforcingBarType::hasBendingParameters() const { return !data_->getArgument(15)->isNull(); } +IfcEntityList::ptr IfcReinforcingBarType::BendingParameters() const { return *data_->getArgument(15); } +void IfcReinforcingBarType::setBendingParameters(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } + + +const IfcParse::entity& IfcReinforcingBarType::declaration() const { return *IfcReinforcingBarType_type; } Type::Enum IfcReinforcingBarType::Class() { return Type::IfcReinforcingBarType; } -IfcReinforcingBarType::IfcReinforcingBarType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingBarType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcingBarType::IfcReinforcingBarType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_CrossSectionArea, boost::optional< double > v13_BarLength, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface, boost::optional< std::string > v15_BendingShapeCode, boost::optional< IfcEntityList::ptr > v16_BendingParameters) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcReinforcingBarTypeEnum::ToString(v10_PredefinedType)); if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_CrossSectionArea) { e->setArgument(11,(*v12_CrossSectionArea)); } else { e->setArgument(11); } if (v13_BarLength) { e->setArgument(12,(*v13_BarLength)); } else { e->setArgument(12); } if (v14_BarSurface) { e->setArgument(13,*v14_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v14_BarSurface)); } else { e->setArgument(13); } if (v15_BendingShapeCode) { e->setArgument(14,(*v15_BendingShapeCode)); } else { e->setArgument(14); } if (v16_BendingParameters) { e->setArgument(15,(*v16_BendingParameters)); } else { e->setArgument(15); } entity = e; EntityBuffer::Add(this); } +IfcReinforcingBarType::IfcReinforcingBarType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingBarType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcingBarType::IfcReinforcingBarType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_CrossSectionArea, boost::optional< double > v13_BarLength, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface, boost::optional< std::string > v15_BendingShapeCode, boost::optional< IfcEntityList::ptr > v16_BendingParameters) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcReinforcingBarTypeEnum::ToString(v10_PredefinedType)); if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_CrossSectionArea) { e->setArgument(11,(*v12_CrossSectionArea)); } else { e->setArgument(11); } if (v13_BarLength) { e->setArgument(12,(*v13_BarLength)); } else { e->setArgument(12); } if (v14_BarSurface) { e->setArgument(13,*v14_BarSurface,IfcReinforcingBarSurfaceEnum::ToString(*v14_BarSurface)); } else { e->setArgument(13); } if (v15_BendingShapeCode) { e->setArgument(14,(*v15_BendingShapeCode)); } else { e->setArgument(14); } if (v16_BendingParameters) { e->setArgument(15,(*v16_BendingParameters)); } else { e->setArgument(15); } 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 || IfcElementComponent::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) : IfcElementComponent((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) : 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); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcReinforcingElement::IfcReinforcingElement(IfcAbstractEntity* e) : IfcElementComponent((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) : 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); } if (v9_SteelGrade) { e->setArgument(8,(*v9_SteelGrade)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcingElementType -bool IfcReinforcingElementType::is(Type::Enum v) const { return v == Type::IfcReinforcingElementType || IfcElementComponentType::is(v); } -Type::Enum IfcReinforcingElementType::type() const { return Type::IfcReinforcingElementType; } + + +const IfcParse::entity& IfcReinforcingElementType::declaration() const { return *IfcReinforcingElementType_type; } Type::Enum IfcReinforcingElementType::Class() { return Type::IfcReinforcingElementType; } -IfcReinforcingElementType::IfcReinforcingElementType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcingElementType::IfcReinforcingElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< 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); } +IfcReinforcingElementType::IfcReinforcingElementType(IfcAbstractEntity* e) : IfcElementComponentType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcingElementType::IfcReinforcingElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< 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 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); } -bool IfcReinforcingMesh::hasLongitudinalBarNominalDiameter() const { return !entity->getArgument(11)->isNull(); } -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); } -bool IfcReinforcingMesh::hasTransverseBarNominalDiameter() const { return !entity->getArgument(12)->isNull(); } -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); } -bool IfcReinforcingMesh::hasLongitudinalBarCrossSectionArea() const { return !entity->getArgument(13)->isNull(); } -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); } -bool IfcReinforcingMesh::hasTransverseBarCrossSectionArea() const { return !entity->getArgument(14)->isNull(); } -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); } -bool IfcReinforcingMesh::hasLongitudinalBarSpacing() const { return !entity->getArgument(15)->isNull(); } -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); } -bool IfcReinforcingMesh::hasTransverseBarSpacing() const { return !entity->getArgument(16)->isNull(); } -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::hasPredefinedType() const { return !entity->getArgument(17)->isNull(); } -IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum IfcReinforcingMesh::PredefinedType() const { return IfcReinforcingMeshTypeEnum::FromString(*entity->getArgument(17)); } -void IfcReinforcingMesh::setPredefinedType(IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v,IfcReinforcingMeshTypeEnum::ToString(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); } +bool IfcReinforcingMesh::hasLongitudinalBarNominalDiameter() const { return !data_->getArgument(11)->isNull(); } +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); } +bool IfcReinforcingMesh::hasTransverseBarNominalDiameter() const { return !data_->getArgument(12)->isNull(); } +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); } +bool IfcReinforcingMesh::hasLongitudinalBarCrossSectionArea() const { return !data_->getArgument(13)->isNull(); } +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); } +bool IfcReinforcingMesh::hasTransverseBarCrossSectionArea() const { return !data_->getArgument(14)->isNull(); } +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); } +bool IfcReinforcingMesh::hasLongitudinalBarSpacing() const { return !data_->getArgument(15)->isNull(); } +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); } +bool IfcReinforcingMesh::hasTransverseBarSpacing() const { return !data_->getArgument(16)->isNull(); } +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); } +bool IfcReinforcingMesh::hasPredefinedType() const { return !data_->getArgument(17)->isNull(); } +IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum IfcReinforcingMesh::PredefinedType() const { return IfcReinforcingMeshTypeEnum::FromString(*data_->getArgument(17)); } +void IfcReinforcingMesh::setPredefinedType(IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v,IfcReinforcingMeshTypeEnum::ToString(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, boost::optional< double > v12_LongitudinalBarNominalDiameter, boost::optional< double > v13_TransverseBarNominalDiameter, boost::optional< double > v14_LongitudinalBarCrossSectionArea, boost::optional< double > v15_TransverseBarCrossSectionArea, boost::optional< double > v16_LongitudinalBarSpacing, boost::optional< double > v17_TransverseBarSpacing, boost::optional< IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum > v18_PredefinedType) : 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); } if (v12_LongitudinalBarNominalDiameter) { e->setArgument(11,(*v12_LongitudinalBarNominalDiameter)); } else { e->setArgument(11); } if (v13_TransverseBarNominalDiameter) { e->setArgument(12,(*v13_TransverseBarNominalDiameter)); } else { e->setArgument(12); } if (v14_LongitudinalBarCrossSectionArea) { e->setArgument(13,(*v14_LongitudinalBarCrossSectionArea)); } else { e->setArgument(13); } if (v15_TransverseBarCrossSectionArea) { e->setArgument(14,(*v15_TransverseBarCrossSectionArea)); } else { e->setArgument(14); } if (v16_LongitudinalBarSpacing) { e->setArgument(15,(*v16_LongitudinalBarSpacing)); } else { e->setArgument(15); } if (v17_TransverseBarSpacing) { e->setArgument(16,(*v17_TransverseBarSpacing)); } else { e->setArgument(16); } if (v18_PredefinedType) { e->setArgument(17,*v18_PredefinedType,IfcReinforcingMeshTypeEnum::ToString(*v18_PredefinedType)); } else { e->setArgument(17); } 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, boost::optional< double > v12_LongitudinalBarNominalDiameter, boost::optional< double > v13_TransverseBarNominalDiameter, boost::optional< double > v14_LongitudinalBarCrossSectionArea, boost::optional< double > v15_TransverseBarCrossSectionArea, boost::optional< double > v16_LongitudinalBarSpacing, boost::optional< double > v17_TransverseBarSpacing, boost::optional< IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum > v18_PredefinedType) : 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); } if (v12_LongitudinalBarNominalDiameter) { e->setArgument(11,(*v12_LongitudinalBarNominalDiameter)); } else { e->setArgument(11); } if (v13_TransverseBarNominalDiameter) { e->setArgument(12,(*v13_TransverseBarNominalDiameter)); } else { e->setArgument(12); } if (v14_LongitudinalBarCrossSectionArea) { e->setArgument(13,(*v14_LongitudinalBarCrossSectionArea)); } else { e->setArgument(13); } if (v15_TransverseBarCrossSectionArea) { e->setArgument(14,(*v15_TransverseBarCrossSectionArea)); } else { e->setArgument(14); } if (v16_LongitudinalBarSpacing) { e->setArgument(15,(*v16_LongitudinalBarSpacing)); } else { e->setArgument(15); } if (v17_TransverseBarSpacing) { e->setArgument(16,(*v17_TransverseBarSpacing)); } else { e->setArgument(16); } if (v18_PredefinedType) { e->setArgument(17,*v18_PredefinedType,IfcReinforcingMeshTypeEnum::ToString(*v18_PredefinedType)); } else { e->setArgument(17); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcReinforcingMeshType -IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum IfcReinforcingMeshType::PredefinedType() const { return IfcReinforcingMeshTypeEnum::FromString(*entity->getArgument(9)); } -void IfcReinforcingMeshType::setPredefinedType(IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcReinforcingMeshTypeEnum::ToString(v)); } -bool IfcReinforcingMeshType::hasMeshLength() const { return !entity->getArgument(10)->isNull(); } -double IfcReinforcingMeshType::MeshLength() const { return *entity->getArgument(10); } -void IfcReinforcingMeshType::setMeshLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcReinforcingMeshType::hasMeshWidth() const { return !entity->getArgument(11)->isNull(); } -double IfcReinforcingMeshType::MeshWidth() const { return *entity->getArgument(11); } -void IfcReinforcingMeshType::setMeshWidth(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcReinforcingMeshType::hasLongitudinalBarNominalDiameter() const { return !entity->getArgument(12)->isNull(); } -double IfcReinforcingMeshType::LongitudinalBarNominalDiameter() const { return *entity->getArgument(12); } -void IfcReinforcingMeshType::setLongitudinalBarNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcReinforcingMeshType::hasTransverseBarNominalDiameter() const { return !entity->getArgument(13)->isNull(); } -double IfcReinforcingMeshType::TransverseBarNominalDiameter() const { return *entity->getArgument(13); } -void IfcReinforcingMeshType::setTransverseBarNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcReinforcingMeshType::hasLongitudinalBarCrossSectionArea() const { return !entity->getArgument(14)->isNull(); } -double IfcReinforcingMeshType::LongitudinalBarCrossSectionArea() const { return *entity->getArgument(14); } -void IfcReinforcingMeshType::setLongitudinalBarCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcReinforcingMeshType::hasTransverseBarCrossSectionArea() const { return !entity->getArgument(15)->isNull(); } -double IfcReinforcingMeshType::TransverseBarCrossSectionArea() const { return *entity->getArgument(15); } -void IfcReinforcingMeshType::setTransverseBarCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcReinforcingMeshType::hasLongitudinalBarSpacing() const { return !entity->getArgument(16)->isNull(); } -double IfcReinforcingMeshType::LongitudinalBarSpacing() const { return *entity->getArgument(16); } -void IfcReinforcingMeshType::setLongitudinalBarSpacing(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcReinforcingMeshType::hasTransverseBarSpacing() const { return !entity->getArgument(17)->isNull(); } -double IfcReinforcingMeshType::TransverseBarSpacing() const { return *entity->getArgument(17); } -void IfcReinforcingMeshType::setTransverseBarSpacing(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v); } -bool IfcReinforcingMeshType::hasBendingShapeCode() const { return !entity->getArgument(18)->isNull(); } -std::string IfcReinforcingMeshType::BendingShapeCode() const { return *entity->getArgument(18); } -void IfcReinforcingMeshType::setBendingShapeCode(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(18,v); } -bool IfcReinforcingMeshType::hasBendingParameters() const { return !entity->getArgument(19)->isNull(); } -IfcEntityList::ptr IfcReinforcingMeshType::BendingParameters() const { return *entity->getArgument(19); } -void IfcReinforcingMeshType::setBendingParameters(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(19,v); } -bool IfcReinforcingMeshType::is(Type::Enum v) const { return v == Type::IfcReinforcingMeshType || IfcReinforcingElementType::is(v); } -Type::Enum IfcReinforcingMeshType::type() const { return Type::IfcReinforcingMeshType; } +IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum IfcReinforcingMeshType::PredefinedType() const { return IfcReinforcingMeshTypeEnum::FromString(*data_->getArgument(9)); } +void IfcReinforcingMeshType::setPredefinedType(IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcReinforcingMeshTypeEnum::ToString(v)); } +bool IfcReinforcingMeshType::hasMeshLength() const { return !data_->getArgument(10)->isNull(); } +double IfcReinforcingMeshType::MeshLength() const { return *data_->getArgument(10); } +void IfcReinforcingMeshType::setMeshLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcReinforcingMeshType::hasMeshWidth() const { return !data_->getArgument(11)->isNull(); } +double IfcReinforcingMeshType::MeshWidth() const { return *data_->getArgument(11); } +void IfcReinforcingMeshType::setMeshWidth(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcReinforcingMeshType::hasLongitudinalBarNominalDiameter() const { return !data_->getArgument(12)->isNull(); } +double IfcReinforcingMeshType::LongitudinalBarNominalDiameter() const { return *data_->getArgument(12); } +void IfcReinforcingMeshType::setLongitudinalBarNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcReinforcingMeshType::hasTransverseBarNominalDiameter() const { return !data_->getArgument(13)->isNull(); } +double IfcReinforcingMeshType::TransverseBarNominalDiameter() const { return *data_->getArgument(13); } +void IfcReinforcingMeshType::setTransverseBarNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcReinforcingMeshType::hasLongitudinalBarCrossSectionArea() const { return !data_->getArgument(14)->isNull(); } +double IfcReinforcingMeshType::LongitudinalBarCrossSectionArea() const { return *data_->getArgument(14); } +void IfcReinforcingMeshType::setLongitudinalBarCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcReinforcingMeshType::hasTransverseBarCrossSectionArea() const { return !data_->getArgument(15)->isNull(); } +double IfcReinforcingMeshType::TransverseBarCrossSectionArea() const { return *data_->getArgument(15); } +void IfcReinforcingMeshType::setTransverseBarCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcReinforcingMeshType::hasLongitudinalBarSpacing() const { return !data_->getArgument(16)->isNull(); } +double IfcReinforcingMeshType::LongitudinalBarSpacing() const { return *data_->getArgument(16); } +void IfcReinforcingMeshType::setLongitudinalBarSpacing(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } +bool IfcReinforcingMeshType::hasTransverseBarSpacing() const { return !data_->getArgument(17)->isNull(); } +double IfcReinforcingMeshType::TransverseBarSpacing() const { return *data_->getArgument(17); } +void IfcReinforcingMeshType::setTransverseBarSpacing(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v); } +bool IfcReinforcingMeshType::hasBendingShapeCode() const { return !data_->getArgument(18)->isNull(); } +std::string IfcReinforcingMeshType::BendingShapeCode() const { return *data_->getArgument(18); } +void IfcReinforcingMeshType::setBendingShapeCode(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(18,v); } +bool IfcReinforcingMeshType::hasBendingParameters() const { return !data_->getArgument(19)->isNull(); } +IfcEntityList::ptr IfcReinforcingMeshType::BendingParameters() const { return *data_->getArgument(19); } +void IfcReinforcingMeshType::setBendingParameters(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(19,v); } + + +const IfcParse::entity& IfcReinforcingMeshType::declaration() const { return *IfcReinforcingMeshType_type; } Type::Enum IfcReinforcingMeshType::Class() { return Type::IfcReinforcingMeshType; } -IfcReinforcingMeshType::IfcReinforcingMeshType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingMeshType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReinforcingMeshType::IfcReinforcingMeshType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v10_PredefinedType, boost::optional< double > v11_MeshLength, boost::optional< double > v12_MeshWidth, boost::optional< double > v13_LongitudinalBarNominalDiameter, boost::optional< double > v14_TransverseBarNominalDiameter, boost::optional< double > v15_LongitudinalBarCrossSectionArea, boost::optional< double > v16_TransverseBarCrossSectionArea, boost::optional< double > v17_LongitudinalBarSpacing, boost::optional< double > v18_TransverseBarSpacing, boost::optional< std::string > v19_BendingShapeCode, boost::optional< IfcEntityList::ptr > v20_BendingParameters) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcReinforcingMeshTypeEnum::ToString(v10_PredefinedType)); if (v11_MeshLength) { e->setArgument(10,(*v11_MeshLength)); } else { e->setArgument(10); } if (v12_MeshWidth) { e->setArgument(11,(*v12_MeshWidth)); } else { e->setArgument(11); } if (v13_LongitudinalBarNominalDiameter) { e->setArgument(12,(*v13_LongitudinalBarNominalDiameter)); } else { e->setArgument(12); } if (v14_TransverseBarNominalDiameter) { e->setArgument(13,(*v14_TransverseBarNominalDiameter)); } else { e->setArgument(13); } if (v15_LongitudinalBarCrossSectionArea) { e->setArgument(14,(*v15_LongitudinalBarCrossSectionArea)); } else { e->setArgument(14); } if (v16_TransverseBarCrossSectionArea) { e->setArgument(15,(*v16_TransverseBarCrossSectionArea)); } else { e->setArgument(15); } if (v17_LongitudinalBarSpacing) { e->setArgument(16,(*v17_LongitudinalBarSpacing)); } else { e->setArgument(16); } if (v18_TransverseBarSpacing) { e->setArgument(17,(*v18_TransverseBarSpacing)); } else { e->setArgument(17); } if (v19_BendingShapeCode) { e->setArgument(18,(*v19_BendingShapeCode)); } else { e->setArgument(18); } if (v20_BendingParameters) { e->setArgument(19,(*v20_BendingParameters)); } else { e->setArgument(19); } entity = e; EntityBuffer::Add(this); } +IfcReinforcingMeshType::IfcReinforcingMeshType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReinforcingMeshType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReinforcingMeshType::IfcReinforcingMeshType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v10_PredefinedType, boost::optional< double > v11_MeshLength, boost::optional< double > v12_MeshWidth, boost::optional< double > v13_LongitudinalBarNominalDiameter, boost::optional< double > v14_TransverseBarNominalDiameter, boost::optional< double > v15_LongitudinalBarCrossSectionArea, boost::optional< double > v16_TransverseBarCrossSectionArea, boost::optional< double > v17_LongitudinalBarSpacing, boost::optional< double > v18_TransverseBarSpacing, boost::optional< std::string > v19_BendingShapeCode, boost::optional< IfcEntityList::ptr > v20_BendingParameters) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcReinforcingMeshTypeEnum::ToString(v10_PredefinedType)); if (v11_MeshLength) { e->setArgument(10,(*v11_MeshLength)); } else { e->setArgument(10); } if (v12_MeshWidth) { e->setArgument(11,(*v12_MeshWidth)); } else { e->setArgument(11); } if (v13_LongitudinalBarNominalDiameter) { e->setArgument(12,(*v13_LongitudinalBarNominalDiameter)); } else { e->setArgument(12); } if (v14_TransverseBarNominalDiameter) { e->setArgument(13,(*v14_TransverseBarNominalDiameter)); } else { e->setArgument(13); } if (v15_LongitudinalBarCrossSectionArea) { e->setArgument(14,(*v15_LongitudinalBarCrossSectionArea)); } else { e->setArgument(14); } if (v16_TransverseBarCrossSectionArea) { e->setArgument(15,(*v16_TransverseBarCrossSectionArea)); } else { e->setArgument(15); } if (v17_LongitudinalBarSpacing) { e->setArgument(16,(*v17_LongitudinalBarSpacing)); } else { e->setArgument(16); } if (v18_TransverseBarSpacing) { e->setArgument(17,(*v18_TransverseBarSpacing)); } else { e->setArgument(17); } if (v19_BendingShapeCode) { e->setArgument(18,(*v19_BendingShapeCode)); } else { e->setArgument(18); } if (v20_BendingParameters) { e->setArgument(19,(*v20_BendingParameters)); } else { e->setArgument(19); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAggregates -IfcObjectDefinition* IfcRelAggregates::RelatingObject() const { return (IfcObjectDefinition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelAggregates::setRelatingObject(IfcObjectDefinition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelAggregates::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelAggregates::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcRelAggregates::is(Type::Enum v) const { return v == Type::IfcRelAggregates || IfcRelDecomposes::is(v); } -Type::Enum IfcRelAggregates::type() const { return Type::IfcRelAggregates; } +IfcObjectDefinition* IfcRelAggregates::RelatingObject() const { return (IfcObjectDefinition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelAggregates::setRelatingObject(IfcObjectDefinition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelAggregates::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelAggregates::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +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 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 IfcRelAssignsToGroupByFactor -double IfcRelAssignsToGroupByFactor::Factor() const { return *entity->getArgument(7); } -void IfcRelAssignsToGroupByFactor::setFactor(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelAssignsToGroupByFactor::is(Type::Enum v) const { return v == Type::IfcRelAssignsToGroupByFactor || IfcRelAssignsToGroup::is(v); } -Type::Enum IfcRelAssignsToGroupByFactor::type() const { return Type::IfcRelAssignsToGroupByFactor; } +double IfcRelAssignsToGroupByFactor::Factor() const { return *data_->getArgument(7); } +void IfcRelAssignsToGroupByFactor::setFactor(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + + +const IfcParse::entity& IfcRelAssignsToGroupByFactor::declaration() const { return *IfcRelAssignsToGroupByFactor_type; } Type::Enum IfcRelAssignsToGroupByFactor::Class() { return Type::IfcRelAssignsToGroupByFactor; } -IfcRelAssignsToGroupByFactor::IfcRelAssignsToGroupByFactor(IfcAbstractEntity* e) : IfcRelAssignsToGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToGroupByFactor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelAssignsToGroupByFactor::IfcRelAssignsToGroupByFactor(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, double v8_Factor) : IfcRelAssignsToGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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)); e->setArgument(7,(v8_Factor)); entity = e; EntityBuffer::Add(this); } +IfcRelAssignsToGroupByFactor::IfcRelAssignsToGroupByFactor(IfcAbstractEntity* e) : IfcRelAssignsToGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelAssignsToGroupByFactor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelAssignsToGroupByFactor::IfcRelAssignsToGroupByFactor(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, double v8_Factor) : IfcRelAssignsToGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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)); e->setArgument(7,(v8_Factor)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssignsToProcess -IfcProcessSelect* IfcRelAssignsToProcess::RelatingProcess() const { return (IfcProcessSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToProcess::setRelatingProcess(IfcProcessSelect* 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; } +IfcProcessSelect* IfcRelAssignsToProcess::RelatingProcess() const { return (IfcProcessSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToProcess::setRelatingProcess(IfcProcessSelect* 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, IfcProcessSelect* 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, IfcProcessSelect* 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 -IfcProductSelect* IfcRelAssignsToProduct::RelatingProduct() const { return (IfcProductSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToProduct::setRelatingProduct(IfcProductSelect* 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; } +IfcProductSelect* IfcRelAssignsToProduct::RelatingProduct() const { return (IfcProductSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToProduct::setRelatingProduct(IfcProductSelect* 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, IfcProductSelect* 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, IfcProductSelect* 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 IfcRelAssignsToResource -IfcResourceSelect* IfcRelAssignsToResource::RelatingResource() const { return (IfcResourceSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelAssignsToResource::setRelatingResource(IfcResourceSelect* 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; } +IfcResourceSelect* IfcRelAssignsToResource::RelatingResource() const { return (IfcResourceSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelAssignsToResource::setRelatingResource(IfcResourceSelect* 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, IfcResourceSelect* 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, IfcResourceSelect* 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 -IfcEntityList::ptr IfcRelAssociates::RelatedObjects() const { return *entity->getArgument(4); } -void IfcRelAssociates::setRelatedObjects(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRelAssociates::is(Type::Enum v) const { return v == Type::IfcRelAssociates || IfcRelationship::is(v); } -Type::Enum IfcRelAssociates::type() const { return Type::IfcRelAssociates; } +IfcEntityList::ptr IfcRelAssociates::RelatedObjects() const { return *data_->getArgument(4); } +void IfcRelAssociates::setRelatedObjects(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +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, IfcEntityList::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)); 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, IfcEntityList::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)); 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, IfcEntityList::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)); 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, IfcEntityList::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)); e->setArgument(5,(v6_RelatingApproval)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesClassification -IfcClassificationSelect* IfcRelAssociatesClassification::RelatingClassification() const { return (IfcClassificationSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelAssociatesClassification::setRelatingClassification(IfcClassificationSelect* 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; } +IfcClassificationSelect* IfcRelAssociatesClassification::RelatingClassification() const { return (IfcClassificationSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelAssociatesClassification::setRelatingClassification(IfcClassificationSelect* 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, IfcEntityList::ptr v5_RelatedObjects, IfcClassificationSelect* 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)); 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, IfcEntityList::ptr v5_RelatedObjects, IfcClassificationSelect* 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)); e->setArgument(5,(v6_RelatingClassification)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelAssociatesConstraint -bool IfcRelAssociatesConstraint::hasIntent() const { return !entity->getArgument(5)->isNull(); } -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; } +bool IfcRelAssociatesConstraint::hasIntent() const { return !data_->getArgument(5)->isNull(); } +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, IfcEntityList::ptr v5_RelatedObjects, boost::optional< 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)); if (v6_Intent) { e->setArgument(5,(*v6_Intent)); } else { e->setArgument(5); } 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, IfcEntityList::ptr v5_RelatedObjects, boost::optional< 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)); if (v6_Intent) { e->setArgument(5,(*v6_Intent)); } else { e->setArgument(5); } 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, IfcEntityList::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)); 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, IfcEntityList::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)); 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, IfcEntityList::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)); 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, IfcEntityList::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)); 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, IfcEntityList::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)); 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, IfcEntityList::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)); e->setArgument(5,(v6_RelatingMaterial)); 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< double > /*[0:?]*/ IfcRelConnectsPathElements::RelatingPriorities() const { return *entity->getArgument(7); } -void IfcRelConnectsPathElements::setRelatingPriorities(std::vector< double > /*[0:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -std::vector< double > /*[0:?]*/ IfcRelConnectsPathElements::RelatedPriorities() const { return *entity->getArgument(8); } -void IfcRelConnectsPathElements::setRelatedPriorities(std::vector< double > /*[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< double > /*[0:?]*/ IfcRelConnectsPathElements::RelatingPriorities() const { return *data_->getArgument(7); } +void IfcRelConnectsPathElements::setRelatingPriorities(std::vector< double > /*[0:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +std::vector< double > /*[0:?]*/ IfcRelConnectsPathElements::RelatedPriorities() const { return *data_->getArgument(8); } +void IfcRelConnectsPathElements::setRelatedPriorities(std::vector< double > /*[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< double > /*[0:?]*/ v8_RelatingPriorities, std::vector< double > /*[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< double > /*[0:?]*/ v8_RelatingPriorities, std::vector< double > /*[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); } -IfcDistributionElement* IfcRelConnectsPortToElement::RelatedElement() const { return (IfcDistributionElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelConnectsPortToElement::setRelatedElement(IfcDistributionElement* 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); } +IfcDistributionElement* IfcRelConnectsPortToElement::RelatedElement() const { return (IfcDistributionElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelConnectsPortToElement::setRelatedElement(IfcDistributionElement* 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, IfcDistributionElement* 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, IfcDistributionElement* 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 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()); } -IfcSpatialElement* IfcRelContainedInSpatialStructure::RelatingStructure() const { return (IfcSpatialElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelContainedInSpatialStructure::setRelatingStructure(IfcSpatialElement* 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()); } +IfcSpatialElement* IfcRelContainedInSpatialStructure::RelatingStructure() const { return (IfcSpatialElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelContainedInSpatialStructure::setRelatingStructure(IfcSpatialElement* 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, IfcSpatialElement* 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, IfcSpatialElement* 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::RelatingSpace() const { return (IfcSpace*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelCoversSpaces::setRelatingSpace(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::RelatingSpace() const { return (IfcSpace*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelCoversSpaces::setRelatingSpace(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_RelatingSpace, 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_RelatingSpace)); 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_RelatingSpace, 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_RelatingSpace)); e->setArgument(5,(v6_RelatedCoverings)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDeclares -IfcContext* IfcRelDeclares::RelatingContext() const { return (IfcContext*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelDeclares::setRelatingContext(IfcContext* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcEntityList::ptr IfcRelDeclares::RelatedDefinitions() const { return *entity->getArgument(5); } -void IfcRelDeclares::setRelatedDefinitions(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelDeclares::is(Type::Enum v) const { return v == Type::IfcRelDeclares || IfcRelationship::is(v); } -Type::Enum IfcRelDeclares::type() const { return Type::IfcRelDeclares; } +IfcContext* IfcRelDeclares::RelatingContext() const { return (IfcContext*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelDeclares::setRelatingContext(IfcContext* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcEntityList::ptr IfcRelDeclares::RelatedDefinitions() const { return *data_->getArgument(5); } +void IfcRelDeclares::setRelatedDefinitions(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelDeclares::declaration() const { return *IfcRelDeclares_type; } Type::Enum IfcRelDeclares::Class() { return Type::IfcRelDeclares; } -IfcRelDeclares::IfcRelDeclares(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDeclares)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDeclares::IfcRelDeclares(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcContext* v5_RelatingContext, IfcEntityList::ptr v6_RelatedDefinitions) : 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_RelatingContext)); e->setArgument(5,(v6_RelatedDefinitions)); entity = e; EntityBuffer::Add(this); } +IfcRelDeclares::IfcRelDeclares(IfcAbstractEntity* e) : IfcRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDeclares)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDeclares::IfcRelDeclares(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcContext* v5_RelatingContext, IfcEntityList::ptr v6_RelatedDefinitions) : 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_RelatingContext)); e->setArgument(5,(v6_RelatedDefinitions)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDecomposes -bool IfcRelDecomposes::is(Type::Enum v) const { return v == Type::IfcRelDecomposes || IfcRelationship::is(v); } -Type::Enum IfcRelDecomposes::type() const { return Type::IfcRelDecomposes; } + + +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) : 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); } +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) : 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 IfcRelDefines -bool IfcRelDefines::is(Type::Enum v) const { return v == Type::IfcRelDefines || IfcRelationship::is(v); } -Type::Enum IfcRelDefines::type() const { return Type::IfcRelDefines; } + + +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) : 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); } +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) : 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 IfcRelDefinesByObject -IfcTemplatedEntityList< IfcObject >::ptr IfcRelDefinesByObject::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelDefinesByObject::setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcObject* IfcRelDefinesByObject::RelatingObject() const { return (IfcObject*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelDefinesByObject::setRelatingObject(IfcObject* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelDefinesByObject::is(Type::Enum v) const { return v == Type::IfcRelDefinesByObject || IfcRelDefines::is(v); } -Type::Enum IfcRelDefinesByObject::type() const { return Type::IfcRelDefinesByObject; } +IfcTemplatedEntityList< IfcObject >::ptr IfcRelDefinesByObject::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelDefinesByObject::setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +IfcObject* IfcRelDefinesByObject::RelatingObject() const { return (IfcObject*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelDefinesByObject::setRelatingObject(IfcObject* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelDefinesByObject::declaration() const { return *IfcRelDefinesByObject_type; } Type::Enum IfcRelDefinesByObject::Class() { return Type::IfcRelDefinesByObject; } -IfcRelDefinesByObject::IfcRelDefinesByObject(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByObject)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDefinesByObject::IfcRelDefinesByObject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcObject* v6_RelatingObject) : 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_RelatingObject)); entity = e; EntityBuffer::Add(this); } +IfcRelDefinesByObject::IfcRelDefinesByObject(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByObject)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDefinesByObject::IfcRelDefinesByObject(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcObject* v6_RelatingObject) : 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_RelatingObject)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDefinesByProperties -IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelDefinesByProperties::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelDefinesByProperties::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcPropertySetDefinitionSelect* IfcRelDefinesByProperties::RelatingPropertyDefinition() const { return (IfcPropertySetDefinitionSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelDefinesByProperties::setRelatingPropertyDefinition(IfcPropertySetDefinitionSelect* 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; } +IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelDefinesByProperties::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelDefinesByProperties::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +IfcPropertySetDefinitionSelect* IfcRelDefinesByProperties::RelatingPropertyDefinition() const { return (IfcPropertySetDefinitionSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelDefinesByProperties::setRelatingPropertyDefinition(IfcPropertySetDefinitionSelect* 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< IfcObjectDefinition >::ptr v5_RelatedObjects, IfcPropertySetDefinitionSelect* 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< IfcObjectDefinition >::ptr v5_RelatedObjects, IfcPropertySetDefinitionSelect* 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 IfcRelDefinesByTemplate -IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr IfcRelDefinesByTemplate::RelatedPropertySets() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelDefinesByTemplate::setRelatedPropertySets(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -IfcPropertySetTemplate* IfcRelDefinesByTemplate::RelatingTemplate() const { return (IfcPropertySetTemplate*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelDefinesByTemplate::setRelatingTemplate(IfcPropertySetTemplate* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelDefinesByTemplate::is(Type::Enum v) const { return v == Type::IfcRelDefinesByTemplate || IfcRelDefines::is(v); } -Type::Enum IfcRelDefinesByTemplate::type() const { return Type::IfcRelDefinesByTemplate; } +IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr IfcRelDefinesByTemplate::RelatedPropertySets() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelDefinesByTemplate::setRelatedPropertySets(IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +IfcPropertySetTemplate* IfcRelDefinesByTemplate::RelatingTemplate() const { return (IfcPropertySetTemplate*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelDefinesByTemplate::setRelatingTemplate(IfcPropertySetTemplate* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcRelDefinesByTemplate::declaration() const { return *IfcRelDefinesByTemplate_type; } Type::Enum IfcRelDefinesByTemplate::Class() { return Type::IfcRelDefinesByTemplate; } -IfcRelDefinesByTemplate::IfcRelDefinesByTemplate(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByTemplate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelDefinesByTemplate::IfcRelDefinesByTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v5_RelatedPropertySets, IfcPropertySetTemplate* v6_RelatingTemplate) : 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_RelatedPropertySets)->generalize()); e->setArgument(5,(v6_RelatingTemplate)); entity = e; EntityBuffer::Add(this); } +IfcRelDefinesByTemplate::IfcRelDefinesByTemplate(IfcAbstractEntity* e) : IfcRelDefines((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelDefinesByTemplate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelDefinesByTemplate::IfcRelDefinesByTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v5_RelatedPropertySets, IfcPropertySetTemplate* v6_RelatingTemplate) : 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_RelatedPropertySets)->generalize()); e->setArgument(5,(v6_RelatingTemplate)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelDefinesByType -IfcTemplatedEntityList< IfcObject >::ptr IfcRelDefinesByType::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(4); return es->as(); } -void IfcRelDefinesByType::setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v->generalize()); } -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; } +IfcTemplatedEntityList< IfcObject >::ptr IfcRelDefinesByType::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(4); return es->as(); } +void IfcRelDefinesByType::setRelatedObjects(IfcTemplatedEntityList< IfcObject >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v->generalize()); } +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 IfcRelInterferesElements -IfcElement* IfcRelInterferesElements::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelInterferesElements::setRelatingElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcElement* IfcRelInterferesElements::RelatedElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelInterferesElements::setRelatedElement(IfcElement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcRelInterferesElements::hasInterferenceGeometry() const { return !entity->getArgument(6)->isNull(); } -IfcConnectionGeometry* IfcRelInterferesElements::InterferenceGeometry() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelInterferesElements::setInterferenceGeometry(IfcConnectionGeometry* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelInterferesElements::hasInterferenceType() const { return !entity->getArgument(7)->isNull(); } -std::string IfcRelInterferesElements::InterferenceType() const { return *entity->getArgument(7); } -void IfcRelInterferesElements::setInterferenceType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcRelInterferesElements::ImpliedOrder() const { return *entity->getArgument(8); } -void IfcRelInterferesElements::setImpliedOrder(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcRelInterferesElements::is(Type::Enum v) const { return v == Type::IfcRelInterferesElements || IfcRelConnects::is(v); } -Type::Enum IfcRelInterferesElements::type() const { return Type::IfcRelInterferesElements; } +IfcElement* IfcRelInterferesElements::RelatingElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelInterferesElements::setRelatingElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcElement* IfcRelInterferesElements::RelatedElement() const { return (IfcElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelInterferesElements::setRelatedElement(IfcElement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcRelInterferesElements::hasInterferenceGeometry() const { return !data_->getArgument(6)->isNull(); } +IfcConnectionGeometry* IfcRelInterferesElements::InterferenceGeometry() const { return (IfcConnectionGeometry*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelInterferesElements::setInterferenceGeometry(IfcConnectionGeometry* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRelInterferesElements::hasInterferenceType() const { return !data_->getArgument(7)->isNull(); } +std::string IfcRelInterferesElements::InterferenceType() const { return *data_->getArgument(7); } +void IfcRelInterferesElements::setInterferenceType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcRelInterferesElements::ImpliedOrder() const { return *data_->getArgument(8); } +void IfcRelInterferesElements::setImpliedOrder(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcRelInterferesElements::declaration() const { return *IfcRelInterferesElements_type; } Type::Enum IfcRelInterferesElements::Class() { return Type::IfcRelInterferesElements; } -IfcRelInterferesElements::IfcRelInterferesElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelInterferesElements)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelInterferesElements::IfcRelInterferesElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcElement* v6_RelatedElement, IfcConnectionGeometry* v7_InterferenceGeometry, boost::optional< std::string > v8_InterferenceType, bool v9_ImpliedOrder) : 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_RelatedElement)); e->setArgument(6,(v7_InterferenceGeometry)); if (v8_InterferenceType) { e->setArgument(7,(*v8_InterferenceType)); } else { e->setArgument(7); } e->setArgument(8,(v9_ImpliedOrder)); entity = e; EntityBuffer::Add(this); } +IfcRelInterferesElements::IfcRelInterferesElements(IfcAbstractEntity* e) : IfcRelConnects((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelInterferesElements)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelInterferesElements::IfcRelInterferesElements(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcElement* v6_RelatedElement, IfcConnectionGeometry* v7_InterferenceGeometry, boost::optional< std::string > v8_InterferenceType, bool v9_ImpliedOrder) : 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_RelatedElement)); e->setArgument(6,(v7_InterferenceGeometry)); if (v8_InterferenceType) { e->setArgument(7,(*v8_InterferenceType)); } else { e->setArgument(7); } e->setArgument(8,(v9_ImpliedOrder)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelNests -IfcObjectDefinition* IfcRelNests::RelatingObject() const { return (IfcObjectDefinition*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelNests::setRelatingObject(IfcObjectDefinition* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelNests::RelatedObjects() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelNests::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v->generalize()); } -bool IfcRelNests::is(Type::Enum v) const { return v == Type::IfcRelNests || IfcRelDecomposes::is(v); } -Type::Enum IfcRelNests::type() const { return Type::IfcRelNests; } +IfcObjectDefinition* IfcRelNests::RelatingObject() const { return (IfcObjectDefinition*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelNests::setRelatingObject(IfcObjectDefinition* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +IfcTemplatedEntityList< IfcObjectDefinition >::ptr IfcRelNests::RelatedObjects() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelNests::setRelatedObjects(IfcTemplatedEntityList< IfcObjectDefinition >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v->generalize()); } + + +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 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 || IfcRelDecomposes::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) : IfcRelDecomposes((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) : 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_RelatingElement)); e->setArgument(5,(v6_RelatedFeatureElement)); entity = e; EntityBuffer::Add(this); } +IfcRelProjectsElement::IfcRelProjectsElement(IfcAbstractEntity* e) : IfcRelDecomposes((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) : 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_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()); } -IfcSpatialElement* IfcRelReferencedInSpatialStructure::RelatingStructure() const { return (IfcSpatialElement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(5))); } -void IfcRelReferencedInSpatialStructure::setRelatingStructure(IfcSpatialElement* 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()); } +IfcSpatialElement* IfcRelReferencedInSpatialStructure::RelatingStructure() const { return (IfcSpatialElement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(5))); } +void IfcRelReferencedInSpatialStructure::setRelatingStructure(IfcSpatialElement* 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, IfcSpatialElement* 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, IfcSpatialElement* 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 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); } -bool IfcRelSequence::hasTimeLag() const { return !entity->getArgument(6)->isNull(); } -IfcLagTime* IfcRelSequence::TimeLag() const { return (IfcLagTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(6))); } -void IfcRelSequence::setTimeLag(IfcLagTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcRelSequence::hasSequenceType() const { return !entity->getArgument(7)->isNull(); } -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::hasUserDefinedSequenceType() const { return !entity->getArgument(8)->isNull(); } -std::string IfcRelSequence::UserDefinedSequenceType() const { return *entity->getArgument(8); } -void IfcRelSequence::setUserDefinedSequenceType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,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); } +bool IfcRelSequence::hasTimeLag() const { return !data_->getArgument(6)->isNull(); } +IfcLagTime* IfcRelSequence::TimeLag() const { return (IfcLagTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(6))); } +void IfcRelSequence::setTimeLag(IfcLagTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcRelSequence::hasSequenceType() const { return !data_->getArgument(7)->isNull(); } +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)); } +bool IfcRelSequence::hasUserDefinedSequenceType() const { return !data_->getArgument(8)->isNull(); } +std::string IfcRelSequence::UserDefinedSequenceType() const { return *data_->getArgument(8); } +void IfcRelSequence::setUserDefinedSequenceType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, IfcLagTime* v7_TimeLag, boost::optional< IfcSequenceEnum::IfcSequenceEnum > v8_SequenceType, boost::optional< std::string > v9_UserDefinedSequenceType) : 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)); if (v8_SequenceType) { e->setArgument(7,*v8_SequenceType,IfcSequenceEnum::ToString(*v8_SequenceType)); } else { e->setArgument(7); } if (v9_UserDefinedSequenceType) { e->setArgument(8,(*v9_UserDefinedSequenceType)); } else { e->setArgument(8); } 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, IfcLagTime* v7_TimeLag, boost::optional< IfcSequenceEnum::IfcSequenceEnum > v8_SequenceType, boost::optional< std::string > v9_UserDefinedSequenceType) : 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)); if (v8_SequenceType) { e->setArgument(7,*v8_SequenceType,IfcSequenceEnum::ToString(*v8_SequenceType)); } else { e->setArgument(7); } if (v9_UserDefinedSequenceType) { e->setArgument(8,(*v9_UserDefinedSequenceType)); } else { e->setArgument(8); } 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< IfcSpatialElement >::ptr IfcRelServicesBuildings::RelatedBuildings() const { IfcEntityList::ptr es = *entity->getArgument(5); return es->as(); } -void IfcRelServicesBuildings::setRelatedBuildings(IfcTemplatedEntityList< IfcSpatialElement >::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< IfcSpatialElement >::ptr IfcRelServicesBuildings::RelatedBuildings() const { IfcEntityList::ptr es = *data_->getArgument(5); return es->as(); } +void IfcRelServicesBuildings::setRelatedBuildings(IfcTemplatedEntityList< IfcSpatialElement >::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< IfcSpatialElement >::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< IfcSpatialElement >::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 -IfcSpaceBoundarySelect* IfcRelSpaceBoundary::RelatingSpace() const { return (IfcSpaceBoundarySelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRelSpaceBoundary::setRelatingSpace(IfcSpaceBoundarySelect* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -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; } +IfcSpaceBoundarySelect* IfcRelSpaceBoundary::RelatingSpace() const { return (IfcSpaceBoundarySelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRelSpaceBoundary::setRelatingSpace(IfcSpaceBoundarySelect* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +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, IfcSpaceBoundarySelect* 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, IfcSpaceBoundarySelect* 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 IfcRelSpaceBoundary1stLevel -bool IfcRelSpaceBoundary1stLevel::hasParentBoundary() const { return !entity->getArgument(9)->isNull(); } -IfcRelSpaceBoundary1stLevel* IfcRelSpaceBoundary1stLevel::ParentBoundary() const { return (IfcRelSpaceBoundary1stLevel*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcRelSpaceBoundary1stLevel::setParentBoundary(IfcRelSpaceBoundary1stLevel* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -IfcRelSpaceBoundary1stLevel::list::ptr IfcRelSpaceBoundary1stLevel::InnerBoundaries() const { return entity->getInverse(Type::IfcRelSpaceBoundary1stLevel, 9)->as(); } -bool IfcRelSpaceBoundary1stLevel::is(Type::Enum v) const { return v == Type::IfcRelSpaceBoundary1stLevel || IfcRelSpaceBoundary::is(v); } -Type::Enum IfcRelSpaceBoundary1stLevel::type() const { return Type::IfcRelSpaceBoundary1stLevel; } +bool IfcRelSpaceBoundary1stLevel::hasParentBoundary() const { return !data_->getArgument(9)->isNull(); } +IfcRelSpaceBoundary1stLevel* IfcRelSpaceBoundary1stLevel::ParentBoundary() const { return (IfcRelSpaceBoundary1stLevel*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcRelSpaceBoundary1stLevel::setParentBoundary(IfcRelSpaceBoundary1stLevel* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + +IfcRelSpaceBoundary1stLevel::list::ptr IfcRelSpaceBoundary1stLevel::InnerBoundaries() const { return data_->getInverse(Type::IfcRelSpaceBoundary1stLevel, 9)->as(); } + +const IfcParse::entity& IfcRelSpaceBoundary1stLevel::declaration() const { return *IfcRelSpaceBoundary1stLevel_type; } Type::Enum IfcRelSpaceBoundary1stLevel::Class() { return Type::IfcRelSpaceBoundary1stLevel; } -IfcRelSpaceBoundary1stLevel::IfcRelSpaceBoundary1stLevel(IfcAbstractEntity* e) : IfcRelSpaceBoundary((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSpaceBoundary1stLevel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelSpaceBoundary1stLevel::IfcRelSpaceBoundary1stLevel(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary, IfcRelSpaceBoundary1stLevel* v10_ParentBoundary) : IfcRelSpaceBoundary((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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)); e->setArgument(9,(v10_ParentBoundary)); entity = e; EntityBuffer::Add(this); } +IfcRelSpaceBoundary1stLevel::IfcRelSpaceBoundary1stLevel(IfcAbstractEntity* e) : IfcRelSpaceBoundary((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSpaceBoundary1stLevel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelSpaceBoundary1stLevel::IfcRelSpaceBoundary1stLevel(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary, IfcRelSpaceBoundary1stLevel* v10_ParentBoundary) : IfcRelSpaceBoundary((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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)); e->setArgument(9,(v10_ParentBoundary)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRelSpaceBoundary2ndLevel -bool IfcRelSpaceBoundary2ndLevel::hasCorrespondingBoundary() const { return !entity->getArgument(10)->isNull(); } -IfcRelSpaceBoundary2ndLevel* IfcRelSpaceBoundary2ndLevel::CorrespondingBoundary() const { return (IfcRelSpaceBoundary2ndLevel*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(10))); } -void IfcRelSpaceBoundary2ndLevel::setCorrespondingBoundary(IfcRelSpaceBoundary2ndLevel* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -IfcRelSpaceBoundary2ndLevel::list::ptr IfcRelSpaceBoundary2ndLevel::Corresponds() const { return entity->getInverse(Type::IfcRelSpaceBoundary2ndLevel, 10)->as(); } -bool IfcRelSpaceBoundary2ndLevel::is(Type::Enum v) const { return v == Type::IfcRelSpaceBoundary2ndLevel || IfcRelSpaceBoundary1stLevel::is(v); } -Type::Enum IfcRelSpaceBoundary2ndLevel::type() const { return Type::IfcRelSpaceBoundary2ndLevel; } +bool IfcRelSpaceBoundary2ndLevel::hasCorrespondingBoundary() const { return !data_->getArgument(10)->isNull(); } +IfcRelSpaceBoundary2ndLevel* IfcRelSpaceBoundary2ndLevel::CorrespondingBoundary() const { return (IfcRelSpaceBoundary2ndLevel*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(10))); } +void IfcRelSpaceBoundary2ndLevel::setCorrespondingBoundary(IfcRelSpaceBoundary2ndLevel* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + +IfcRelSpaceBoundary2ndLevel::list::ptr IfcRelSpaceBoundary2ndLevel::Corresponds() const { return data_->getInverse(Type::IfcRelSpaceBoundary2ndLevel, 10)->as(); } + +const IfcParse::entity& IfcRelSpaceBoundary2ndLevel::declaration() const { return *IfcRelSpaceBoundary2ndLevel_type; } Type::Enum IfcRelSpaceBoundary2ndLevel::Class() { return Type::IfcRelSpaceBoundary2ndLevel; } -IfcRelSpaceBoundary2ndLevel::IfcRelSpaceBoundary2ndLevel(IfcAbstractEntity* e) : IfcRelSpaceBoundary1stLevel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSpaceBoundary2ndLevel)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRelSpaceBoundary2ndLevel::IfcRelSpaceBoundary2ndLevel(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary, IfcRelSpaceBoundary1stLevel* v10_ParentBoundary, IfcRelSpaceBoundary2ndLevel* v11_CorrespondingBoundary) : IfcRelSpaceBoundary1stLevel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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)); e->setArgument(9,(v10_ParentBoundary)); e->setArgument(10,(v11_CorrespondingBoundary)); entity = e; EntityBuffer::Add(this); } +IfcRelSpaceBoundary2ndLevel::IfcRelSpaceBoundary2ndLevel(IfcAbstractEntity* e) : IfcRelSpaceBoundary1stLevel((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRelSpaceBoundary2ndLevel)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRelSpaceBoundary2ndLevel::IfcRelSpaceBoundary2ndLevel(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary, IfcRelSpaceBoundary1stLevel* v10_ParentBoundary, IfcRelSpaceBoundary2ndLevel* v11_CorrespondingBoundary) : IfcRelSpaceBoundary1stLevel((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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)); e->setArgument(9,(v10_ParentBoundary)); e->setArgument(10,(v11_CorrespondingBoundary)); 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 || IfcRelDecomposes::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) : IfcRelDecomposes((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) : 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_RelatingBuildingElement)); e->setArgument(5,(v6_RelatedOpeningElement)); entity = e; EntityBuffer::Add(this); } +IfcRelVoidsElement::IfcRelVoidsElement(IfcAbstractEntity* e) : IfcRelDecomposes((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) : 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_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 IfcReparametrisedCompositeCurveSegment -double IfcReparametrisedCompositeCurveSegment::ParamLength() const { return *entity->getArgument(3); } -void IfcReparametrisedCompositeCurveSegment::setParamLength(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcReparametrisedCompositeCurveSegment::is(Type::Enum v) const { return v == Type::IfcReparametrisedCompositeCurveSegment || IfcCompositeCurveSegment::is(v); } -Type::Enum IfcReparametrisedCompositeCurveSegment::type() const { return Type::IfcReparametrisedCompositeCurveSegment; } +double IfcReparametrisedCompositeCurveSegment::ParamLength() const { return *data_->getArgument(3); } +void IfcReparametrisedCompositeCurveSegment::setParamLength(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcReparametrisedCompositeCurveSegment::declaration() const { return *IfcReparametrisedCompositeCurveSegment_type; } Type::Enum IfcReparametrisedCompositeCurveSegment::Class() { return Type::IfcReparametrisedCompositeCurveSegment; } -IfcReparametrisedCompositeCurveSegment::IfcReparametrisedCompositeCurveSegment(IfcAbstractEntity* e) : IfcCompositeCurveSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReparametrisedCompositeCurveSegment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcReparametrisedCompositeCurveSegment::IfcReparametrisedCompositeCurveSegment(IfcTransitionCode::IfcTransitionCode v1_Transition, bool v2_SameSense, IfcCurve* v3_ParentCurve, double v4_ParamLength) : IfcCompositeCurveSegment((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)); e->setArgument(3,(v4_ParamLength)); entity = e; EntityBuffer::Add(this); } +IfcReparametrisedCompositeCurveSegment::IfcReparametrisedCompositeCurveSegment(IfcAbstractEntity* e) : IfcCompositeCurveSegment((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcReparametrisedCompositeCurveSegment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcReparametrisedCompositeCurveSegment::IfcReparametrisedCompositeCurveSegment(IfcTransitionCode::IfcTransitionCode v1_Transition, bool v2_SameSense, IfcCurve* v3_ParentCurve, double v4_ParamLength) : IfcCompositeCurveSegment((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)); e->setArgument(3,(v4_ParamLength)); 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::LayerAssignment() 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::LayerAssignment() 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); } -IfcShapeAspect::list::ptr IfcRepresentationMap::HasShapeAspects() const { return entity->getInverse(Type::IfcShapeAspect, 4)->as(); } -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); } + +IfcShapeAspect::list::ptr IfcRepresentationMap::HasShapeAspects() const { return data_->getInverse(Type::IfcShapeAspect, 4)->as(); } +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 -bool IfcResource::hasIdentification() const { return !entity->getArgument(5)->isNull(); } -std::string IfcResource::Identification() const { return *entity->getArgument(5); } -void IfcResource::setIdentification(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcResource::hasLongDescription() const { return !entity->getArgument(6)->isNull(); } -std::string IfcResource::LongDescription() const { return *entity->getArgument(6); } -void IfcResource::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -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; } +bool IfcResource::hasIdentification() const { return !data_->getArgument(5)->isNull(); } +std::string IfcResource::Identification() const { return *data_->getArgument(5); } +void IfcResource::setIdentification(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcResource::hasLongDescription() const { return !data_->getArgument(6)->isNull(); } +std::string IfcResource::LongDescription() const { return *data_->getArgument(6); } +void IfcResource::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } + +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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcResourceApprovalRelationship -IfcEntityList::ptr IfcResourceApprovalRelationship::RelatedResourceObjects() const { return *entity->getArgument(2); } -void IfcResourceApprovalRelationship::setRelatedResourceObjects(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcApproval* IfcResourceApprovalRelationship::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcResourceApprovalRelationship::setRelatingApproval(IfcApproval* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcResourceApprovalRelationship::is(Type::Enum v) const { return v == Type::IfcResourceApprovalRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcResourceApprovalRelationship::type() const { return Type::IfcResourceApprovalRelationship; } +IfcEntityList::ptr IfcResourceApprovalRelationship::RelatedResourceObjects() const { return *data_->getArgument(2); } +void IfcResourceApprovalRelationship::setRelatedResourceObjects(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcApproval* IfcResourceApprovalRelationship::RelatingApproval() const { return (IfcApproval*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcResourceApprovalRelationship::setRelatingApproval(IfcApproval* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcResourceApprovalRelationship::declaration() const { return *IfcResourceApprovalRelationship_type; } Type::Enum IfcResourceApprovalRelationship::Class() { return Type::IfcResourceApprovalRelationship; } -IfcResourceApprovalRelationship::IfcResourceApprovalRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResourceApprovalRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcResourceApprovalRelationship::IfcResourceApprovalRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_RelatedResourceObjects, IfcApproval* v4_RelatingApproval) : IfcResourceLevelRelationship((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_RelatedResourceObjects)); e->setArgument(3,(v4_RelatingApproval)); entity = e; EntityBuffer::Add(this); } +IfcResourceApprovalRelationship::IfcResourceApprovalRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResourceApprovalRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcResourceApprovalRelationship::IfcResourceApprovalRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_RelatedResourceObjects, IfcApproval* v4_RelatingApproval) : IfcResourceLevelRelationship((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_RelatedResourceObjects)); e->setArgument(3,(v4_RelatingApproval)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcResourceConstraintRelationship -IfcConstraint* IfcResourceConstraintRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcResourceConstraintRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcEntityList::ptr IfcResourceConstraintRelationship::RelatedResourceObjects() const { return *entity->getArgument(3); } -void IfcResourceConstraintRelationship::setRelatedResourceObjects(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcResourceConstraintRelationship::is(Type::Enum v) const { return v == Type::IfcResourceConstraintRelationship || IfcResourceLevelRelationship::is(v); } -Type::Enum IfcResourceConstraintRelationship::type() const { return Type::IfcResourceConstraintRelationship; } +IfcConstraint* IfcResourceConstraintRelationship::RelatingConstraint() const { return (IfcConstraint*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcResourceConstraintRelationship::setRelatingConstraint(IfcConstraint* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +IfcEntityList::ptr IfcResourceConstraintRelationship::RelatedResourceObjects() const { return *data_->getArgument(3); } +void IfcResourceConstraintRelationship::setRelatedResourceObjects(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcResourceConstraintRelationship::declaration() const { return *IfcResourceConstraintRelationship_type; } Type::Enum IfcResourceConstraintRelationship::Class() { return Type::IfcResourceConstraintRelationship; } -IfcResourceConstraintRelationship::IfcResourceConstraintRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResourceConstraintRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcResourceConstraintRelationship::IfcResourceConstraintRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcEntityList::ptr v4_RelatedResourceObjects) : IfcResourceLevelRelationship((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_RelatingConstraint)); e->setArgument(3,(v4_RelatedResourceObjects)); entity = e; EntityBuffer::Add(this); } +IfcResourceConstraintRelationship::IfcResourceConstraintRelationship(IfcAbstractEntity* e) : IfcResourceLevelRelationship((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResourceConstraintRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcResourceConstraintRelationship::IfcResourceConstraintRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcEntityList::ptr v4_RelatedResourceObjects) : IfcResourceLevelRelationship((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_RelatingConstraint)); e->setArgument(3,(v4_RelatedResourceObjects)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcResourceLevelRelationship -bool IfcResourceLevelRelationship::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcResourceLevelRelationship::Name() const { return *entity->getArgument(0); } -void IfcResourceLevelRelationship::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcResourceLevelRelationship::hasDescription() const { return !entity->getArgument(1)->isNull(); } -std::string IfcResourceLevelRelationship::Description() const { return *entity->getArgument(1); } -void IfcResourceLevelRelationship::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcResourceLevelRelationship::is(Type::Enum v) const { return v == Type::IfcResourceLevelRelationship; } -Type::Enum IfcResourceLevelRelationship::type() const { return Type::IfcResourceLevelRelationship; } +bool IfcResourceLevelRelationship::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcResourceLevelRelationship::Name() const { return *data_->getArgument(0); } +void IfcResourceLevelRelationship::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcResourceLevelRelationship::hasDescription() const { return !data_->getArgument(1)->isNull(); } +std::string IfcResourceLevelRelationship::Description() const { return *data_->getArgument(1); } +void IfcResourceLevelRelationship::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcResourceLevelRelationship::declaration() const { return *IfcResourceLevelRelationship_type; } Type::Enum IfcResourceLevelRelationship::Class() { return Type::IfcResourceLevelRelationship; } -IfcResourceLevelRelationship::IfcResourceLevelRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcResourceLevelRelationship)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcResourceLevelRelationship::IfcResourceLevelRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description) : 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); } entity = e; EntityBuffer::Add(this); } +IfcResourceLevelRelationship::IfcResourceLevelRelationship(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcResourceLevelRelationship)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcResourceLevelRelationship::IfcResourceLevelRelationship(boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description) : 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); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcResourceTime -bool IfcResourceTime::hasScheduleWork() const { return !entity->getArgument(3)->isNull(); } -std::string IfcResourceTime::ScheduleWork() const { return *entity->getArgument(3); } -void IfcResourceTime::setScheduleWork(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcResourceTime::hasScheduleUsage() const { return !entity->getArgument(4)->isNull(); } -double IfcResourceTime::ScheduleUsage() const { return *entity->getArgument(4); } -void IfcResourceTime::setScheduleUsage(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcResourceTime::hasScheduleStart() const { return !entity->getArgument(5)->isNull(); } -std::string IfcResourceTime::ScheduleStart() const { return *entity->getArgument(5); } -void IfcResourceTime::setScheduleStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcResourceTime::hasScheduleFinish() const { return !entity->getArgument(6)->isNull(); } -std::string IfcResourceTime::ScheduleFinish() const { return *entity->getArgument(6); } -void IfcResourceTime::setScheduleFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcResourceTime::hasScheduleContour() const { return !entity->getArgument(7)->isNull(); } -std::string IfcResourceTime::ScheduleContour() const { return *entity->getArgument(7); } -void IfcResourceTime::setScheduleContour(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcResourceTime::hasLevelingDelay() const { return !entity->getArgument(8)->isNull(); } -std::string IfcResourceTime::LevelingDelay() const { return *entity->getArgument(8); } -void IfcResourceTime::setLevelingDelay(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcResourceTime::hasIsOverAllocated() const { return !entity->getArgument(9)->isNull(); } -bool IfcResourceTime::IsOverAllocated() const { return *entity->getArgument(9); } -void IfcResourceTime::setIsOverAllocated(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcResourceTime::hasStatusTime() const { return !entity->getArgument(10)->isNull(); } -std::string IfcResourceTime::StatusTime() const { return *entity->getArgument(10); } -void IfcResourceTime::setStatusTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcResourceTime::hasActualWork() const { return !entity->getArgument(11)->isNull(); } -std::string IfcResourceTime::ActualWork() const { return *entity->getArgument(11); } -void IfcResourceTime::setActualWork(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcResourceTime::hasActualUsage() const { return !entity->getArgument(12)->isNull(); } -double IfcResourceTime::ActualUsage() const { return *entity->getArgument(12); } -void IfcResourceTime::setActualUsage(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcResourceTime::hasActualStart() const { return !entity->getArgument(13)->isNull(); } -std::string IfcResourceTime::ActualStart() const { return *entity->getArgument(13); } -void IfcResourceTime::setActualStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcResourceTime::hasActualFinish() const { return !entity->getArgument(14)->isNull(); } -std::string IfcResourceTime::ActualFinish() const { return *entity->getArgument(14); } -void IfcResourceTime::setActualFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcResourceTime::hasRemainingWork() const { return !entity->getArgument(15)->isNull(); } -std::string IfcResourceTime::RemainingWork() const { return *entity->getArgument(15); } -void IfcResourceTime::setRemainingWork(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcResourceTime::hasRemainingUsage() const { return !entity->getArgument(16)->isNull(); } -double IfcResourceTime::RemainingUsage() const { return *entity->getArgument(16); } -void IfcResourceTime::setRemainingUsage(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcResourceTime::hasCompletion() const { return !entity->getArgument(17)->isNull(); } -double IfcResourceTime::Completion() const { return *entity->getArgument(17); } -void IfcResourceTime::setCompletion(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v); } -bool IfcResourceTime::is(Type::Enum v) const { return v == Type::IfcResourceTime || IfcSchedulingTime::is(v); } -Type::Enum IfcResourceTime::type() const { return Type::IfcResourceTime; } +bool IfcResourceTime::hasScheduleWork() const { return !data_->getArgument(3)->isNull(); } +std::string IfcResourceTime::ScheduleWork() const { return *data_->getArgument(3); } +void IfcResourceTime::setScheduleWork(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcResourceTime::hasScheduleUsage() const { return !data_->getArgument(4)->isNull(); } +double IfcResourceTime::ScheduleUsage() const { return *data_->getArgument(4); } +void IfcResourceTime::setScheduleUsage(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcResourceTime::hasScheduleStart() const { return !data_->getArgument(5)->isNull(); } +std::string IfcResourceTime::ScheduleStart() const { return *data_->getArgument(5); } +void IfcResourceTime::setScheduleStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcResourceTime::hasScheduleFinish() const { return !data_->getArgument(6)->isNull(); } +std::string IfcResourceTime::ScheduleFinish() const { return *data_->getArgument(6); } +void IfcResourceTime::setScheduleFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcResourceTime::hasScheduleContour() const { return !data_->getArgument(7)->isNull(); } +std::string IfcResourceTime::ScheduleContour() const { return *data_->getArgument(7); } +void IfcResourceTime::setScheduleContour(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcResourceTime::hasLevelingDelay() const { return !data_->getArgument(8)->isNull(); } +std::string IfcResourceTime::LevelingDelay() const { return *data_->getArgument(8); } +void IfcResourceTime::setLevelingDelay(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcResourceTime::hasIsOverAllocated() const { return !data_->getArgument(9)->isNull(); } +bool IfcResourceTime::IsOverAllocated() const { return *data_->getArgument(9); } +void IfcResourceTime::setIsOverAllocated(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcResourceTime::hasStatusTime() const { return !data_->getArgument(10)->isNull(); } +std::string IfcResourceTime::StatusTime() const { return *data_->getArgument(10); } +void IfcResourceTime::setStatusTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcResourceTime::hasActualWork() const { return !data_->getArgument(11)->isNull(); } +std::string IfcResourceTime::ActualWork() const { return *data_->getArgument(11); } +void IfcResourceTime::setActualWork(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcResourceTime::hasActualUsage() const { return !data_->getArgument(12)->isNull(); } +double IfcResourceTime::ActualUsage() const { return *data_->getArgument(12); } +void IfcResourceTime::setActualUsage(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcResourceTime::hasActualStart() const { return !data_->getArgument(13)->isNull(); } +std::string IfcResourceTime::ActualStart() const { return *data_->getArgument(13); } +void IfcResourceTime::setActualStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcResourceTime::hasActualFinish() const { return !data_->getArgument(14)->isNull(); } +std::string IfcResourceTime::ActualFinish() const { return *data_->getArgument(14); } +void IfcResourceTime::setActualFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcResourceTime::hasRemainingWork() const { return !data_->getArgument(15)->isNull(); } +std::string IfcResourceTime::RemainingWork() const { return *data_->getArgument(15); } +void IfcResourceTime::setRemainingWork(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcResourceTime::hasRemainingUsage() const { return !data_->getArgument(16)->isNull(); } +double IfcResourceTime::RemainingUsage() const { return *data_->getArgument(16); } +void IfcResourceTime::setRemainingUsage(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } +bool IfcResourceTime::hasCompletion() const { return !data_->getArgument(17)->isNull(); } +double IfcResourceTime::Completion() const { return *data_->getArgument(17); } +void IfcResourceTime::setCompletion(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v); } + + +const IfcParse::entity& IfcResourceTime::declaration() const { return *IfcResourceTime_type; } Type::Enum IfcResourceTime::Class() { return Type::IfcResourceTime; } -IfcResourceTime::IfcResourceTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResourceTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcResourceTime::IfcResourceTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< std::string > v4_ScheduleWork, boost::optional< double > v5_ScheduleUsage, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_ScheduleContour, boost::optional< std::string > v9_LevelingDelay, boost::optional< bool > v10_IsOverAllocated, boost::optional< std::string > v11_StatusTime, boost::optional< std::string > v12_ActualWork, boost::optional< double > v13_ActualUsage, boost::optional< std::string > v14_ActualStart, boost::optional< std::string > v15_ActualFinish, boost::optional< std::string > v16_RemainingWork, boost::optional< double > v17_RemainingUsage, boost::optional< double > v18_Completion) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_ScheduleWork) { e->setArgument(3,(*v4_ScheduleWork)); } else { e->setArgument(3); } if (v5_ScheduleUsage) { e->setArgument(4,(*v5_ScheduleUsage)); } else { e->setArgument(4); } if (v6_ScheduleStart) { e->setArgument(5,(*v6_ScheduleStart)); } else { e->setArgument(5); } if (v7_ScheduleFinish) { e->setArgument(6,(*v7_ScheduleFinish)); } else { e->setArgument(6); } if (v8_ScheduleContour) { e->setArgument(7,(*v8_ScheduleContour)); } else { e->setArgument(7); } if (v9_LevelingDelay) { e->setArgument(8,(*v9_LevelingDelay)); } else { e->setArgument(8); } if (v10_IsOverAllocated) { e->setArgument(9,(*v10_IsOverAllocated)); } else { e->setArgument(9); } if (v11_StatusTime) { e->setArgument(10,(*v11_StatusTime)); } else { e->setArgument(10); } if (v12_ActualWork) { e->setArgument(11,(*v12_ActualWork)); } else { e->setArgument(11); } if (v13_ActualUsage) { e->setArgument(12,(*v13_ActualUsage)); } else { e->setArgument(12); } if (v14_ActualStart) { e->setArgument(13,(*v14_ActualStart)); } else { e->setArgument(13); } if (v15_ActualFinish) { e->setArgument(14,(*v15_ActualFinish)); } else { e->setArgument(14); } if (v16_RemainingWork) { e->setArgument(15,(*v16_RemainingWork)); } else { e->setArgument(15); } if (v17_RemainingUsage) { e->setArgument(16,(*v17_RemainingUsage)); } else { e->setArgument(16); } if (v18_Completion) { e->setArgument(17,(*v18_Completion)); } else { e->setArgument(17); } entity = e; EntityBuffer::Add(this); } +IfcResourceTime::IfcResourceTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcResourceTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcResourceTime::IfcResourceTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< std::string > v4_ScheduleWork, boost::optional< double > v5_ScheduleUsage, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_ScheduleContour, boost::optional< std::string > v9_LevelingDelay, boost::optional< bool > v10_IsOverAllocated, boost::optional< std::string > v11_StatusTime, boost::optional< std::string > v12_ActualWork, boost::optional< double > v13_ActualUsage, boost::optional< std::string > v14_ActualStart, boost::optional< std::string > v15_ActualFinish, boost::optional< std::string > v16_RemainingWork, boost::optional< double > v17_RemainingUsage, boost::optional< double > v18_Completion) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_ScheduleWork) { e->setArgument(3,(*v4_ScheduleWork)); } else { e->setArgument(3); } if (v5_ScheduleUsage) { e->setArgument(4,(*v5_ScheduleUsage)); } else { e->setArgument(4); } if (v6_ScheduleStart) { e->setArgument(5,(*v6_ScheduleStart)); } else { e->setArgument(5); } if (v7_ScheduleFinish) { e->setArgument(6,(*v7_ScheduleFinish)); } else { e->setArgument(6); } if (v8_ScheduleContour) { e->setArgument(7,(*v8_ScheduleContour)); } else { e->setArgument(7); } if (v9_LevelingDelay) { e->setArgument(8,(*v9_LevelingDelay)); } else { e->setArgument(8); } if (v10_IsOverAllocated) { e->setArgument(9,(*v10_IsOverAllocated)); } else { e->setArgument(9); } if (v11_StatusTime) { e->setArgument(10,(*v11_StatusTime)); } else { e->setArgument(10); } if (v12_ActualWork) { e->setArgument(11,(*v12_ActualWork)); } else { e->setArgument(11); } if (v13_ActualUsage) { e->setArgument(12,(*v13_ActualUsage)); } else { e->setArgument(12); } if (v14_ActualStart) { e->setArgument(13,(*v14_ActualStart)); } else { e->setArgument(13); } if (v15_ActualFinish) { e->setArgument(14,(*v15_ActualFinish)); } else { e->setArgument(14); } if (v16_RemainingWork) { e->setArgument(15,(*v16_RemainingWork)); } else { e->setArgument(15); } if (v17_RemainingUsage) { e->setArgument(16,(*v17_RemainingUsage)); } else { e->setArgument(16); } if (v18_Completion) { e->setArgument(17,(*v18_Completion)); } else { e->setArgument(17); } 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 IfcRevolvedAreaSolidTapered -IfcProfileDef* IfcRevolvedAreaSolidTapered::EndSweptArea() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcRevolvedAreaSolidTapered::setEndSweptArea(IfcProfileDef* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcRevolvedAreaSolidTapered::is(Type::Enum v) const { return v == Type::IfcRevolvedAreaSolidTapered || IfcRevolvedAreaSolid::is(v); } -Type::Enum IfcRevolvedAreaSolidTapered::type() const { return Type::IfcRevolvedAreaSolidTapered; } +IfcProfileDef* IfcRevolvedAreaSolidTapered::EndSweptArea() const { return (IfcProfileDef*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcRevolvedAreaSolidTapered::setEndSweptArea(IfcProfileDef* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcRevolvedAreaSolidTapered::declaration() const { return *IfcRevolvedAreaSolidTapered_type; } Type::Enum IfcRevolvedAreaSolidTapered::Class() { return Type::IfcRevolvedAreaSolidTapered; } -IfcRevolvedAreaSolidTapered::IfcRevolvedAreaSolidTapered(IfcAbstractEntity* e) : IfcRevolvedAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRevolvedAreaSolidTapered)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRevolvedAreaSolidTapered::IfcRevolvedAreaSolidTapered(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_Axis, double v4_Angle, IfcProfileDef* v5_EndSweptArea) : IfcRevolvedAreaSolid((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)); e->setArgument(4,(v5_EndSweptArea)); entity = e; EntityBuffer::Add(this); } +IfcRevolvedAreaSolidTapered::IfcRevolvedAreaSolidTapered(IfcAbstractEntity* e) : IfcRevolvedAreaSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRevolvedAreaSolidTapered)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRevolvedAreaSolidTapered::IfcRevolvedAreaSolidTapered(IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_Axis, double v4_Angle, IfcProfileDef* v5_EndSweptArea) : IfcRevolvedAreaSolid((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)); e->setArgument(4,(v5_EndSweptArea)); 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 -bool IfcRoof::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoof::PredefinedType() const { return IfcRoofTypeEnum::FromString(*entity->getArgument(8)); } -void IfcRoof::setPredefinedType(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; } +bool IfcRoof::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoof::PredefinedType() const { return IfcRoofTypeEnum::FromString(*data_->getArgument(8)); } +void IfcRoof::setPredefinedType(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, boost::optional< IfcRoofTypeEnum::IfcRoofTypeEnum > 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,IfcRoofTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcRoofTypeEnum::IfcRoofTypeEnum > 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,IfcRoofTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcRoofType -IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoofType::PredefinedType() const { return IfcRoofTypeEnum::FromString(*entity->getArgument(9)); } -void IfcRoofType::setPredefinedType(IfcRoofTypeEnum::IfcRoofTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcRoofTypeEnum::ToString(v)); } -bool IfcRoofType::is(Type::Enum v) const { return v == Type::IfcRoofType || IfcBuildingElementType::is(v); } -Type::Enum IfcRoofType::type() const { return Type::IfcRoofType; } +IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoofType::PredefinedType() const { return IfcRoofTypeEnum::FromString(*data_->getArgument(9)); } +void IfcRoofType::setPredefinedType(IfcRoofTypeEnum::IfcRoofTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcRoofTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcRoofType::declaration() const { return *IfcRoofType_type; } Type::Enum IfcRoofType::Class() { return Type::IfcRoofType; } -IfcRoofType::IfcRoofType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoofType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcRoofType::IfcRoofType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRoofTypeEnum::IfcRoofTypeEnum 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,IfcRoofTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcRoofType::IfcRoofType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRoofType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcRoofType::IfcRoofType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRoofTypeEnum::IfcRoofTypeEnum 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,IfcRoofTypeEnum::ToString(v10_PredefinedType)); 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); } -bool IfcRoot::hasOwnerHistory() const { return !entity->getArgument(1)->isNull(); } -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); } +bool IfcRoot::hasOwnerHistory() const { return !data_->getArgument(1)->isNull(); } +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 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 IfcSanitaryTerminal -bool IfcSanitaryTerminal::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminal::PredefinedType() const { return IfcSanitaryTerminalTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSanitaryTerminal::setPredefinedType(IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSanitaryTerminalTypeEnum::ToString(v)); } -bool IfcSanitaryTerminal::is(Type::Enum v) const { return v == Type::IfcSanitaryTerminal || IfcFlowTerminal::is(v); } -Type::Enum IfcSanitaryTerminal::type() const { return Type::IfcSanitaryTerminal; } +bool IfcSanitaryTerminal::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminal::PredefinedType() const { return IfcSanitaryTerminalTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSanitaryTerminal::setPredefinedType(IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSanitaryTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSanitaryTerminal::declaration() const { return *IfcSanitaryTerminal_type; } Type::Enum IfcSanitaryTerminal::Class() { return Type::IfcSanitaryTerminal; } -IfcSanitaryTerminal::IfcSanitaryTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSanitaryTerminal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSanitaryTerminal::IfcSanitaryTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSanitaryTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSanitaryTerminal::IfcSanitaryTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSanitaryTerminal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSanitaryTerminal::IfcSanitaryTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSanitaryTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcSchedulingTime -bool IfcSchedulingTime::hasName() const { return !entity->getArgument(0)->isNull(); } -std::string IfcSchedulingTime::Name() const { return *entity->getArgument(0); } -void IfcSchedulingTime::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcSchedulingTime::hasDataOrigin() const { return !entity->getArgument(1)->isNull(); } -IfcDataOriginEnum::IfcDataOriginEnum IfcSchedulingTime::DataOrigin() const { return IfcDataOriginEnum::FromString(*entity->getArgument(1)); } -void IfcSchedulingTime::setDataOrigin(IfcDataOriginEnum::IfcDataOriginEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v,IfcDataOriginEnum::ToString(v)); } -bool IfcSchedulingTime::hasUserDefinedDataOrigin() const { return !entity->getArgument(2)->isNull(); } -std::string IfcSchedulingTime::UserDefinedDataOrigin() const { return *entity->getArgument(2); } -void IfcSchedulingTime::setUserDefinedDataOrigin(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSchedulingTime::is(Type::Enum v) const { return v == Type::IfcSchedulingTime; } -Type::Enum IfcSchedulingTime::type() const { return Type::IfcSchedulingTime; } +bool IfcSchedulingTime::hasName() const { return !data_->getArgument(0)->isNull(); } +std::string IfcSchedulingTime::Name() const { return *data_->getArgument(0); } +void IfcSchedulingTime::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcSchedulingTime::hasDataOrigin() const { return !data_->getArgument(1)->isNull(); } +IfcDataOriginEnum::IfcDataOriginEnum IfcSchedulingTime::DataOrigin() const { return IfcDataOriginEnum::FromString(*data_->getArgument(1)); } +void IfcSchedulingTime::setDataOrigin(IfcDataOriginEnum::IfcDataOriginEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v,IfcDataOriginEnum::ToString(v)); } +bool IfcSchedulingTime::hasUserDefinedDataOrigin() const { return !data_->getArgument(2)->isNull(); } +std::string IfcSchedulingTime::UserDefinedDataOrigin() const { return *data_->getArgument(2); } +void IfcSchedulingTime::setUserDefinedDataOrigin(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcSchedulingTime::declaration() const { return *IfcSchedulingTime_type; } Type::Enum IfcSchedulingTime::Class() { return Type::IfcSchedulingTime; } -IfcSchedulingTime::IfcSchedulingTime(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSchedulingTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSchedulingTime::IfcSchedulingTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcSchedulingTime::IfcSchedulingTime(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcSchedulingTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSchedulingTime::IfcSchedulingTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } 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 || IfcPreDefinedProperties::is(v); } -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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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 || IfcPreDefinedProperties::is(v); } -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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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) : IfcPreDefinedProperties((IfcAbstractEntity*)0) { 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 IfcSensor -bool IfcSensor::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensor::PredefinedType() const { return IfcSensorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSensor::setPredefinedType(IfcSensorTypeEnum::IfcSensorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSensorTypeEnum::ToString(v)); } -bool IfcSensor::is(Type::Enum v) const { return v == Type::IfcSensor || IfcDistributionControlElement::is(v); } -Type::Enum IfcSensor::type() const { return Type::IfcSensor; } +bool IfcSensor::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensor::PredefinedType() const { return IfcSensorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSensor::setPredefinedType(IfcSensorTypeEnum::IfcSensorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSensorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSensor::declaration() const { return *IfcSensor_type; } Type::Enum IfcSensor::Class() { return Type::IfcSensor; } -IfcSensor::IfcSensor(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSensor)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSensor::IfcSensor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSensorTypeEnum::IfcSensorTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSensorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSensor::IfcSensor(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSensor)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSensor::IfcSensor(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSensorTypeEnum::IfcSensorTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSensorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcShadingDevice -bool IfcShadingDevice::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum IfcShadingDevice::PredefinedType() const { return IfcShadingDeviceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcShadingDevice::setPredefinedType(IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcShadingDeviceTypeEnum::ToString(v)); } -bool IfcShadingDevice::is(Type::Enum v) const { return v == Type::IfcShadingDevice || IfcBuildingElement::is(v); } -Type::Enum IfcShadingDevice::type() const { return Type::IfcShadingDevice; } +bool IfcShadingDevice::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum IfcShadingDevice::PredefinedType() const { return IfcShadingDeviceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcShadingDevice::setPredefinedType(IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcShadingDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcShadingDevice::declaration() const { return *IfcShadingDevice_type; } Type::Enum IfcShadingDevice::Class() { return Type::IfcShadingDevice; } -IfcShadingDevice::IfcShadingDevice(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShadingDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcShadingDevice::IfcShadingDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum > 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,IfcShadingDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcShadingDevice::IfcShadingDevice(IfcAbstractEntity* e) : IfcBuildingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShadingDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcShadingDevice::IfcShadingDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum > 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,IfcShadingDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcShadingDeviceType -IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum IfcShadingDeviceType::PredefinedType() const { return IfcShadingDeviceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcShadingDeviceType::setPredefinedType(IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcShadingDeviceTypeEnum::ToString(v)); } -bool IfcShadingDeviceType::is(Type::Enum v) const { return v == Type::IfcShadingDeviceType || IfcBuildingElementType::is(v); } -Type::Enum IfcShadingDeviceType::type() const { return Type::IfcShadingDeviceType; } +IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum IfcShadingDeviceType::PredefinedType() const { return IfcShadingDeviceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcShadingDeviceType::setPredefinedType(IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcShadingDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcShadingDeviceType::declaration() const { return *IfcShadingDeviceType_type; } Type::Enum IfcShadingDeviceType::Class() { return Type::IfcShadingDeviceType; } -IfcShadingDeviceType::IfcShadingDeviceType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShadingDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcShadingDeviceType::IfcShadingDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum 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,IfcShadingDeviceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcShadingDeviceType::IfcShadingDeviceType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcShadingDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcShadingDeviceType::IfcShadingDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum 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,IfcShadingDeviceTypeEnum::ToString(v10_PredefinedType)); 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); } -bool IfcShapeAspect::hasPartOfProductDefinitionShape() const { return !entity->getArgument(4)->isNull(); } -IfcProductRepresentationSelect* IfcShapeAspect::PartOfProductDefinitionShape() const { return (IfcProductRepresentationSelect*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcShapeAspect::setPartOfProductDefinitionShape(IfcProductRepresentationSelect* 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); } +bool IfcShapeAspect::hasPartOfProductDefinitionShape() const { return !data_->getArgument(4)->isNull(); } +IfcProductRepresentationSelect* IfcShapeAspect::PartOfProductDefinitionShape() const { return (IfcProductRepresentationSelect*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcShapeAspect::setPartOfProductDefinitionShape(IfcProductRepresentationSelect* 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, IfcProductRepresentationSelect* 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, IfcProductRepresentationSelect* 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 IfcSimplePropertyTemplate -bool IfcSimplePropertyTemplate::hasTemplateType() const { return !entity->getArgument(4)->isNull(); } -IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum IfcSimplePropertyTemplate::TemplateType() const { return IfcSimplePropertyTemplateTypeEnum::FromString(*entity->getArgument(4)); } -void IfcSimplePropertyTemplate::setTemplateType(IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v,IfcSimplePropertyTemplateTypeEnum::ToString(v)); } -bool IfcSimplePropertyTemplate::hasPrimaryMeasureType() const { return !entity->getArgument(5)->isNull(); } -std::string IfcSimplePropertyTemplate::PrimaryMeasureType() const { return *entity->getArgument(5); } -void IfcSimplePropertyTemplate::setPrimaryMeasureType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcSimplePropertyTemplate::hasSecondaryMeasureType() const { return !entity->getArgument(6)->isNull(); } -std::string IfcSimplePropertyTemplate::SecondaryMeasureType() const { return *entity->getArgument(6); } -void IfcSimplePropertyTemplate::setSecondaryMeasureType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcSimplePropertyTemplate::hasEnumerators() const { return !entity->getArgument(7)->isNull(); } -IfcPropertyEnumeration* IfcSimplePropertyTemplate::Enumerators() const { return (IfcPropertyEnumeration*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(7))); } -void IfcSimplePropertyTemplate::setEnumerators(IfcPropertyEnumeration* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcSimplePropertyTemplate::hasPrimaryUnit() const { return !entity->getArgument(8)->isNull(); } -IfcUnit* IfcSimplePropertyTemplate::PrimaryUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcSimplePropertyTemplate::setPrimaryUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcSimplePropertyTemplate::hasSecondaryUnit() const { return !entity->getArgument(9)->isNull(); } -IfcUnit* IfcSimplePropertyTemplate::SecondaryUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcSimplePropertyTemplate::setSecondaryUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcSimplePropertyTemplate::hasExpression() const { return !entity->getArgument(10)->isNull(); } -std::string IfcSimplePropertyTemplate::Expression() const { return *entity->getArgument(10); } -void IfcSimplePropertyTemplate::setExpression(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcSimplePropertyTemplate::hasAccessState() const { return !entity->getArgument(11)->isNull(); } -IfcStateEnum::IfcStateEnum IfcSimplePropertyTemplate::AccessState() const { return IfcStateEnum::FromString(*entity->getArgument(11)); } -void IfcSimplePropertyTemplate::setAccessState(IfcStateEnum::IfcStateEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcStateEnum::ToString(v)); } -bool IfcSimplePropertyTemplate::is(Type::Enum v) const { return v == Type::IfcSimplePropertyTemplate || IfcPropertyTemplate::is(v); } -Type::Enum IfcSimplePropertyTemplate::type() const { return Type::IfcSimplePropertyTemplate; } +bool IfcSimplePropertyTemplate::hasTemplateType() const { return !data_->getArgument(4)->isNull(); } +IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum IfcSimplePropertyTemplate::TemplateType() const { return IfcSimplePropertyTemplateTypeEnum::FromString(*data_->getArgument(4)); } +void IfcSimplePropertyTemplate::setTemplateType(IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v,IfcSimplePropertyTemplateTypeEnum::ToString(v)); } +bool IfcSimplePropertyTemplate::hasPrimaryMeasureType() const { return !data_->getArgument(5)->isNull(); } +std::string IfcSimplePropertyTemplate::PrimaryMeasureType() const { return *data_->getArgument(5); } +void IfcSimplePropertyTemplate::setPrimaryMeasureType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcSimplePropertyTemplate::hasSecondaryMeasureType() const { return !data_->getArgument(6)->isNull(); } +std::string IfcSimplePropertyTemplate::SecondaryMeasureType() const { return *data_->getArgument(6); } +void IfcSimplePropertyTemplate::setSecondaryMeasureType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcSimplePropertyTemplate::hasEnumerators() const { return !data_->getArgument(7)->isNull(); } +IfcPropertyEnumeration* IfcSimplePropertyTemplate::Enumerators() const { return (IfcPropertyEnumeration*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(7))); } +void IfcSimplePropertyTemplate::setEnumerators(IfcPropertyEnumeration* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcSimplePropertyTemplate::hasPrimaryUnit() const { return !data_->getArgument(8)->isNull(); } +IfcUnit* IfcSimplePropertyTemplate::PrimaryUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcSimplePropertyTemplate::setPrimaryUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcSimplePropertyTemplate::hasSecondaryUnit() const { return !data_->getArgument(9)->isNull(); } +IfcUnit* IfcSimplePropertyTemplate::SecondaryUnit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcSimplePropertyTemplate::setSecondaryUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcSimplePropertyTemplate::hasExpression() const { return !data_->getArgument(10)->isNull(); } +std::string IfcSimplePropertyTemplate::Expression() const { return *data_->getArgument(10); } +void IfcSimplePropertyTemplate::setExpression(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcSimplePropertyTemplate::hasAccessState() const { return !data_->getArgument(11)->isNull(); } +IfcStateEnum::IfcStateEnum IfcSimplePropertyTemplate::AccessState() const { return IfcStateEnum::FromString(*data_->getArgument(11)); } +void IfcSimplePropertyTemplate::setAccessState(IfcStateEnum::IfcStateEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcStateEnum::ToString(v)); } + + +const IfcParse::entity& IfcSimplePropertyTemplate::declaration() const { return *IfcSimplePropertyTemplate_type; } Type::Enum IfcSimplePropertyTemplate::Class() { return Type::IfcSimplePropertyTemplate; } -IfcSimplePropertyTemplate::IfcSimplePropertyTemplate(IfcAbstractEntity* e) : IfcPropertyTemplate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSimplePropertyTemplate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSimplePropertyTemplate::IfcSimplePropertyTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum > v5_TemplateType, boost::optional< std::string > v6_PrimaryMeasureType, boost::optional< std::string > v7_SecondaryMeasureType, IfcPropertyEnumeration* v8_Enumerators, IfcUnit* v9_PrimaryUnit, IfcUnit* v10_SecondaryUnit, boost::optional< std::string > v11_Expression, boost::optional< IfcStateEnum::IfcStateEnum > v12_AccessState) : IfcPropertyTemplate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_TemplateType) { e->setArgument(4,*v5_TemplateType,IfcSimplePropertyTemplateTypeEnum::ToString(*v5_TemplateType)); } else { e->setArgument(4); } if (v6_PrimaryMeasureType) { e->setArgument(5,(*v6_PrimaryMeasureType)); } else { e->setArgument(5); } if (v7_SecondaryMeasureType) { e->setArgument(6,(*v7_SecondaryMeasureType)); } else { e->setArgument(6); } e->setArgument(7,(v8_Enumerators)); e->setArgument(8,(v9_PrimaryUnit)); e->setArgument(9,(v10_SecondaryUnit)); if (v11_Expression) { e->setArgument(10,(*v11_Expression)); } else { e->setArgument(10); } if (v12_AccessState) { e->setArgument(11,*v12_AccessState,IfcStateEnum::ToString(*v12_AccessState)); } else { e->setArgument(11); } entity = e; EntityBuffer::Add(this); } +IfcSimplePropertyTemplate::IfcSimplePropertyTemplate(IfcAbstractEntity* e) : IfcPropertyTemplate((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSimplePropertyTemplate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSimplePropertyTemplate::IfcSimplePropertyTemplate(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum > v5_TemplateType, boost::optional< std::string > v6_PrimaryMeasureType, boost::optional< std::string > v7_SecondaryMeasureType, IfcPropertyEnumeration* v8_Enumerators, IfcUnit* v9_PrimaryUnit, IfcUnit* v10_SecondaryUnit, boost::optional< std::string > v11_Expression, boost::optional< IfcStateEnum::IfcStateEnum > v12_AccessState) : IfcPropertyTemplate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } if (v4_Description) { e->setArgument(3,(*v4_Description)); } else { e->setArgument(3); } if (v5_TemplateType) { e->setArgument(4,*v5_TemplateType,IfcSimplePropertyTemplateTypeEnum::ToString(*v5_TemplateType)); } else { e->setArgument(4); } if (v6_PrimaryMeasureType) { e->setArgument(5,(*v6_PrimaryMeasureType)); } else { e->setArgument(5); } if (v7_SecondaryMeasureType) { e->setArgument(6,(*v7_SecondaryMeasureType)); } else { e->setArgument(6); } e->setArgument(7,(v8_Enumerators)); e->setArgument(8,(v9_PrimaryUnit)); e->setArgument(9,(v10_SecondaryUnit)); if (v11_Expression) { e->setArgument(10,(*v11_Expression)); } else { e->setArgument(10); } if (v12_AccessState) { e->setArgument(11,*v12_AccessState,IfcStateEnum::ToString(*v12_AccessState)); } else { e->setArgument(11); } 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, boost::optional< 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } 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, boost::optional< 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } 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 IfcSlabElementedCase -bool IfcSlabElementedCase::is(Type::Enum v) const { return v == Type::IfcSlabElementedCase || IfcSlab::is(v); } -Type::Enum IfcSlabElementedCase::type() const { return Type::IfcSlabElementedCase; } + + +const IfcParse::entity& IfcSlabElementedCase::declaration() const { return *IfcSlabElementedCase_type; } Type::Enum IfcSlabElementedCase::Class() { return Type::IfcSlabElementedCase; } -IfcSlabElementedCase::IfcSlabElementedCase(IfcAbstractEntity* e) : IfcSlab((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlabElementedCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSlabElementedCase::IfcSlabElementedCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : IfcSlab((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } +IfcSlabElementedCase::IfcSlabElementedCase(IfcAbstractEntity* e) : IfcSlab((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlabElementedCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSlabElementedCase::IfcSlabElementedCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : IfcSlab((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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 IfcSlabStandardCase -bool IfcSlabStandardCase::is(Type::Enum v) const { return v == Type::IfcSlabStandardCase || IfcSlab::is(v); } -Type::Enum IfcSlabStandardCase::type() const { return Type::IfcSlabStandardCase; } + + +const IfcParse::entity& IfcSlabStandardCase::declaration() const { return *IfcSlabStandardCase_type; } Type::Enum IfcSlabStandardCase::Class() { return Type::IfcSlabStandardCase; } -IfcSlabStandardCase::IfcSlabStandardCase(IfcAbstractEntity* e) : IfcSlab((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlabStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSlabStandardCase::IfcSlabStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : IfcSlab((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } +IfcSlabStandardCase::IfcSlabStandardCase(IfcAbstractEntity* e) : IfcSlab((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSlabStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSlabStandardCase::IfcSlabStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : IfcSlab((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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 IfcSolarDevice -bool IfcSolarDevice::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum IfcSolarDevice::PredefinedType() const { return IfcSolarDeviceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSolarDevice::setPredefinedType(IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSolarDeviceTypeEnum::ToString(v)); } -bool IfcSolarDevice::is(Type::Enum v) const { return v == Type::IfcSolarDevice || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcSolarDevice::type() const { return Type::IfcSolarDevice; } +bool IfcSolarDevice::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum IfcSolarDevice::PredefinedType() const { return IfcSolarDeviceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSolarDevice::setPredefinedType(IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSolarDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSolarDevice::declaration() const { return *IfcSolarDevice_type; } Type::Enum IfcSolarDevice::Class() { return Type::IfcSolarDevice; } -IfcSolarDevice::IfcSolarDevice(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSolarDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSolarDevice::IfcSolarDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSolarDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSolarDevice::IfcSolarDevice(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSolarDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSolarDevice::IfcSolarDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSolarDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSolarDeviceType -IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum IfcSolarDeviceType::PredefinedType() const { return IfcSolarDeviceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSolarDeviceType::setPredefinedType(IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSolarDeviceTypeEnum::ToString(v)); } -bool IfcSolarDeviceType::is(Type::Enum v) const { return v == Type::IfcSolarDeviceType || IfcEnergyConversionDeviceType::is(v); } -Type::Enum IfcSolarDeviceType::type() const { return Type::IfcSolarDeviceType; } +IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum IfcSolarDeviceType::PredefinedType() const { return IfcSolarDeviceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSolarDeviceType::setPredefinedType(IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSolarDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSolarDeviceType::declaration() const { return *IfcSolarDeviceType_type; } Type::Enum IfcSolarDeviceType::Class() { return Type::IfcSolarDeviceType; } -IfcSolarDeviceType::IfcSolarDeviceType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSolarDeviceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSolarDeviceType::IfcSolarDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum 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,IfcSolarDeviceTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSolarDeviceType::IfcSolarDeviceType(IfcAbstractEntity* e) : IfcEnergyConversionDeviceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSolarDeviceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSolarDeviceType::IfcSolarDeviceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum 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,IfcSolarDeviceTypeEnum::ToString(v10_PredefinedType)); 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 IfcSpace -bool IfcSpace::hasPredefinedType() const { return !entity->getArgument(9)->isNull(); } -IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpace::PredefinedType() const { return IfcSpaceTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSpace::setPredefinedType(IfcSpaceTypeEnum::IfcSpaceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSpaceTypeEnum::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; } +bool IfcSpace::hasPredefinedType() const { return !data_->getArgument(9)->isNull(); } +IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpace::PredefinedType() const { return IfcSpaceTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSpace::setPredefinedType(IfcSpaceTypeEnum::IfcSpaceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSpaceTypeEnum::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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType, boost::optional< IfcSpaceTypeEnum::IfcSpaceTypeEnum > v10_PredefinedType, 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcSpaceTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } 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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType, boost::optional< IfcSpaceTypeEnum::IfcSpaceTypeEnum > v10_PredefinedType, 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcSpaceTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } if (v11_ElevationWithFlooring) { e->setArgument(10,(*v11_ElevationWithFlooring)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpaceHeater -bool IfcSpaceHeater::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeater::PredefinedType() const { return IfcSpaceHeaterTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSpaceHeater::setPredefinedType(IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSpaceHeaterTypeEnum::ToString(v)); } -bool IfcSpaceHeater::is(Type::Enum v) const { return v == Type::IfcSpaceHeater || IfcFlowTerminal::is(v); } -Type::Enum IfcSpaceHeater::type() const { return Type::IfcSpaceHeater; } +bool IfcSpaceHeater::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeater::PredefinedType() const { return IfcSpaceHeaterTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSpaceHeater::setPredefinedType(IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSpaceHeaterTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSpaceHeater::declaration() const { return *IfcSpaceHeater_type; } Type::Enum IfcSpaceHeater::Class() { return Type::IfcSpaceHeater; } -IfcSpaceHeater::IfcSpaceHeater(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceHeater)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpaceHeater::IfcSpaceHeater(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSpaceHeaterTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSpaceHeater::IfcSpaceHeater(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpaceHeater)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpaceHeater::IfcSpaceHeater(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSpaceHeaterTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 || IfcFlowTerminalType::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) : IfcFlowTerminalType((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) : 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,IfcSpaceHeaterTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSpaceHeaterType::IfcSpaceHeaterType(IfcAbstractEntity* e) : IfcFlowTerminalType((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) : 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,IfcSpaceHeaterTypeEnum::ToString(v10_PredefinedType)); 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::hasLongName() const { return !entity->getArgument(10)->isNull(); } -std::string IfcSpaceType::LongName() const { return *entity->getArgument(10); } -void IfcSpaceType::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,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)); } +bool IfcSpaceType::hasLongName() const { return !data_->getArgument(10)->isNull(); } +std::string IfcSpaceType::LongName() const { return *data_->getArgument(10); } +void IfcSpaceType::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,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, boost::optional< std::string > v11_LongName) : 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)); if (v11_LongName) { e->setArgument(10,(*v11_LongName)); } else { e->setArgument(10); } 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, boost::optional< std::string > v11_LongName) : 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)); if (v11_LongName) { e->setArgument(10,(*v11_LongName)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpatialElement -bool IfcSpatialElement::hasLongName() const { return !entity->getArgument(7)->isNull(); } -std::string IfcSpatialElement::LongName() const { return *entity->getArgument(7); } -void IfcSpatialElement::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -IfcRelContainedInSpatialStructure::list::ptr IfcSpatialElement::ContainsElements() const { return entity->getInverse(Type::IfcRelContainedInSpatialStructure, 5)->as(); } -IfcRelServicesBuildings::list::ptr IfcSpatialElement::ServicedBySystems() const { return entity->getInverse(Type::IfcRelServicesBuildings, 5)->as(); } -IfcRelReferencedInSpatialStructure::list::ptr IfcSpatialElement::ReferencesElements() const { return entity->getInverse(Type::IfcRelReferencedInSpatialStructure, 5)->as(); } -bool IfcSpatialElement::is(Type::Enum v) const { return v == Type::IfcSpatialElement || IfcProduct::is(v); } -Type::Enum IfcSpatialElement::type() const { return Type::IfcSpatialElement; } +bool IfcSpatialElement::hasLongName() const { return !data_->getArgument(7)->isNull(); } +std::string IfcSpatialElement::LongName() const { return *data_->getArgument(7); } +void IfcSpatialElement::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } + +IfcRelContainedInSpatialStructure::list::ptr IfcSpatialElement::ContainsElements() const { return data_->getInverse(Type::IfcRelContainedInSpatialStructure, 5)->as(); } +IfcRelServicesBuildings::list::ptr IfcSpatialElement::ServicedBySystems() const { return data_->getInverse(Type::IfcRelServicesBuildings, 5)->as(); } +IfcRelReferencedInSpatialStructure::list::ptr IfcSpatialElement::ReferencesElements() const { return data_->getInverse(Type::IfcRelReferencedInSpatialStructure, 5)->as(); } + +const IfcParse::entity& IfcSpatialElement::declaration() const { return *IfcSpatialElement_type; } Type::Enum IfcSpatialElement::Class() { return Type::IfcSpatialElement; } -IfcSpatialElement::IfcSpatialElement(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpatialElement::IfcSpatialElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : 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); } entity = e; EntityBuffer::Add(this); } +IfcSpatialElement::IfcSpatialElement(IfcAbstractEntity* e) : IfcProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpatialElement::IfcSpatialElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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) : 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); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpatialElementType -bool IfcSpatialElementType::hasElementType() const { return !entity->getArgument(8)->isNull(); } -std::string IfcSpatialElementType::ElementType() const { return *entity->getArgument(8); } -void IfcSpatialElementType::setElementType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcSpatialElementType::is(Type::Enum v) const { return v == Type::IfcSpatialElementType || IfcTypeProduct::is(v); } -Type::Enum IfcSpatialElementType::type() const { return Type::IfcSpatialElementType; } +bool IfcSpatialElementType::hasElementType() const { return !data_->getArgument(8)->isNull(); } +std::string IfcSpatialElementType::ElementType() const { return *data_->getArgument(8); } +void IfcSpatialElementType::setElementType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +const IfcParse::entity& IfcSpatialElementType::declaration() const { return *IfcSpatialElementType_type; } Type::Enum IfcSpatialElementType::Class() { return Type::IfcSpatialElementType; } -IfcSpatialElementType::IfcSpatialElementType(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpatialElementType::IfcSpatialElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< 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); } +IfcSpatialElementType::IfcSpatialElementType(IfcAbstractEntity* e) : IfcTypeProduct((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpatialElementType::IfcSpatialElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< 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 IfcSpatialStructureElement -bool IfcSpatialStructureElement::hasCompositionType() const { return !entity->getArgument(8)->isNull(); } -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)); } -bool IfcSpatialStructureElement::is(Type::Enum v) const { return v == Type::IfcSpatialStructureElement || IfcSpatialElement::is(v); } -Type::Enum IfcSpatialStructureElement::type() const { return Type::IfcSpatialStructureElement; } +bool IfcSpatialStructureElement::hasCompositionType() const { return !data_->getArgument(8)->isNull(); } +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)); } + + +const IfcParse::entity& IfcSpatialStructureElement::declaration() const { return *IfcSpatialStructureElement_type; } Type::Enum IfcSpatialStructureElement::Class() { return Type::IfcSpatialStructureElement; } -IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntity* e) : IfcSpatialElement((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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType) : IfcSpatialElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntity* e) : IfcSpatialElement((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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType) : IfcSpatialElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v9_CompositionType) { e->setArgument(8,*v9_CompositionType,IfcElementCompositionEnum::ToString(*v9_CompositionType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpatialStructureElementType -bool IfcSpatialStructureElementType::is(Type::Enum v) const { return v == Type::IfcSpatialStructureElementType || IfcSpatialElementType::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) : IfcSpatialElementType((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) : IfcSpatialElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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) : IfcSpatialElementType((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) : IfcSpatialElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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 IfcSpatialZone -bool IfcSpatialZone::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum IfcSpatialZone::PredefinedType() const { return IfcSpatialZoneTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSpatialZone::setPredefinedType(IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSpatialZoneTypeEnum::ToString(v)); } -bool IfcSpatialZone::is(Type::Enum v) const { return v == Type::IfcSpatialZone || IfcSpatialElement::is(v); } -Type::Enum IfcSpatialZone::type() const { return Type::IfcSpatialZone; } +bool IfcSpatialZone::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum IfcSpatialZone::PredefinedType() const { return IfcSpatialZoneTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSpatialZone::setPredefinedType(IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSpatialZoneTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSpatialZone::declaration() const { return *IfcSpatialZone_type; } Type::Enum IfcSpatialZone::Class() { return Type::IfcSpatialZone; } -IfcSpatialZone::IfcSpatialZone(IfcAbstractEntity* e) : IfcSpatialElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialZone)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpatialZone::IfcSpatialZone(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum > v9_PredefinedType) : IfcSpatialElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSpatialZoneTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSpatialZone::IfcSpatialZone(IfcAbstractEntity* e) : IfcSpatialElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialZone)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpatialZone::IfcSpatialZone(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum > v9_PredefinedType) : IfcSpatialElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSpatialZoneTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSpatialZoneType -IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum IfcSpatialZoneType::PredefinedType() const { return IfcSpatialZoneTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSpatialZoneType::setPredefinedType(IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSpatialZoneTypeEnum::ToString(v)); } -bool IfcSpatialZoneType::hasLongName() const { return !entity->getArgument(10)->isNull(); } -std::string IfcSpatialZoneType::LongName() const { return *entity->getArgument(10); } -void IfcSpatialZoneType::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcSpatialZoneType::is(Type::Enum v) const { return v == Type::IfcSpatialZoneType || IfcSpatialElementType::is(v); } -Type::Enum IfcSpatialZoneType::type() const { return Type::IfcSpatialZoneType; } +IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum IfcSpatialZoneType::PredefinedType() const { return IfcSpatialZoneTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSpatialZoneType::setPredefinedType(IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSpatialZoneTypeEnum::ToString(v)); } +bool IfcSpatialZoneType::hasLongName() const { return !data_->getArgument(10)->isNull(); } +std::string IfcSpatialZoneType::LongName() const { return *data_->getArgument(10); } +void IfcSpatialZoneType::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcSpatialZoneType::declaration() const { return *IfcSpatialZoneType_type; } Type::Enum IfcSpatialZoneType::Class() { return Type::IfcSpatialZoneType; } -IfcSpatialZoneType::IfcSpatialZoneType(IfcAbstractEntity* e) : IfcSpatialElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialZoneType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSpatialZoneType::IfcSpatialZoneType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v10_PredefinedType, boost::optional< std::string > v11_LongName) : IfcSpatialElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcSpatialZoneTypeEnum::ToString(v10_PredefinedType)); if (v11_LongName) { e->setArgument(10,(*v11_LongName)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcSpatialZoneType::IfcSpatialZoneType(IfcAbstractEntity* e) : IfcSpatialElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSpatialZoneType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSpatialZoneType::IfcSpatialZoneType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v10_PredefinedType, boost::optional< std::string > v11_LongName) : IfcSpatialElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcSpatialZoneTypeEnum::ToString(v10_PredefinedType)); if (v11_LongName) { e->setArgument(10,(*v11_LongName)); } else { e->setArgument(10); } 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 IfcStackTerminal -bool IfcStackTerminal::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminal::PredefinedType() const { return IfcStackTerminalTypeEnum::FromString(*entity->getArgument(8)); } -void IfcStackTerminal::setPredefinedType(IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcStackTerminalTypeEnum::ToString(v)); } -bool IfcStackTerminal::is(Type::Enum v) const { return v == Type::IfcStackTerminal || IfcFlowTerminal::is(v); } -Type::Enum IfcStackTerminal::type() const { return Type::IfcStackTerminal; } +bool IfcStackTerminal::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminal::PredefinedType() const { return IfcStackTerminalTypeEnum::FromString(*data_->getArgument(8)); } +void IfcStackTerminal::setPredefinedType(IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcStackTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStackTerminal::declaration() const { return *IfcStackTerminal_type; } Type::Enum IfcStackTerminal::Class() { return Type::IfcStackTerminal; } -IfcStackTerminal::IfcStackTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStackTerminal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStackTerminal::IfcStackTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcStackTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcStackTerminal::IfcStackTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStackTerminal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStackTerminal::IfcStackTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcStackTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 -bool IfcStair::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcStairTypeEnum::IfcStairTypeEnum IfcStair::PredefinedType() const { return IfcStairTypeEnum::FromString(*entity->getArgument(8)); } -void IfcStair::setPredefinedType(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; } +bool IfcStair::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcStairTypeEnum::IfcStairTypeEnum IfcStair::PredefinedType() const { return IfcStairTypeEnum::FromString(*data_->getArgument(8)); } +void IfcStair::setPredefinedType(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, boost::optional< IfcStairTypeEnum::IfcStairTypeEnum > 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,IfcStairTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcStairTypeEnum::IfcStairTypeEnum > 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,IfcStairTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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::hasPredefinedType() const { return !entity->getArgument(12)->isNull(); } -IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlight::PredefinedType() const { return IfcStairFlightTypeEnum::FromString(*entity->getArgument(12)); } -void IfcStairFlight::setPredefinedType(IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v,IfcStairFlightTypeEnum::ToString(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); } +bool IfcStairFlight::hasPredefinedType() const { return !data_->getArgument(12)->isNull(); } +IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlight::PredefinedType() const { return IfcStairFlightTypeEnum::FromString(*data_->getArgument(12)); } +void IfcStairFlight::setPredefinedType(IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v,IfcStairFlightTypeEnum::ToString(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, boost::optional< IfcStairFlightTypeEnum::IfcStairFlightTypeEnum > v13_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_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); } if (v13_PredefinedType) { e->setArgument(12,*v13_PredefinedType,IfcStairFlightTypeEnum::ToString(*v13_PredefinedType)); } else { e->setArgument(12); } 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, boost::optional< IfcStairFlightTypeEnum::IfcStairFlightTypeEnum > v13_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_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); } if (v13_PredefinedType) { e->setArgument(12,*v13_PredefinedType,IfcStairFlightTypeEnum::ToString(*v13_PredefinedType)); } else { e->setArgument(12); } 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 IfcStairType -IfcStairTypeEnum::IfcStairTypeEnum IfcStairType::PredefinedType() const { return IfcStairTypeEnum::FromString(*entity->getArgument(9)); } -void IfcStairType::setPredefinedType(IfcStairTypeEnum::IfcStairTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcStairTypeEnum::ToString(v)); } -bool IfcStairType::is(Type::Enum v) const { return v == Type::IfcStairType || IfcBuildingElementType::is(v); } -Type::Enum IfcStairType::type() const { return Type::IfcStairType; } +IfcStairTypeEnum::IfcStairTypeEnum IfcStairType::PredefinedType() const { return IfcStairTypeEnum::FromString(*data_->getArgument(9)); } +void IfcStairType::setPredefinedType(IfcStairTypeEnum::IfcStairTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcStairTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStairType::declaration() const { return *IfcStairType_type; } Type::Enum IfcStairType::Class() { return Type::IfcStairType; } -IfcStairType::IfcStairType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStairType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStairType::IfcStairType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStairTypeEnum::IfcStairTypeEnum 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,IfcStairTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStairType::IfcStairType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStairType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStairType::IfcStairType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStairTypeEnum::IfcStairTypeEnum 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,IfcStairTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralAction -bool IfcStructuralAction::hasDestabilizingLoad() const { return !entity->getArgument(9)->isNull(); } -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::is(Type::Enum v) const { return v == Type::IfcStructuralAction || IfcStructuralActivity::is(v); } -Type::Enum IfcStructuralAction::type() const { return Type::IfcStructuralAction; } +bool IfcStructuralAction::hasDestabilizingLoad() const { return !data_->getArgument(9)->isNull(); } +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); } + + +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, boost::optional< bool > v10_DestabilizingLoad) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } 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, boost::optional< bool > v10_DestabilizingLoad) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } 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::hasSharedPlacement() const { return !entity->getArgument(9)->isNull(); } -IfcObjectPlacement* IfcStructuralAnalysisModel::SharedPlacement() const { return (IfcObjectPlacement*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(9))); } -void IfcStructuralAnalysisModel::setSharedPlacement(IfcObjectPlacement* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -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()); } +bool IfcStructuralAnalysisModel::hasSharedPlacement() const { return !data_->getArgument(9)->isNull(); } +IfcObjectPlacement* IfcStructuralAnalysisModel::SharedPlacement() const { return (IfcObjectPlacement*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(9))); } +void IfcStructuralAnalysisModel::setSharedPlacement(IfcObjectPlacement* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } + + +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, IfcObjectPlacement* v10_SharedPlacement) : 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); } e->setArgument(9,(v10_SharedPlacement)); 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, IfcObjectPlacement* v10_SharedPlacement) : 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); } e->setArgument(9,(v10_SharedPlacement)); 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 IfcStructuralCurveAction -bool IfcStructuralCurveAction::hasProjectedOrTrue() const { return !entity->getArgument(10)->isNull(); } -IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralCurveAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(10)); } -void IfcStructuralCurveAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } -IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum IfcStructuralCurveAction::PredefinedType() const { return IfcStructuralCurveActivityTypeEnum::FromString(*entity->getArgument(11)); } -void IfcStructuralCurveAction::setPredefinedType(IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcStructuralCurveActivityTypeEnum::ToString(v)); } -bool IfcStructuralCurveAction::is(Type::Enum v) const { return v == Type::IfcStructuralCurveAction || IfcStructuralAction::is(v); } -Type::Enum IfcStructuralCurveAction::type() const { return Type::IfcStructuralCurveAction; } +bool IfcStructuralCurveAction::hasProjectedOrTrue() const { return !data_->getArgument(10)->isNull(); } +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralCurveAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*data_->getArgument(10)); } +void IfcStructuralCurveAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } +IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum IfcStructuralCurveAction::PredefinedType() const { return IfcStructuralCurveActivityTypeEnum::FromString(*data_->getArgument(11)); } +void IfcStructuralCurveAction::setPredefinedType(IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcStructuralCurveActivityTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralCurveAction::declaration() const { return *IfcStructuralCurveAction_type; } Type::Enum IfcStructuralCurveAction::Class() { return Type::IfcStructuralCurveAction; } -IfcStructuralCurveAction::IfcStructuralCurveAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralCurveAction::IfcStructuralCurveAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v12_PredefinedType) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralCurveActivityTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralCurveAction::IfcStructuralCurveAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralCurveAction::IfcStructuralCurveAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v12_PredefinedType) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralCurveActivityTypeEnum::ToString(v12_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralCurveConnection -IfcDirection* IfcStructuralCurveConnection::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcStructuralCurveConnection::setAxis(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStructuralCurveConnection::is(Type::Enum v) const { return v == Type::IfcStructuralCurveConnection || IfcStructuralConnection::is(v); } -Type::Enum IfcStructuralCurveConnection::type() const { return Type::IfcStructuralCurveConnection; } +IfcDirection* IfcStructuralCurveConnection::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcStructuralCurveConnection::setAxis(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +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, IfcDirection* v9_Axis) : 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)); e->setArgument(8,(v9_Axis)); 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, IfcDirection* v9_Axis) : 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)); e->setArgument(8,(v9_Axis)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralCurveMember -IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum IfcStructuralCurveMember::PredefinedType() const { return IfcStructuralCurveMemberTypeEnum::FromString(*entity->getArgument(7)); } -void IfcStructuralCurveMember::setPredefinedType(IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcStructuralCurveMemberTypeEnum::ToString(v)); } -IfcDirection* IfcStructuralCurveMember::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcStructuralCurveMember::setAxis(IfcDirection* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStructuralCurveMember::is(Type::Enum v) const { return v == Type::IfcStructuralCurveMember || IfcStructuralMember::is(v); } -Type::Enum IfcStructuralCurveMember::type() const { return Type::IfcStructuralCurveMember; } +IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum IfcStructuralCurveMember::PredefinedType() const { return IfcStructuralCurveMemberTypeEnum::FromString(*data_->getArgument(7)); } +void IfcStructuralCurveMember::setPredefinedType(IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcStructuralCurveMemberTypeEnum::ToString(v)); } +IfcDirection* IfcStructuralCurveMember::Axis() const { return (IfcDirection*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcStructuralCurveMember::setAxis(IfcDirection* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v8_PredefinedType, IfcDirection* v9_Axis) : 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,IfcStructuralCurveMemberTypeEnum::ToString(v8_PredefinedType)); e->setArgument(8,(v9_Axis)); 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, IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v8_PredefinedType, IfcDirection* v9_Axis) : 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,IfcStructuralCurveMemberTypeEnum::ToString(v8_PredefinedType)); e->setArgument(8,(v9_Axis)); 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, IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v8_PredefinedType, IfcDirection* v9_Axis) : 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,IfcStructuralCurveMemberTypeEnum::ToString(v8_PredefinedType)); e->setArgument(8,(v9_Axis)); 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, IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v8_PredefinedType, IfcDirection* v9_Axis) : 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,IfcStructuralCurveMemberTypeEnum::ToString(v8_PredefinedType)); e->setArgument(8,(v9_Axis)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralCurveReaction -IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum IfcStructuralCurveReaction::PredefinedType() const { return IfcStructuralCurveActivityTypeEnum::FromString(*entity->getArgument(9)); } -void IfcStructuralCurveReaction::setPredefinedType(IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcStructuralCurveActivityTypeEnum::ToString(v)); } -bool IfcStructuralCurveReaction::is(Type::Enum v) const { return v == Type::IfcStructuralCurveReaction || IfcStructuralReaction::is(v); } -Type::Enum IfcStructuralCurveReaction::type() const { return Type::IfcStructuralCurveReaction; } +IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum IfcStructuralCurveReaction::PredefinedType() const { return IfcStructuralCurveActivityTypeEnum::FromString(*data_->getArgument(9)); } +void IfcStructuralCurveReaction::setPredefinedType(IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcStructuralCurveActivityTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralCurveReaction::declaration() const { return *IfcStructuralCurveReaction_type; } Type::Enum IfcStructuralCurveReaction::Class() { return Type::IfcStructuralCurveReaction; } -IfcStructuralCurveReaction::IfcStructuralCurveReaction(IfcAbstractEntity* e) : IfcStructuralReaction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveReaction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralCurveReaction::IfcStructuralCurveReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v10_PredefinedType) : 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)); e->setArgument(9,v10_PredefinedType,IfcStructuralCurveActivityTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralCurveReaction::IfcStructuralCurveReaction(IfcAbstractEntity* e) : IfcStructuralReaction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralCurveReaction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralCurveReaction::IfcStructuralCurveReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v10_PredefinedType) : 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)); e->setArgument(9,v10_PredefinedType,IfcStructuralCurveActivityTypeEnum::ToString(v10_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 -bool IfcStructuralLinearAction::is(Type::Enum v) const { return v == Type::IfcStructuralLinearAction || IfcStructuralCurveAction::is(v); } -Type::Enum IfcStructuralLinearAction::type() const { return Type::IfcStructuralLinearAction; } + + +const IfcParse::entity& IfcStructuralLinearAction::declaration() const { return *IfcStructuralLinearAction_type; } Type::Enum IfcStructuralLinearAction::Class() { return Type::IfcStructuralLinearAction; } -IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntity* e) : IfcStructuralCurveAction((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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v12_PredefinedType) : IfcStructuralCurveAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralCurveActivityTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntity* e) : IfcStructuralCurveAction((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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v12_PredefinedType) : IfcStructuralCurveAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralCurveActivityTypeEnum::ToString(v12_PredefinedType)); 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 IfcStructuralLoadCase -bool IfcStructuralLoadCase::hasSelfWeightCoefficients() const { return !entity->getArgument(10)->isNull(); } -std::vector< double > /*[3:3]*/ IfcStructuralLoadCase::SelfWeightCoefficients() const { return *entity->getArgument(10); } -void IfcStructuralLoadCase::setSelfWeightCoefficients(std::vector< double > /*[3:3]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcStructuralLoadCase::is(Type::Enum v) const { return v == Type::IfcStructuralLoadCase || IfcStructuralLoadGroup::is(v); } -Type::Enum IfcStructuralLoadCase::type() const { return Type::IfcStructuralLoadCase; } +bool IfcStructuralLoadCase::hasSelfWeightCoefficients() const { return !data_->getArgument(10)->isNull(); } +std::vector< double > /*[3:3]*/ IfcStructuralLoadCase::SelfWeightCoefficients() const { return *data_->getArgument(10); } +void IfcStructuralLoadCase::setSelfWeightCoefficients(std::vector< double > /*[3:3]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcStructuralLoadCase::declaration() const { return *IfcStructuralLoadCase_type; } Type::Enum IfcStructuralLoadCase::Class() { return Type::IfcStructuralLoadCase; } -IfcStructuralLoadCase::IfcStructuralLoadCase(IfcAbstractEntity* e) : IfcStructuralLoadGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadCase::IfcStructuralLoadCase(std::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, boost::optional< std::vector< double > /*[3:3]*/ > v11_SelfWeightCoefficients) : IfcStructuralLoadGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v11_SelfWeightCoefficients) { e->setArgument(10,(*v11_SelfWeightCoefficients)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadCase::IfcStructuralLoadCase(IfcAbstractEntity* e) : IfcStructuralLoadGroup((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadCase::IfcStructuralLoadCase(std::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, boost::optional< std::vector< double > /*[3:3]*/ > v11_SelfWeightCoefficients) : IfcStructuralLoadGroup((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v11_SelfWeightCoefficients) { e->setArgument(10,(*v11_SelfWeightCoefficients)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralLoadConfiguration -IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr IfcStructuralLoadConfiguration::Values() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcStructuralLoadConfiguration::setValues(IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -bool IfcStructuralLoadConfiguration::hasLocations() const { return !entity->getArgument(2)->isNull(); } -std::vector< std::vector< double > > IfcStructuralLoadConfiguration::Locations() const { return *entity->getArgument(2); } -void IfcStructuralLoadConfiguration::setLocations(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadConfiguration::is(Type::Enum v) const { return v == Type::IfcStructuralLoadConfiguration || IfcStructuralLoad::is(v); } -Type::Enum IfcStructuralLoadConfiguration::type() const { return Type::IfcStructuralLoadConfiguration; } +IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr IfcStructuralLoadConfiguration::Values() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcStructuralLoadConfiguration::setValues(IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +bool IfcStructuralLoadConfiguration::hasLocations() const { return !data_->getArgument(2)->isNull(); } +std::vector< std::vector< double > > IfcStructuralLoadConfiguration::Locations() const { return *data_->getArgument(2); } +void IfcStructuralLoadConfiguration::setLocations(std::vector< std::vector< double > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +const IfcParse::entity& IfcStructuralLoadConfiguration::declaration() const { return *IfcStructuralLoadConfiguration_type; } Type::Enum IfcStructuralLoadConfiguration::Class() { return Type::IfcStructuralLoadConfiguration; } -IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadConfiguration)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values, boost::optional< std::vector< std::vector< double > > > v3_Locations) : IfcStructuralLoad((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Values)->generalize()); if (v3_Locations) { e->setArgument(2,(*v3_Locations)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadConfiguration)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values, boost::optional< std::vector< std::vector< double > > > v3_Locations) : IfcStructuralLoad((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Values)->generalize()); if (v3_Locations) { e->setArgument(2,(*v3_Locations)); } else { e->setArgument(2); } 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 IfcStructuralLoadOrResult -bool IfcStructuralLoadOrResult::is(Type::Enum v) const { return v == Type::IfcStructuralLoadOrResult || IfcStructuralLoad::is(v); } -Type::Enum IfcStructuralLoadOrResult::type() const { return Type::IfcStructuralLoadOrResult; } + + +const IfcParse::entity& IfcStructuralLoadOrResult::declaration() const { return *IfcStructuralLoadOrResult_type; } Type::Enum IfcStructuralLoadOrResult::Class() { return Type::IfcStructuralLoadOrResult; } -IfcStructuralLoadOrResult::IfcStructuralLoadOrResult(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadOrResult)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralLoadOrResult::IfcStructuralLoadOrResult(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); } +IfcStructuralLoadOrResult::IfcStructuralLoadOrResult(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadOrResult)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralLoadOrResult::IfcStructuralLoadOrResult(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 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 || IfcStructuralLoadOrResult::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) : IfcStructuralLoadOrResult((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) : IfcStructuralLoadOrResult((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) : IfcStructuralLoadOrResult((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) : IfcStructuralLoadOrResult((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::hasDeltaTConstant() const { return !entity->getArgument(1)->isNull(); } -double IfcStructuralLoadTemperature::DeltaTConstant() const { return *entity->getArgument(1); } -void IfcStructuralLoadTemperature::setDeltaTConstant(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcStructuralLoadTemperature::hasDeltaTY() const { return !entity->getArgument(2)->isNull(); } -double IfcStructuralLoadTemperature::DeltaTY() const { return *entity->getArgument(2); } -void IfcStructuralLoadTemperature::setDeltaTY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcStructuralLoadTemperature::hasDeltaTZ() const { return !entity->getArgument(3)->isNull(); } -double IfcStructuralLoadTemperature::DeltaTZ() const { return *entity->getArgument(3); } -void IfcStructuralLoadTemperature::setDeltaTZ(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::hasDeltaTConstant() const { return !data_->getArgument(1)->isNull(); } +double IfcStructuralLoadTemperature::DeltaTConstant() const { return *data_->getArgument(1); } +void IfcStructuralLoadTemperature::setDeltaTConstant(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcStructuralLoadTemperature::hasDeltaTY() const { return !data_->getArgument(2)->isNull(); } +double IfcStructuralLoadTemperature::DeltaTY() const { return *data_->getArgument(2); } +void IfcStructuralLoadTemperature::setDeltaTY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcStructuralLoadTemperature::hasDeltaTZ() const { return !data_->getArgument(3)->isNull(); } +double IfcStructuralLoadTemperature::DeltaTZ() const { return *data_->getArgument(3); } +void IfcStructuralLoadTemperature::setDeltaTZ(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_DeltaTConstant, boost::optional< double > v3_DeltaTY, boost::optional< double > v4_DeltaTZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DeltaTConstant) { e->setArgument(1,(*v2_DeltaTConstant)); } else { e->setArgument(1); } if (v3_DeltaTY) { e->setArgument(2,(*v3_DeltaTY)); } else { e->setArgument(2); } if (v4_DeltaTZ) { e->setArgument(3,(*v4_DeltaTZ)); } 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_DeltaTConstant, boost::optional< double > v3_DeltaTY, boost::optional< double > v4_DeltaTZ) : IfcStructuralLoadStatic((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DeltaTConstant) { e->setArgument(1,(*v2_DeltaTConstant)); } else { e->setArgument(1); } if (v3_DeltaTY) { e->setArgument(2,(*v3_DeltaTY)); } else { e->setArgument(2); } if (v4_DeltaTZ) { e->setArgument(3,(*v4_DeltaTZ)); } else { e->setArgument(3); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralMember -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; } + +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 -bool IfcStructuralPlanarAction::is(Type::Enum v) const { return v == Type::IfcStructuralPlanarAction || IfcStructuralSurfaceAction::is(v); } -Type::Enum IfcStructuralPlanarAction::type() const { return Type::IfcStructuralPlanarAction; } + + +const IfcParse::entity& IfcStructuralPlanarAction::declaration() const { return *IfcStructuralPlanarAction_type; } Type::Enum IfcStructuralPlanarAction::Class() { return Type::IfcStructuralPlanarAction; } -IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntity* e) : IfcStructuralSurfaceAction((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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v12_PredefinedType) : IfcStructuralSurfaceAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralSurfaceActivityTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntity* e) : IfcStructuralSurfaceAction((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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v12_PredefinedType) : IfcStructuralSurfaceAction((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralSurfaceActivityTypeEnum::ToString(v12_PredefinedType)); 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, boost::optional< bool > v10_DestabilizingLoad) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } 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, boost::optional< bool > v10_DestabilizingLoad) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralPointConnection -bool IfcStructuralPointConnection::hasConditionCoordinateSystem() const { return !entity->getArgument(8)->isNull(); } -IfcAxis2Placement3D* IfcStructuralPointConnection::ConditionCoordinateSystem() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(8))); } -void IfcStructuralPointConnection::setConditionCoordinateSystem(IfcAxis2Placement3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcStructuralPointConnection::is(Type::Enum v) const { return v == Type::IfcStructuralPointConnection || IfcStructuralConnection::is(v); } -Type::Enum IfcStructuralPointConnection::type() const { return Type::IfcStructuralPointConnection; } +bool IfcStructuralPointConnection::hasConditionCoordinateSystem() const { return !data_->getArgument(8)->isNull(); } +IfcAxis2Placement3D* IfcStructuralPointConnection::ConditionCoordinateSystem() const { return (IfcAxis2Placement3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(8))); } +void IfcStructuralPointConnection::setConditionCoordinateSystem(IfcAxis2Placement3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + + +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, IfcAxis2Placement3D* v9_ConditionCoordinateSystem) : 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)); e->setArgument(8,(v9_ConditionCoordinateSystem)); 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, IfcAxis2Placement3D* v9_ConditionCoordinateSystem) : 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)); e->setArgument(8,(v9_ConditionCoordinateSystem)); 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 IfcStructuralReaction -bool IfcStructuralReaction::is(Type::Enum v) const { return v == Type::IfcStructuralReaction || IfcStructuralActivity::is(v); } -Type::Enum IfcStructuralReaction::type() const { return Type::IfcStructuralReaction; } + + +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 IfcStructuralSurfaceAction -bool IfcStructuralSurfaceAction::hasProjectedOrTrue() const { return !entity->getArgument(10)->isNull(); } -IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralSurfaceAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(10)); } -void IfcStructuralSurfaceAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } -IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum IfcStructuralSurfaceAction::PredefinedType() const { return IfcStructuralSurfaceActivityTypeEnum::FromString(*entity->getArgument(11)); } -void IfcStructuralSurfaceAction::setPredefinedType(IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcStructuralSurfaceActivityTypeEnum::ToString(v)); } -bool IfcStructuralSurfaceAction::is(Type::Enum v) const { return v == Type::IfcStructuralSurfaceAction || IfcStructuralAction::is(v); } -Type::Enum IfcStructuralSurfaceAction::type() const { return Type::IfcStructuralSurfaceAction; } +bool IfcStructuralSurfaceAction::hasProjectedOrTrue() const { return !data_->getArgument(10)->isNull(); } +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralSurfaceAction::ProjectedOrTrue() const { return IfcProjectedOrTrueLengthEnum::FromString(*data_->getArgument(10)); } +void IfcStructuralSurfaceAction::setProjectedOrTrue(IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcProjectedOrTrueLengthEnum::ToString(v)); } +IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum IfcStructuralSurfaceAction::PredefinedType() const { return IfcStructuralSurfaceActivityTypeEnum::FromString(*data_->getArgument(11)); } +void IfcStructuralSurfaceAction::setPredefinedType(IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcStructuralSurfaceActivityTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralSurfaceAction::declaration() const { return *IfcStructuralSurfaceAction_type; } Type::Enum IfcStructuralSurfaceAction::Class() { return Type::IfcStructuralSurfaceAction; } -IfcStructuralSurfaceAction::IfcStructuralSurfaceAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceAction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralSurfaceAction::IfcStructuralSurfaceAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v12_PredefinedType) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralSurfaceActivityTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralSurfaceAction::IfcStructuralSurfaceAction(IfcAbstractEntity* e) : IfcStructuralAction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceAction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralSurfaceAction::IfcStructuralSurfaceAction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v12_PredefinedType) : 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)); if (v10_DestabilizingLoad) { e->setArgument(9,(*v10_DestabilizingLoad)); } else { e->setArgument(9); } if (v11_ProjectedOrTrue) { e->setArgument(10,*v11_ProjectedOrTrue,IfcProjectedOrTrueLengthEnum::ToString(*v11_ProjectedOrTrue)); } else { e->setArgument(10); } e->setArgument(11,v12_PredefinedType,IfcStructuralSurfaceActivityTypeEnum::ToString(v12_PredefinedType)); 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 -IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum IfcStructuralSurfaceMember::PredefinedType() const { return IfcStructuralSurfaceMemberTypeEnum::FromString(*entity->getArgument(7)); } -void IfcStructuralSurfaceMember::setPredefinedType(IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v,IfcStructuralSurfaceMemberTypeEnum::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; } +IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum IfcStructuralSurfaceMember::PredefinedType() const { return IfcStructuralSurfaceMemberTypeEnum::FromString(*data_->getArgument(7)); } +void IfcStructuralSurfaceMember::setPredefinedType(IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v,IfcStructuralSurfaceMemberTypeEnum::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, IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum 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,IfcStructuralSurfaceMemberTypeEnum::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, IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum 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,IfcStructuralSurfaceMemberTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralSurfaceMemberVarying -bool IfcStructuralSurfaceMemberVarying::is(Type::Enum v) const { return v == Type::IfcStructuralSurfaceMemberVarying || IfcStructuralSurfaceMember::is(v); } -Type::Enum IfcStructuralSurfaceMemberVarying::type() const { return Type::IfcStructuralSurfaceMemberVarying; } + + +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, IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness) : 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,IfcStructuralSurfaceMemberTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } 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, IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness) : 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,IfcStructuralSurfaceMemberTypeEnum::ToString(v8_PredefinedType)); if (v9_Thickness) { e->setArgument(8,(*v9_Thickness)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcStructuralSurfaceReaction -IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum IfcStructuralSurfaceReaction::PredefinedType() const { return IfcStructuralSurfaceActivityTypeEnum::FromString(*entity->getArgument(9)); } -void IfcStructuralSurfaceReaction::setPredefinedType(IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcStructuralSurfaceActivityTypeEnum::ToString(v)); } -bool IfcStructuralSurfaceReaction::is(Type::Enum v) const { return v == Type::IfcStructuralSurfaceReaction || IfcStructuralReaction::is(v); } -Type::Enum IfcStructuralSurfaceReaction::type() const { return Type::IfcStructuralSurfaceReaction; } +IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum IfcStructuralSurfaceReaction::PredefinedType() const { return IfcStructuralSurfaceActivityTypeEnum::FromString(*data_->getArgument(9)); } +void IfcStructuralSurfaceReaction::setPredefinedType(IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcStructuralSurfaceActivityTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcStructuralSurfaceReaction::declaration() const { return *IfcStructuralSurfaceReaction_type; } Type::Enum IfcStructuralSurfaceReaction::Class() { return Type::IfcStructuralSurfaceReaction; } -IfcStructuralSurfaceReaction::IfcStructuralSurfaceReaction(IfcAbstractEntity* e) : IfcStructuralReaction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceReaction)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcStructuralSurfaceReaction::IfcStructuralSurfaceReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v10_PredefinedType) : 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)); e->setArgument(9,v10_PredefinedType,IfcStructuralSurfaceActivityTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcStructuralSurfaceReaction::IfcStructuralSurfaceReaction(IfcAbstractEntity* e) : IfcStructuralReaction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralSurfaceReaction)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcStructuralSurfaceReaction::IfcStructuralSurfaceReaction(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v10_PredefinedType) : 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)); e->setArgument(9,v10_PredefinedType,IfcStructuralSurfaceActivityTypeEnum::ToString(v10_PredefinedType)); 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); } -IfcEntityList::ptr IfcStyledItem::Styles() const { return *entity->getArgument(1); } -void IfcStyledItem::setStyles(IfcEntityList::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -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); } +IfcEntityList::ptr IfcStyledItem::Styles() const { return *data_->getArgument(1); } +void IfcStyledItem::setStyles(IfcEntityList::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +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, IfcEntityList::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)); 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, IfcEntityList::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)); 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::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum IfcSubContractResource::PredefinedType() const { return IfcSubContractResourceTypeEnum::FromString(*entity->getArgument(10)); } -void IfcSubContractResource::setPredefinedType(IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcSubContractResourceTypeEnum::ToString(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::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum IfcSubContractResource::PredefinedType() const { return IfcSubContractResourceTypeEnum::FromString(*data_->getArgument(10)); } +void IfcSubContractResource::setPredefinedType(IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcSubContractResourceTypeEnum::ToString(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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcSubContractResourceTypeEnum::ToString(*v11_PredefinedType)); } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum > v11_PredefinedType) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } e->setArgument(7,(v8_Usage)); if (v9_BaseCosts) { e->setArgument(8,(*v9_BaseCosts)->generalize()); } else { e->setArgument(8); } e->setArgument(9,(v10_BaseQuantity)); if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcSubContractResourceTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSubContractResourceType -IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum IfcSubContractResourceType::PredefinedType() const { return IfcSubContractResourceTypeEnum::FromString(*entity->getArgument(11)); } -void IfcSubContractResourceType::setPredefinedType(IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcSubContractResourceTypeEnum::ToString(v)); } -bool IfcSubContractResourceType::is(Type::Enum v) const { return v == Type::IfcSubContractResourceType || IfcConstructionResourceType::is(v); } -Type::Enum IfcSubContractResourceType::type() const { return Type::IfcSubContractResourceType; } +IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum IfcSubContractResourceType::PredefinedType() const { return IfcSubContractResourceTypeEnum::FromString(*data_->getArgument(11)); } +void IfcSubContractResourceType::setPredefinedType(IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcSubContractResourceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSubContractResourceType::declaration() const { return *IfcSubContractResourceType_type; } Type::Enum IfcSubContractResourceType::Class() { return Type::IfcSubContractResourceType; } -IfcSubContractResourceType::IfcSubContractResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSubContractResourceType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSubContractResourceType::IfcSubContractResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcSubContractResourceTypeEnum::ToString(v12_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcSubContractResourceType::IfcSubContractResourceType(IfcAbstractEntity* e) : IfcConstructionResourceType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSubContractResourceType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSubContractResourceType::IfcSubContractResourceType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v12_PredefinedType) : IfcConstructionResourceType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } if (v10_BaseCosts) { e->setArgument(9,(*v10_BaseCosts)->generalize()); } else { e->setArgument(9); } e->setArgument(10,(v11_BaseQuantity)); e->setArgument(11,v12_PredefinedType,IfcSubContractResourceTypeEnum::ToString(v12_PredefinedType)); 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); } -bool IfcSurfaceCurveSweptAreaSolid::hasStartParam() const { return !entity->getArgument(3)->isNull(); } -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); } -bool IfcSurfaceCurveSweptAreaSolid::hasEndParam() const { return !entity->getArgument(4)->isNull(); } -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); } +bool IfcSurfaceCurveSweptAreaSolid::hasStartParam() const { return !data_->getArgument(3)->isNull(); } +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); } +bool IfcSurfaceCurveSweptAreaSolid::hasEndParam() const { return !data_->getArgument(4)->isNull(); } +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, boost::optional< double > v4_StartParam, boost::optional< 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)); if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } 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, boost::optional< double > v4_StartParam, boost::optional< 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)); if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } e->setArgument(5,(v6_ReferenceSurface)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSurfaceFeature -bool IfcSurfaceFeature::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum IfcSurfaceFeature::PredefinedType() const { return IfcSurfaceFeatureTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSurfaceFeature::setPredefinedType(IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSurfaceFeatureTypeEnum::ToString(v)); } -bool IfcSurfaceFeature::is(Type::Enum v) const { return v == Type::IfcSurfaceFeature || IfcFeatureElement::is(v); } -Type::Enum IfcSurfaceFeature::type() const { return Type::IfcSurfaceFeature; } +bool IfcSurfaceFeature::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum IfcSurfaceFeature::PredefinedType() const { return IfcSurfaceFeatureTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSurfaceFeature::setPredefinedType(IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSurfaceFeatureTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSurfaceFeature::declaration() const { return *IfcSurfaceFeature_type; } Type::Enum IfcSurfaceFeature::Class() { return Type::IfcSurfaceFeature; } -IfcSurfaceFeature::IfcSurfaceFeature(IfcAbstractEntity* e) : IfcFeatureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceFeature)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceFeature::IfcSurfaceFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSurfaceFeatureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSurfaceFeature::IfcSurfaceFeature(IfcAbstractEntity* e) : IfcFeatureElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceFeature)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceFeature::IfcSurfaceFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSurfaceFeatureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcSurfaceReinforcementArea -bool IfcSurfaceReinforcementArea::hasSurfaceReinforcement1() const { return !entity->getArgument(1)->isNull(); } -std::vector< double > /*[2:3]*/ IfcSurfaceReinforcementArea::SurfaceReinforcement1() const { return *entity->getArgument(1); } -void IfcSurfaceReinforcementArea::setSurfaceReinforcement1(std::vector< double > /*[2:3]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcSurfaceReinforcementArea::hasSurfaceReinforcement2() const { return !entity->getArgument(2)->isNull(); } -std::vector< double > /*[2:3]*/ IfcSurfaceReinforcementArea::SurfaceReinforcement2() const { return *entity->getArgument(2); } -void IfcSurfaceReinforcementArea::setSurfaceReinforcement2(std::vector< double > /*[2:3]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcSurfaceReinforcementArea::hasShearReinforcement() const { return !entity->getArgument(3)->isNull(); } -double IfcSurfaceReinforcementArea::ShearReinforcement() const { return *entity->getArgument(3); } -void IfcSurfaceReinforcementArea::setShearReinforcement(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcSurfaceReinforcementArea::is(Type::Enum v) const { return v == Type::IfcSurfaceReinforcementArea || IfcStructuralLoadOrResult::is(v); } -Type::Enum IfcSurfaceReinforcementArea::type() const { return Type::IfcSurfaceReinforcementArea; } +bool IfcSurfaceReinforcementArea::hasSurfaceReinforcement1() const { return !data_->getArgument(1)->isNull(); } +std::vector< double > /*[2:3]*/ IfcSurfaceReinforcementArea::SurfaceReinforcement1() const { return *data_->getArgument(1); } +void IfcSurfaceReinforcementArea::setSurfaceReinforcement1(std::vector< double > /*[2:3]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcSurfaceReinforcementArea::hasSurfaceReinforcement2() const { return !data_->getArgument(2)->isNull(); } +std::vector< double > /*[2:3]*/ IfcSurfaceReinforcementArea::SurfaceReinforcement2() const { return *data_->getArgument(2); } +void IfcSurfaceReinforcementArea::setSurfaceReinforcement2(std::vector< double > /*[2:3]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcSurfaceReinforcementArea::hasShearReinforcement() const { return !data_->getArgument(3)->isNull(); } +double IfcSurfaceReinforcementArea::ShearReinforcement() const { return *data_->getArgument(3); } +void IfcSurfaceReinforcementArea::setShearReinforcement(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } + + +const IfcParse::entity& IfcSurfaceReinforcementArea::declaration() const { return *IfcSurfaceReinforcementArea_type; } Type::Enum IfcSurfaceReinforcementArea::Class() { return Type::IfcSurfaceReinforcementArea; } -IfcSurfaceReinforcementArea::IfcSurfaceReinforcementArea(IfcAbstractEntity* e) : IfcStructuralLoadOrResult((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceReinforcementArea)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceReinforcementArea::IfcSurfaceReinforcementArea(boost::optional< std::string > v1_Name, boost::optional< std::vector< double > /*[2:3]*/ > v2_SurfaceReinforcement1, boost::optional< std::vector< double > /*[2:3]*/ > v3_SurfaceReinforcement2, boost::optional< double > v4_ShearReinforcement) : IfcStructuralLoadOrResult((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_SurfaceReinforcement1) { e->setArgument(1,(*v2_SurfaceReinforcement1)); } else { e->setArgument(1); } if (v3_SurfaceReinforcement2) { e->setArgument(2,(*v3_SurfaceReinforcement2)); } else { e->setArgument(2); } if (v4_ShearReinforcement) { e->setArgument(3,(*v4_ShearReinforcement)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); } +IfcSurfaceReinforcementArea::IfcSurfaceReinforcementArea(IfcAbstractEntity* e) : IfcStructuralLoadOrResult((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceReinforcementArea)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceReinforcementArea::IfcSurfaceReinforcementArea(boost::optional< std::string > v1_Name, boost::optional< std::vector< double > /*[2:3]*/ > v2_SurfaceReinforcement1, boost::optional< std::vector< double > /*[2:3]*/ > v3_SurfaceReinforcement2, boost::optional< double > v4_ShearReinforcement) : IfcStructuralLoadOrResult((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_SurfaceReinforcement1) { e->setArgument(1,(*v2_SurfaceReinforcement1)); } else { e->setArgument(1); } if (v3_SurfaceReinforcement2) { e->setArgument(2,(*v3_SurfaceReinforcement2)); } else { e->setArgument(2); } if (v4_ShearReinforcement) { e->setArgument(3,(*v4_ShearReinforcement)); } else { e->setArgument(3); } 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceStyleShading)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcColourRgb* v1_SurfaceColour) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_SurfaceColour)); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSurfaceStyleShading)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcColourRgb* v1_SurfaceColour) : IfcPresentationItem((IfcAbstractEntity*)0) { 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Textures)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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); } -bool IfcSurfaceTexture::hasMode() const { return !entity->getArgument(2)->isNull(); } -std::string IfcSurfaceTexture::Mode() const { return *entity->getArgument(2); } -void IfcSurfaceTexture::setMode(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,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::hasParameter() const { return !entity->getArgument(4)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcSurfaceTexture::Parameter() const { return *entity->getArgument(4); } -void IfcSurfaceTexture::setParameter(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -IfcTextureCoordinate::list::ptr IfcSurfaceTexture::IsMappedBy() const { return entity->getInverse(Type::IfcTextureCoordinate, 0)->as(); } -IfcSurfaceStyleWithTextures::list::ptr IfcSurfaceTexture::UsedInStyles() const { return entity->getInverse(Type::IfcSurfaceStyleWithTextures, 0)->as(); } -bool IfcSurfaceTexture::is(Type::Enum v) const { return v == Type::IfcSurfaceTexture || IfcPresentationItem::is(v); } -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); } +bool IfcSurfaceTexture::hasMode() const { return !data_->getArgument(2)->isNull(); } +std::string IfcSurfaceTexture::Mode() const { return *data_->getArgument(2); } +void IfcSurfaceTexture::setMode(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,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); } +bool IfcSurfaceTexture::hasParameter() const { return !data_->getArgument(4)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcSurfaceTexture::Parameter() const { return *data_->getArgument(4); } +void IfcSurfaceTexture::setParameter(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + +IfcTextureCoordinate::list::ptr IfcSurfaceTexture::IsMappedBy() const { return data_->getInverse(Type::IfcTextureCoordinate, 0)->as(); } +IfcSurfaceStyleWithTextures::list::ptr IfcSurfaceTexture::UsedInStyles() const { return data_->getInverse(Type::IfcSurfaceStyleWithTextures, 0)->as(); } + +const IfcParse::entity& IfcSurfaceTexture::declaration() const { return *IfcSurfaceTexture_type; } Type::Enum IfcSurfaceTexture::Class() { return Type::IfcSurfaceTexture; } -IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_RepeatS)); e->setArgument(1,(v2_RepeatT)); if (v3_Mode) { e->setArgument(2,(*v3_Mode)); } else { e->setArgument(2); } e->setArgument(3,(v4_TextureTransform)); if (v5_Parameter) { e->setArgument(4,(*v5_Parameter)); } else { e->setArgument(4); } 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); } -bool IfcSweptAreaSolid::hasPosition() const { return !entity->getArgument(1)->isNull(); } -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); } +bool IfcSweptAreaSolid::hasPosition() const { return !data_->getArgument(1)->isNull(); } +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); } -bool IfcSweptDiskSolid::hasStartParam() const { return !entity->getArgument(3)->isNull(); } -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); } -bool IfcSweptDiskSolid::hasEndParam() const { return !entity->getArgument(4)->isNull(); } -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); } +bool IfcSweptDiskSolid::hasStartParam() const { return !data_->getArgument(3)->isNull(); } +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); } +bool IfcSweptDiskSolid::hasEndParam() const { return !data_->getArgument(4)->isNull(); } +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, boost::optional< double > v4_StartParam, boost::optional< 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); } if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } 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, boost::optional< double > v4_StartParam, boost::optional< 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); } if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSweptDiskSolidPolygonal -bool IfcSweptDiskSolidPolygonal::hasFilletRadius() const { return !entity->getArgument(5)->isNull(); } -double IfcSweptDiskSolidPolygonal::FilletRadius() const { return *entity->getArgument(5); } -void IfcSweptDiskSolidPolygonal::setFilletRadius(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcSweptDiskSolidPolygonal::is(Type::Enum v) const { return v == Type::IfcSweptDiskSolidPolygonal || IfcSweptDiskSolid::is(v); } -Type::Enum IfcSweptDiskSolidPolygonal::type() const { return Type::IfcSweptDiskSolidPolygonal; } +bool IfcSweptDiskSolidPolygonal::hasFilletRadius() const { return !data_->getArgument(5)->isNull(); } +double IfcSweptDiskSolidPolygonal::FilletRadius() const { return *data_->getArgument(5); } +void IfcSweptDiskSolidPolygonal::setFilletRadius(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcSweptDiskSolidPolygonal::declaration() const { return *IfcSweptDiskSolidPolygonal_type; } Type::Enum IfcSweptDiskSolidPolygonal::Class() { return Type::IfcSweptDiskSolidPolygonal; } -IfcSweptDiskSolidPolygonal::IfcSweptDiskSolidPolygonal(IfcAbstractEntity* e) : IfcSweptDiskSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptDiskSolidPolygonal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSweptDiskSolidPolygonal::IfcSweptDiskSolidPolygonal(IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, boost::optional< double > v6_FilletRadius) : IfcSweptDiskSolid((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); } if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } if (v6_FilletRadius) { e->setArgument(5,(*v6_FilletRadius)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcSweptDiskSolidPolygonal::IfcSweptDiskSolidPolygonal(IfcAbstractEntity* e) : IfcSweptDiskSolid((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSweptDiskSolidPolygonal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSweptDiskSolidPolygonal::IfcSweptDiskSolidPolygonal(IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, boost::optional< double > v6_FilletRadius) : IfcSweptDiskSolid((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); } if (v4_StartParam) { e->setArgument(3,(*v4_StartParam)); } else { e->setArgument(3); } if (v5_EndParam) { e->setArgument(4,(*v5_EndParam)); } else { e->setArgument(4); } if (v6_FilletRadius) { e->setArgument(5,(*v6_FilletRadius)); } else { e->setArgument(5); } 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); } -bool IfcSweptSurface::hasPosition() const { return !entity->getArgument(1)->isNull(); } -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); } +bool IfcSweptSurface::hasPosition() const { return !data_->getArgument(1)->isNull(); } +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 IfcSwitchingDevice -bool IfcSwitchingDevice::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDevice::PredefinedType() const { return IfcSwitchingDeviceTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSwitchingDevice::setPredefinedType(IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSwitchingDeviceTypeEnum::ToString(v)); } -bool IfcSwitchingDevice::is(Type::Enum v) const { return v == Type::IfcSwitchingDevice || IfcFlowController::is(v); } -Type::Enum IfcSwitchingDevice::type() const { return Type::IfcSwitchingDevice; } +bool IfcSwitchingDevice::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDevice::PredefinedType() const { return IfcSwitchingDeviceTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSwitchingDevice::setPredefinedType(IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSwitchingDeviceTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSwitchingDevice::declaration() const { return *IfcSwitchingDevice_type; } Type::Enum IfcSwitchingDevice::Class() { return Type::IfcSwitchingDevice; } -IfcSwitchingDevice::IfcSwitchingDevice(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSwitchingDevice)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSwitchingDevice::IfcSwitchingDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSwitchingDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSwitchingDevice::IfcSwitchingDevice(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSwitchingDevice)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSwitchingDevice::IfcSwitchingDevice(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcSwitchingDeviceTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 IfcSystemFurnitureElement -bool IfcSystemFurnitureElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum IfcSystemFurnitureElement::PredefinedType() const { return IfcSystemFurnitureElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcSystemFurnitureElement::setPredefinedType(IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcSystemFurnitureElementTypeEnum::ToString(v)); } -bool IfcSystemFurnitureElement::is(Type::Enum v) const { return v == Type::IfcSystemFurnitureElement || IfcFurnishingElement::is(v); } -Type::Enum IfcSystemFurnitureElement::type() const { return Type::IfcSystemFurnitureElement; } +bool IfcSystemFurnitureElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum IfcSystemFurnitureElement::PredefinedType() const { return IfcSystemFurnitureElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcSystemFurnitureElement::setPredefinedType(IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcSystemFurnitureElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcSystemFurnitureElement::declaration() const { return *IfcSystemFurnitureElement_type; } Type::Enum IfcSystemFurnitureElement::Class() { return Type::IfcSystemFurnitureElement; } -IfcSystemFurnitureElement::IfcSystemFurnitureElement(IfcAbstractEntity* e) : IfcFurnishingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSystemFurnitureElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcSystemFurnitureElement::IfcSystemFurnitureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum > v9_PredefinedType) : IfcFurnishingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSystemFurnitureElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcSystemFurnitureElement::IfcSystemFurnitureElement(IfcAbstractEntity* e) : IfcFurnishingElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcSystemFurnitureElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcSystemFurnitureElement::IfcSystemFurnitureElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum > v9_PredefinedType) : IfcFurnishingElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcSystemFurnitureElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcSystemFurnitureElementType -bool IfcSystemFurnitureElementType::hasPredefinedType() const { return !entity->getArgument(9)->isNull(); } -IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum IfcSystemFurnitureElementType::PredefinedType() const { return IfcSystemFurnitureElementTypeEnum::FromString(*entity->getArgument(9)); } -void IfcSystemFurnitureElementType::setPredefinedType(IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcSystemFurnitureElementTypeEnum::ToString(v)); } -bool IfcSystemFurnitureElementType::is(Type::Enum v) const { return v == Type::IfcSystemFurnitureElementType || IfcFurnishingElementType::is(v); } -Type::Enum IfcSystemFurnitureElementType::type() const { return Type::IfcSystemFurnitureElementType; } +bool IfcSystemFurnitureElementType::hasPredefinedType() const { return !data_->getArgument(9)->isNull(); } +IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum IfcSystemFurnitureElementType::PredefinedType() const { return IfcSystemFurnitureElementTypeEnum::FromString(*data_->getArgument(9)); } +void IfcSystemFurnitureElementType::setPredefinedType(IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcSystemFurnitureElementTypeEnum::ToString(v)); } + + +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, boost::optional< IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum > v10_PredefinedType) : 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); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcSystemFurnitureElementTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } 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, boost::optional< IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum > v10_PredefinedType) : 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); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcSystemFurnitureElementTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } 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::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); } + + +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) : 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); } 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) : 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); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTable -bool IfcTable::hasName() const { return !entity->getArgument(0)->isNull(); } -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); } -bool IfcTable::hasRows() const { return !entity->getArgument(1)->isNull(); } -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::hasColumns() const { return !entity->getArgument(2)->isNull(); } -IfcTemplatedEntityList< IfcTableColumn >::ptr IfcTable::Columns() const { IfcEntityList::ptr es = *entity->getArgument(2); return es->as(); } -void IfcTable::setColumns(IfcTemplatedEntityList< IfcTableColumn >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v->generalize()); } -bool IfcTable::is(Type::Enum v) const { return v == Type::IfcTable; } -Type::Enum IfcTable::type() const { return Type::IfcTable; } +bool IfcTable::hasName() const { return !data_->getArgument(0)->isNull(); } +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); } +bool IfcTable::hasRows() const { return !data_->getArgument(1)->isNull(); } +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()); } +bool IfcTable::hasColumns() const { return !data_->getArgument(2)->isNull(); } +IfcTemplatedEntityList< IfcTableColumn >::ptr IfcTable::Columns() const { IfcEntityList::ptr es = *data_->getArgument(2); return es->as(); } +void IfcTable::setColumns(IfcTemplatedEntityList< IfcTableColumn >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,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(boost::optional< std::string > v1_Name, boost::optional< IfcTemplatedEntityList< IfcTableRow >::ptr > v2_Rows, boost::optional< IfcTemplatedEntityList< IfcTableColumn >::ptr > v3_Columns) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Rows) { e->setArgument(1,(*v2_Rows)->generalize()); } else { e->setArgument(1); } if (v3_Columns) { e->setArgument(2,(*v3_Columns)->generalize()); } else { e->setArgument(2); } 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(boost::optional< std::string > v1_Name, boost::optional< IfcTemplatedEntityList< IfcTableRow >::ptr > v2_Rows, boost::optional< IfcTemplatedEntityList< IfcTableColumn >::ptr > v3_Columns) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_Rows) { e->setArgument(1,(*v2_Rows)->generalize()); } else { e->setArgument(1); } if (v3_Columns) { e->setArgument(2,(*v3_Columns)->generalize()); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTableColumn -bool IfcTableColumn::hasIdentifier() const { return !entity->getArgument(0)->isNull(); } -std::string IfcTableColumn::Identifier() const { return *entity->getArgument(0); } -void IfcTableColumn::setIdentifier(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTableColumn::hasName() const { return !entity->getArgument(1)->isNull(); } -std::string IfcTableColumn::Name() const { return *entity->getArgument(1); } -void IfcTableColumn::setName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTableColumn::hasDescription() const { return !entity->getArgument(2)->isNull(); } -std::string IfcTableColumn::Description() const { return *entity->getArgument(2); } -void IfcTableColumn::setDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcTableColumn::hasUnit() const { return !entity->getArgument(3)->isNull(); } -IfcUnit* IfcTableColumn::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcTableColumn::setUnit(IfcUnit* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTableColumn::hasReferencePath() const { return !entity->getArgument(4)->isNull(); } -IfcReference* IfcTableColumn::ReferencePath() const { return (IfcReference*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(4))); } -void IfcTableColumn::setReferencePath(IfcReference* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTableColumn::is(Type::Enum v) const { return v == Type::IfcTableColumn; } -Type::Enum IfcTableColumn::type() const { return Type::IfcTableColumn; } +bool IfcTableColumn::hasIdentifier() const { return !data_->getArgument(0)->isNull(); } +std::string IfcTableColumn::Identifier() const { return *data_->getArgument(0); } +void IfcTableColumn::setIdentifier(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTableColumn::hasName() const { return !data_->getArgument(1)->isNull(); } +std::string IfcTableColumn::Name() const { return *data_->getArgument(1); } +void IfcTableColumn::setName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTableColumn::hasDescription() const { return !data_->getArgument(2)->isNull(); } +std::string IfcTableColumn::Description() const { return *data_->getArgument(2); } +void IfcTableColumn::setDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +bool IfcTableColumn::hasUnit() const { return !data_->getArgument(3)->isNull(); } +IfcUnit* IfcTableColumn::Unit() const { return (IfcUnit*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcTableColumn::setUnit(IfcUnit* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcTableColumn::hasReferencePath() const { return !data_->getArgument(4)->isNull(); } +IfcReference* IfcTableColumn::ReferencePath() const { return (IfcReference*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(4))); } +void IfcTableColumn::setReferencePath(IfcReference* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcTableColumn::declaration() const { return *IfcTableColumn_type; } Type::Enum IfcTableColumn::Class() { return Type::IfcTableColumn; } -IfcTableColumn::IfcTableColumn(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTableColumn)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTableColumn::IfcTableColumn(boost::optional< std::string > v1_Identifier, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, IfcUnit* v4_Unit, IfcReference* v5_ReferencePath) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Identifier) { e->setArgument(0,(*v1_Identifier)); } else { e->setArgument(0); } 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_Unit)); e->setArgument(4,(v5_ReferencePath)); entity = e; EntityBuffer::Add(this); } +IfcTableColumn::IfcTableColumn(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTableColumn)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTableColumn::IfcTableColumn(boost::optional< std::string > v1_Identifier, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, IfcUnit* v4_Unit, IfcReference* v5_ReferencePath) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Identifier) { e->setArgument(0,(*v1_Identifier)); } else { e->setArgument(0); } 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_Unit)); e->setArgument(4,(v5_ReferencePath)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTableRow -bool IfcTableRow::hasRowCells() const { return !entity->getArgument(0)->isNull(); } -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::hasIsHeading() const { return !entity->getArgument(1)->isNull(); } -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; } +bool IfcTableRow::hasRowCells() const { return !data_->getArgument(0)->isNull(); } +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::hasIsHeading() const { return !data_->getArgument(1)->isNull(); } +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(boost::optional< IfcEntityList::ptr > v1_RowCells, boost::optional< bool > v2_IsHeading) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_RowCells) { e->setArgument(0,(*v1_RowCells)); } else { e->setArgument(0); } if (v2_IsHeading) { e->setArgument(1,(*v2_IsHeading)); } else { e->setArgument(1); } 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(boost::optional< IfcEntityList::ptr > v1_RowCells, boost::optional< bool > v2_IsHeading) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_RowCells) { e->setArgument(0,(*v1_RowCells)); } else { e->setArgument(0); } if (v2_IsHeading) { e->setArgument(1,(*v2_IsHeading)); } else { e->setArgument(1); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTank -bool IfcTank::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcTankTypeEnum::IfcTankTypeEnum IfcTank::PredefinedType() const { return IfcTankTypeEnum::FromString(*entity->getArgument(8)); } -void IfcTank::setPredefinedType(IfcTankTypeEnum::IfcTankTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcTankTypeEnum::ToString(v)); } -bool IfcTank::is(Type::Enum v) const { return v == Type::IfcTank || IfcFlowStorageDevice::is(v); } -Type::Enum IfcTank::type() const { return Type::IfcTank; } +bool IfcTank::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcTankTypeEnum::IfcTankTypeEnum IfcTank::PredefinedType() const { return IfcTankTypeEnum::FromString(*data_->getArgument(8)); } +void IfcTank::setPredefinedType(IfcTankTypeEnum::IfcTankTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcTankTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTank::declaration() const { return *IfcTank_type; } Type::Enum IfcTank::Class() { return Type::IfcTank; } -IfcTank::IfcTank(IfcAbstractEntity* e) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTank)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTank::IfcTank(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTankTypeEnum::IfcTankTypeEnum > v9_PredefinedType) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcTankTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcTank::IfcTank(IfcAbstractEntity* e) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTank)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTank::IfcTank(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTankTypeEnum::IfcTankTypeEnum > v9_PredefinedType) : IfcFlowStorageDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcTankTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 -bool IfcTask::hasStatus() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTask::Status() const { return *entity->getArgument(7); } -void IfcTask::setStatus(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTask::hasWorkMethod() const { return !entity->getArgument(8)->isNull(); } -std::string IfcTask::WorkMethod() const { return *entity->getArgument(8); } -void IfcTask::setWorkMethod(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcTask::IsMilestone() const { return *entity->getArgument(9); } -void IfcTask::setIsMilestone(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcTask::hasPriority() const { return !entity->getArgument(10)->isNull(); } -int IfcTask::Priority() const { return *entity->getArgument(10); } -void IfcTask::setPriority(int v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcTask::hasTaskTime() const { return !entity->getArgument(11)->isNull(); } -IfcTaskTime* IfcTask::TaskTime() const { return (IfcTaskTime*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(11))); } -void IfcTask::setTaskTime(IfcTaskTime* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcTask::hasPredefinedType() const { return !entity->getArgument(12)->isNull(); } -IfcTaskTypeEnum::IfcTaskTypeEnum IfcTask::PredefinedType() const { return IfcTaskTypeEnum::FromString(*entity->getArgument(12)); } -void IfcTask::setPredefinedType(IfcTaskTypeEnum::IfcTaskTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v,IfcTaskTypeEnum::ToString(v)); } -bool IfcTask::is(Type::Enum v) const { return v == Type::IfcTask || IfcProcess::is(v); } -Type::Enum IfcTask::type() const { return Type::IfcTask; } +bool IfcTask::hasStatus() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTask::Status() const { return *data_->getArgument(7); } +void IfcTask::setStatus(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcTask::hasWorkMethod() const { return !data_->getArgument(8)->isNull(); } +std::string IfcTask::WorkMethod() const { return *data_->getArgument(8); } +void IfcTask::setWorkMethod(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcTask::IsMilestone() const { return *data_->getArgument(9); } +void IfcTask::setIsMilestone(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcTask::hasPriority() const { return !data_->getArgument(10)->isNull(); } +int IfcTask::Priority() const { return *data_->getArgument(10); } +void IfcTask::setPriority(int v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcTask::hasTaskTime() const { return !data_->getArgument(11)->isNull(); } +IfcTaskTime* IfcTask::TaskTime() const { return (IfcTaskTime*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(11))); } +void IfcTask::setTaskTime(IfcTaskTime* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcTask::hasPredefinedType() const { return !data_->getArgument(12)->isNull(); } +IfcTaskTypeEnum::IfcTaskTypeEnum IfcTask::PredefinedType() const { return IfcTaskTypeEnum::FromString(*data_->getArgument(12)); } +void IfcTask::setPredefinedType(IfcTaskTypeEnum::IfcTaskTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v,IfcTaskTypeEnum::ToString(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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_WorkMethod, bool v10_IsMilestone, boost::optional< int > v11_Priority, IfcTaskTime* v12_TaskTime, boost::optional< IfcTaskTypeEnum::IfcTaskTypeEnum > v13_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_WorkMethod) { e->setArgument(8,(*v9_WorkMethod)); } else { e->setArgument(8); } e->setArgument(9,(v10_IsMilestone)); if (v11_Priority) { e->setArgument(10,(*v11_Priority)); } else { e->setArgument(10); } e->setArgument(11,(v12_TaskTime)); if (v13_PredefinedType) { e->setArgument(12,*v13_PredefinedType,IfcTaskTypeEnum::ToString(*v13_PredefinedType)); } else { e->setArgument(12); } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_WorkMethod, bool v10_IsMilestone, boost::optional< int > v11_Priority, IfcTaskTime* v12_TaskTime, boost::optional< IfcTaskTypeEnum::IfcTaskTypeEnum > v13_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_LongDescription) { e->setArgument(6,(*v7_LongDescription)); } else { e->setArgument(6); } if (v8_Status) { e->setArgument(7,(*v8_Status)); } else { e->setArgument(7); } if (v9_WorkMethod) { e->setArgument(8,(*v9_WorkMethod)); } else { e->setArgument(8); } e->setArgument(9,(v10_IsMilestone)); if (v11_Priority) { e->setArgument(10,(*v11_Priority)); } else { e->setArgument(10); } e->setArgument(11,(v12_TaskTime)); if (v13_PredefinedType) { e->setArgument(12,*v13_PredefinedType,IfcTaskTypeEnum::ToString(*v13_PredefinedType)); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTaskTime -bool IfcTaskTime::hasDurationType() const { return !entity->getArgument(3)->isNull(); } -IfcTaskDurationEnum::IfcTaskDurationEnum IfcTaskTime::DurationType() const { return IfcTaskDurationEnum::FromString(*entity->getArgument(3)); } -void IfcTaskTime::setDurationType(IfcTaskDurationEnum::IfcTaskDurationEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v,IfcTaskDurationEnum::ToString(v)); } -bool IfcTaskTime::hasScheduleDuration() const { return !entity->getArgument(4)->isNull(); } -std::string IfcTaskTime::ScheduleDuration() const { return *entity->getArgument(4); } -void IfcTaskTime::setScheduleDuration(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTaskTime::hasScheduleStart() const { return !entity->getArgument(5)->isNull(); } -std::string IfcTaskTime::ScheduleStart() const { return *entity->getArgument(5); } -void IfcTaskTime::setScheduleStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcTaskTime::hasScheduleFinish() const { return !entity->getArgument(6)->isNull(); } -std::string IfcTaskTime::ScheduleFinish() const { return *entity->getArgument(6); } -void IfcTaskTime::setScheduleFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTaskTime::hasEarlyStart() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTaskTime::EarlyStart() const { return *entity->getArgument(7); } -void IfcTaskTime::setEarlyStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTaskTime::hasEarlyFinish() const { return !entity->getArgument(8)->isNull(); } -std::string IfcTaskTime::EarlyFinish() const { return *entity->getArgument(8); } -void IfcTaskTime::setEarlyFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -bool IfcTaskTime::hasLateStart() const { return !entity->getArgument(9)->isNull(); } -std::string IfcTaskTime::LateStart() const { return *entity->getArgument(9); } -void IfcTaskTime::setLateStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcTaskTime::hasLateFinish() const { return !entity->getArgument(10)->isNull(); } -std::string IfcTaskTime::LateFinish() const { return *entity->getArgument(10); } -void IfcTaskTime::setLateFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcTaskTime::hasFreeFloat() const { return !entity->getArgument(11)->isNull(); } -std::string IfcTaskTime::FreeFloat() const { return *entity->getArgument(11); } -void IfcTaskTime::setFreeFloat(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcTaskTime::hasTotalFloat() const { return !entity->getArgument(12)->isNull(); } -std::string IfcTaskTime::TotalFloat() const { return *entity->getArgument(12); } -void IfcTaskTime::setTotalFloat(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcTaskTime::hasIsCritical() const { return !entity->getArgument(13)->isNull(); } -bool IfcTaskTime::IsCritical() const { return *entity->getArgument(13); } -void IfcTaskTime::setIsCritical(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcTaskTime::hasStatusTime() const { return !entity->getArgument(14)->isNull(); } -std::string IfcTaskTime::StatusTime() const { return *entity->getArgument(14); } -void IfcTaskTime::setStatusTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcTaskTime::hasActualDuration() const { return !entity->getArgument(15)->isNull(); } -std::string IfcTaskTime::ActualDuration() const { return *entity->getArgument(15); } -void IfcTaskTime::setActualDuration(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcTaskTime::hasActualStart() const { return !entity->getArgument(16)->isNull(); } -std::string IfcTaskTime::ActualStart() const { return *entity->getArgument(16); } -void IfcTaskTime::setActualStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(16,v); } -bool IfcTaskTime::hasActualFinish() const { return !entity->getArgument(17)->isNull(); } -std::string IfcTaskTime::ActualFinish() const { return *entity->getArgument(17); } -void IfcTaskTime::setActualFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(17,v); } -bool IfcTaskTime::hasRemainingTime() const { return !entity->getArgument(18)->isNull(); } -std::string IfcTaskTime::RemainingTime() const { return *entity->getArgument(18); } -void IfcTaskTime::setRemainingTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(18,v); } -bool IfcTaskTime::hasCompletion() const { return !entity->getArgument(19)->isNull(); } -double IfcTaskTime::Completion() const { return *entity->getArgument(19); } -void IfcTaskTime::setCompletion(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(19,v); } -bool IfcTaskTime::is(Type::Enum v) const { return v == Type::IfcTaskTime || IfcSchedulingTime::is(v); } -Type::Enum IfcTaskTime::type() const { return Type::IfcTaskTime; } +bool IfcTaskTime::hasDurationType() const { return !data_->getArgument(3)->isNull(); } +IfcTaskDurationEnum::IfcTaskDurationEnum IfcTaskTime::DurationType() const { return IfcTaskDurationEnum::FromString(*data_->getArgument(3)); } +void IfcTaskTime::setDurationType(IfcTaskDurationEnum::IfcTaskDurationEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v,IfcTaskDurationEnum::ToString(v)); } +bool IfcTaskTime::hasScheduleDuration() const { return !data_->getArgument(4)->isNull(); } +std::string IfcTaskTime::ScheduleDuration() const { return *data_->getArgument(4); } +void IfcTaskTime::setScheduleDuration(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcTaskTime::hasScheduleStart() const { return !data_->getArgument(5)->isNull(); } +std::string IfcTaskTime::ScheduleStart() const { return *data_->getArgument(5); } +void IfcTaskTime::setScheduleStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } +bool IfcTaskTime::hasScheduleFinish() const { return !data_->getArgument(6)->isNull(); } +std::string IfcTaskTime::ScheduleFinish() const { return *data_->getArgument(6); } +void IfcTaskTime::setScheduleFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTaskTime::hasEarlyStart() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTaskTime::EarlyStart() const { return *data_->getArgument(7); } +void IfcTaskTime::setEarlyStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcTaskTime::hasEarlyFinish() const { return !data_->getArgument(8)->isNull(); } +std::string IfcTaskTime::EarlyFinish() const { return *data_->getArgument(8); } +void IfcTaskTime::setEarlyFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } +bool IfcTaskTime::hasLateStart() const { return !data_->getArgument(9)->isNull(); } +std::string IfcTaskTime::LateStart() const { return *data_->getArgument(9); } +void IfcTaskTime::setLateStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcTaskTime::hasLateFinish() const { return !data_->getArgument(10)->isNull(); } +std::string IfcTaskTime::LateFinish() const { return *data_->getArgument(10); } +void IfcTaskTime::setLateFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcTaskTime::hasFreeFloat() const { return !data_->getArgument(11)->isNull(); } +std::string IfcTaskTime::FreeFloat() const { return *data_->getArgument(11); } +void IfcTaskTime::setFreeFloat(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcTaskTime::hasTotalFloat() const { return !data_->getArgument(12)->isNull(); } +std::string IfcTaskTime::TotalFloat() const { return *data_->getArgument(12); } +void IfcTaskTime::setTotalFloat(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } +bool IfcTaskTime::hasIsCritical() const { return !data_->getArgument(13)->isNull(); } +bool IfcTaskTime::IsCritical() const { return *data_->getArgument(13); } +void IfcTaskTime::setIsCritical(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcTaskTime::hasStatusTime() const { return !data_->getArgument(14)->isNull(); } +std::string IfcTaskTime::StatusTime() const { return *data_->getArgument(14); } +void IfcTaskTime::setStatusTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcTaskTime::hasActualDuration() const { return !data_->getArgument(15)->isNull(); } +std::string IfcTaskTime::ActualDuration() const { return *data_->getArgument(15); } +void IfcTaskTime::setActualDuration(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } +bool IfcTaskTime::hasActualStart() const { return !data_->getArgument(16)->isNull(); } +std::string IfcTaskTime::ActualStart() const { return *data_->getArgument(16); } +void IfcTaskTime::setActualStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(16,v); } +bool IfcTaskTime::hasActualFinish() const { return !data_->getArgument(17)->isNull(); } +std::string IfcTaskTime::ActualFinish() const { return *data_->getArgument(17); } +void IfcTaskTime::setActualFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(17,v); } +bool IfcTaskTime::hasRemainingTime() const { return !data_->getArgument(18)->isNull(); } +std::string IfcTaskTime::RemainingTime() const { return *data_->getArgument(18); } +void IfcTaskTime::setRemainingTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(18,v); } +bool IfcTaskTime::hasCompletion() const { return !data_->getArgument(19)->isNull(); } +double IfcTaskTime::Completion() const { return *data_->getArgument(19); } +void IfcTaskTime::setCompletion(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(19,v); } + + +const IfcParse::entity& IfcTaskTime::declaration() const { return *IfcTaskTime_type; } Type::Enum IfcTaskTime::Class() { return Type::IfcTaskTime; } -IfcTaskTime::IfcTaskTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTaskTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTaskTime::IfcTaskTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< IfcTaskDurationEnum::IfcTaskDurationEnum > v4_DurationType, boost::optional< std::string > v5_ScheduleDuration, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_EarlyStart, boost::optional< std::string > v9_EarlyFinish, boost::optional< std::string > v10_LateStart, boost::optional< std::string > v11_LateFinish, boost::optional< std::string > v12_FreeFloat, boost::optional< std::string > v13_TotalFloat, boost::optional< bool > v14_IsCritical, boost::optional< std::string > v15_StatusTime, boost::optional< std::string > v16_ActualDuration, boost::optional< std::string > v17_ActualStart, boost::optional< std::string > v18_ActualFinish, boost::optional< std::string > v19_RemainingTime, boost::optional< double > v20_Completion) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_DurationType) { e->setArgument(3,*v4_DurationType,IfcTaskDurationEnum::ToString(*v4_DurationType)); } else { e->setArgument(3); } if (v5_ScheduleDuration) { e->setArgument(4,(*v5_ScheduleDuration)); } else { e->setArgument(4); } if (v6_ScheduleStart) { e->setArgument(5,(*v6_ScheduleStart)); } else { e->setArgument(5); } if (v7_ScheduleFinish) { e->setArgument(6,(*v7_ScheduleFinish)); } else { e->setArgument(6); } if (v8_EarlyStart) { e->setArgument(7,(*v8_EarlyStart)); } else { e->setArgument(7); } if (v9_EarlyFinish) { e->setArgument(8,(*v9_EarlyFinish)); } else { e->setArgument(8); } if (v10_LateStart) { e->setArgument(9,(*v10_LateStart)); } else { e->setArgument(9); } if (v11_LateFinish) { e->setArgument(10,(*v11_LateFinish)); } else { e->setArgument(10); } if (v12_FreeFloat) { e->setArgument(11,(*v12_FreeFloat)); } else { e->setArgument(11); } if (v13_TotalFloat) { e->setArgument(12,(*v13_TotalFloat)); } else { e->setArgument(12); } if (v14_IsCritical) { e->setArgument(13,(*v14_IsCritical)); } else { e->setArgument(13); } if (v15_StatusTime) { e->setArgument(14,(*v15_StatusTime)); } else { e->setArgument(14); } if (v16_ActualDuration) { e->setArgument(15,(*v16_ActualDuration)); } else { e->setArgument(15); } if (v17_ActualStart) { e->setArgument(16,(*v17_ActualStart)); } else { e->setArgument(16); } if (v18_ActualFinish) { e->setArgument(17,(*v18_ActualFinish)); } else { e->setArgument(17); } if (v19_RemainingTime) { e->setArgument(18,(*v19_RemainingTime)); } else { e->setArgument(18); } if (v20_Completion) { e->setArgument(19,(*v20_Completion)); } else { e->setArgument(19); } entity = e; EntityBuffer::Add(this); } +IfcTaskTime::IfcTaskTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTaskTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTaskTime::IfcTaskTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< IfcTaskDurationEnum::IfcTaskDurationEnum > v4_DurationType, boost::optional< std::string > v5_ScheduleDuration, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_EarlyStart, boost::optional< std::string > v9_EarlyFinish, boost::optional< std::string > v10_LateStart, boost::optional< std::string > v11_LateFinish, boost::optional< std::string > v12_FreeFloat, boost::optional< std::string > v13_TotalFloat, boost::optional< bool > v14_IsCritical, boost::optional< std::string > v15_StatusTime, boost::optional< std::string > v16_ActualDuration, boost::optional< std::string > v17_ActualStart, boost::optional< std::string > v18_ActualFinish, boost::optional< std::string > v19_RemainingTime, boost::optional< double > v20_Completion) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_DurationType) { e->setArgument(3,*v4_DurationType,IfcTaskDurationEnum::ToString(*v4_DurationType)); } else { e->setArgument(3); } if (v5_ScheduleDuration) { e->setArgument(4,(*v5_ScheduleDuration)); } else { e->setArgument(4); } if (v6_ScheduleStart) { e->setArgument(5,(*v6_ScheduleStart)); } else { e->setArgument(5); } if (v7_ScheduleFinish) { e->setArgument(6,(*v7_ScheduleFinish)); } else { e->setArgument(6); } if (v8_EarlyStart) { e->setArgument(7,(*v8_EarlyStart)); } else { e->setArgument(7); } if (v9_EarlyFinish) { e->setArgument(8,(*v9_EarlyFinish)); } else { e->setArgument(8); } if (v10_LateStart) { e->setArgument(9,(*v10_LateStart)); } else { e->setArgument(9); } if (v11_LateFinish) { e->setArgument(10,(*v11_LateFinish)); } else { e->setArgument(10); } if (v12_FreeFloat) { e->setArgument(11,(*v12_FreeFloat)); } else { e->setArgument(11); } if (v13_TotalFloat) { e->setArgument(12,(*v13_TotalFloat)); } else { e->setArgument(12); } if (v14_IsCritical) { e->setArgument(13,(*v14_IsCritical)); } else { e->setArgument(13); } if (v15_StatusTime) { e->setArgument(14,(*v15_StatusTime)); } else { e->setArgument(14); } if (v16_ActualDuration) { e->setArgument(15,(*v16_ActualDuration)); } else { e->setArgument(15); } if (v17_ActualStart) { e->setArgument(16,(*v17_ActualStart)); } else { e->setArgument(16); } if (v18_ActualFinish) { e->setArgument(17,(*v18_ActualFinish)); } else { e->setArgument(17); } if (v19_RemainingTime) { e->setArgument(18,(*v19_RemainingTime)); } else { e->setArgument(18); } if (v20_Completion) { e->setArgument(19,(*v20_Completion)); } else { e->setArgument(19); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTaskTimeRecurring -IfcRecurrencePattern* IfcTaskTimeRecurring::Recurrance() const { return (IfcRecurrencePattern*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(20))); } -void IfcTaskTimeRecurring::setRecurrance(IfcRecurrencePattern* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(20,v); } -bool IfcTaskTimeRecurring::is(Type::Enum v) const { return v == Type::IfcTaskTimeRecurring || IfcTaskTime::is(v); } -Type::Enum IfcTaskTimeRecurring::type() const { return Type::IfcTaskTimeRecurring; } +IfcRecurrencePattern* IfcTaskTimeRecurring::Recurrance() const { return (IfcRecurrencePattern*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(20))); } +void IfcTaskTimeRecurring::setRecurrance(IfcRecurrencePattern* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(20,v); } + + +const IfcParse::entity& IfcTaskTimeRecurring::declaration() const { return *IfcTaskTimeRecurring_type; } Type::Enum IfcTaskTimeRecurring::Class() { return Type::IfcTaskTimeRecurring; } -IfcTaskTimeRecurring::IfcTaskTimeRecurring(IfcAbstractEntity* e) : IfcTaskTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTaskTimeRecurring)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTaskTimeRecurring::IfcTaskTimeRecurring(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< IfcTaskDurationEnum::IfcTaskDurationEnum > v4_DurationType, boost::optional< std::string > v5_ScheduleDuration, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_EarlyStart, boost::optional< std::string > v9_EarlyFinish, boost::optional< std::string > v10_LateStart, boost::optional< std::string > v11_LateFinish, boost::optional< std::string > v12_FreeFloat, boost::optional< std::string > v13_TotalFloat, boost::optional< bool > v14_IsCritical, boost::optional< std::string > v15_StatusTime, boost::optional< std::string > v16_ActualDuration, boost::optional< std::string > v17_ActualStart, boost::optional< std::string > v18_ActualFinish, boost::optional< std::string > v19_RemainingTime, boost::optional< double > v20_Completion, IfcRecurrencePattern* v21_Recurrance) : IfcTaskTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_DurationType) { e->setArgument(3,*v4_DurationType,IfcTaskDurationEnum::ToString(*v4_DurationType)); } else { e->setArgument(3); } if (v5_ScheduleDuration) { e->setArgument(4,(*v5_ScheduleDuration)); } else { e->setArgument(4); } if (v6_ScheduleStart) { e->setArgument(5,(*v6_ScheduleStart)); } else { e->setArgument(5); } if (v7_ScheduleFinish) { e->setArgument(6,(*v7_ScheduleFinish)); } else { e->setArgument(6); } if (v8_EarlyStart) { e->setArgument(7,(*v8_EarlyStart)); } else { e->setArgument(7); } if (v9_EarlyFinish) { e->setArgument(8,(*v9_EarlyFinish)); } else { e->setArgument(8); } if (v10_LateStart) { e->setArgument(9,(*v10_LateStart)); } else { e->setArgument(9); } if (v11_LateFinish) { e->setArgument(10,(*v11_LateFinish)); } else { e->setArgument(10); } if (v12_FreeFloat) { e->setArgument(11,(*v12_FreeFloat)); } else { e->setArgument(11); } if (v13_TotalFloat) { e->setArgument(12,(*v13_TotalFloat)); } else { e->setArgument(12); } if (v14_IsCritical) { e->setArgument(13,(*v14_IsCritical)); } else { e->setArgument(13); } if (v15_StatusTime) { e->setArgument(14,(*v15_StatusTime)); } else { e->setArgument(14); } if (v16_ActualDuration) { e->setArgument(15,(*v16_ActualDuration)); } else { e->setArgument(15); } if (v17_ActualStart) { e->setArgument(16,(*v17_ActualStart)); } else { e->setArgument(16); } if (v18_ActualFinish) { e->setArgument(17,(*v18_ActualFinish)); } else { e->setArgument(17); } if (v19_RemainingTime) { e->setArgument(18,(*v19_RemainingTime)); } else { e->setArgument(18); } if (v20_Completion) { e->setArgument(19,(*v20_Completion)); } else { e->setArgument(19); } e->setArgument(20,(v21_Recurrance)); entity = e; EntityBuffer::Add(this); } +IfcTaskTimeRecurring::IfcTaskTimeRecurring(IfcAbstractEntity* e) : IfcTaskTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTaskTimeRecurring)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTaskTimeRecurring::IfcTaskTimeRecurring(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< IfcTaskDurationEnum::IfcTaskDurationEnum > v4_DurationType, boost::optional< std::string > v5_ScheduleDuration, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_EarlyStart, boost::optional< std::string > v9_EarlyFinish, boost::optional< std::string > v10_LateStart, boost::optional< std::string > v11_LateFinish, boost::optional< std::string > v12_FreeFloat, boost::optional< std::string > v13_TotalFloat, boost::optional< bool > v14_IsCritical, boost::optional< std::string > v15_StatusTime, boost::optional< std::string > v16_ActualDuration, boost::optional< std::string > v17_ActualStart, boost::optional< std::string > v18_ActualFinish, boost::optional< std::string > v19_RemainingTime, boost::optional< double > v20_Completion, IfcRecurrencePattern* v21_Recurrance) : IfcTaskTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } if (v4_DurationType) { e->setArgument(3,*v4_DurationType,IfcTaskDurationEnum::ToString(*v4_DurationType)); } else { e->setArgument(3); } if (v5_ScheduleDuration) { e->setArgument(4,(*v5_ScheduleDuration)); } else { e->setArgument(4); } if (v6_ScheduleStart) { e->setArgument(5,(*v6_ScheduleStart)); } else { e->setArgument(5); } if (v7_ScheduleFinish) { e->setArgument(6,(*v7_ScheduleFinish)); } else { e->setArgument(6); } if (v8_EarlyStart) { e->setArgument(7,(*v8_EarlyStart)); } else { e->setArgument(7); } if (v9_EarlyFinish) { e->setArgument(8,(*v9_EarlyFinish)); } else { e->setArgument(8); } if (v10_LateStart) { e->setArgument(9,(*v10_LateStart)); } else { e->setArgument(9); } if (v11_LateFinish) { e->setArgument(10,(*v11_LateFinish)); } else { e->setArgument(10); } if (v12_FreeFloat) { e->setArgument(11,(*v12_FreeFloat)); } else { e->setArgument(11); } if (v13_TotalFloat) { e->setArgument(12,(*v13_TotalFloat)); } else { e->setArgument(12); } if (v14_IsCritical) { e->setArgument(13,(*v14_IsCritical)); } else { e->setArgument(13); } if (v15_StatusTime) { e->setArgument(14,(*v15_StatusTime)); } else { e->setArgument(14); } if (v16_ActualDuration) { e->setArgument(15,(*v16_ActualDuration)); } else { e->setArgument(15); } if (v17_ActualStart) { e->setArgument(16,(*v17_ActualStart)); } else { e->setArgument(16); } if (v18_ActualFinish) { e->setArgument(17,(*v18_ActualFinish)); } else { e->setArgument(17); } if (v19_RemainingTime) { e->setArgument(18,(*v19_RemainingTime)); } else { e->setArgument(18); } if (v20_Completion) { e->setArgument(19,(*v20_Completion)); } else { e->setArgument(19); } e->setArgument(20,(v21_Recurrance)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTaskType -IfcTaskTypeEnum::IfcTaskTypeEnum IfcTaskType::PredefinedType() const { return IfcTaskTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTaskType::setPredefinedType(IfcTaskTypeEnum::IfcTaskTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTaskTypeEnum::ToString(v)); } -bool IfcTaskType::hasWorkMethod() const { return !entity->getArgument(10)->isNull(); } -std::string IfcTaskType::WorkMethod() const { return *entity->getArgument(10); } -void IfcTaskType::setWorkMethod(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcTaskType::is(Type::Enum v) const { return v == Type::IfcTaskType || IfcTypeProcess::is(v); } -Type::Enum IfcTaskType::type() const { return Type::IfcTaskType; } +IfcTaskTypeEnum::IfcTaskTypeEnum IfcTaskType::PredefinedType() const { return IfcTaskTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTaskType::setPredefinedType(IfcTaskTypeEnum::IfcTaskTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTaskTypeEnum::ToString(v)); } +bool IfcTaskType::hasWorkMethod() const { return !data_->getArgument(10)->isNull(); } +std::string IfcTaskType::WorkMethod() const { return *data_->getArgument(10); } +void IfcTaskType::setWorkMethod(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } + + +const IfcParse::entity& IfcTaskType::declaration() const { return *IfcTaskType_type; } Type::Enum IfcTaskType::Class() { return Type::IfcTaskType; } -IfcTaskType::IfcTaskType(IfcAbstractEntity* e) : IfcTypeProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTaskType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTaskType::IfcTaskType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcTaskTypeEnum::IfcTaskTypeEnum v10_PredefinedType, boost::optional< std::string > v11_WorkMethod) : IfcTypeProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTaskTypeEnum::ToString(v10_PredefinedType)); if (v11_WorkMethod) { e->setArgument(10,(*v11_WorkMethod)); } else { e->setArgument(10); } entity = e; EntityBuffer::Add(this); } +IfcTaskType::IfcTaskType(IfcAbstractEntity* e) : IfcTypeProcess((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTaskType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTaskType::IfcTaskType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcTaskTypeEnum::IfcTaskTypeEnum v10_PredefinedType, boost::optional< std::string > v11_WorkMethod) : IfcTypeProcess((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } e->setArgument(9,v10_PredefinedType,IfcTaskTypeEnum::ToString(v10_PredefinedType)); if (v11_WorkMethod) { e->setArgument(10,(*v11_WorkMethod)); } else { e->setArgument(10); } 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::hasMessagingIDs() const { return !entity->getArgument(8)->isNull(); } -std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::MessagingIDs() const { return *entity->getArgument(8); } -void IfcTelecomAddress::setMessagingIDs(std::vector< std::string > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,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); } +bool IfcTelecomAddress::hasMessagingIDs() const { return !data_->getArgument(8)->isNull(); } +std::vector< std::string > /*[1:?]*/ IfcTelecomAddress::MessagingIDs() const { return *data_->getArgument(8); } +void IfcTelecomAddress::setMessagingIDs(std::vector< std::string > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,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, boost::optional< std::vector< std::string > /*[1:?]*/ > v9_MessagingIDs) : 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); } if (v9_MessagingIDs) { e->setArgument(8,(*v9_MessagingIDs)); } else { e->setArgument(8); } 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, boost::optional< std::vector< std::string > /*[1:?]*/ > v9_MessagingIDs) : 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); } if (v9_MessagingIDs) { e->setArgument(8,(*v9_MessagingIDs)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTendon -bool IfcTendon::hasPredefinedType() const { return !entity->getArgument(9)->isNull(); } -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)); } -bool IfcTendon::hasNominalDiameter() const { return !entity->getArgument(10)->isNull(); } -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); } -bool IfcTendon::hasCrossSectionArea() const { return !entity->getArgument(11)->isNull(); } -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; } +bool IfcTendon::hasPredefinedType() const { return !data_->getArgument(9)->isNull(); } +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)); } +bool IfcTendon::hasNominalDiameter() const { return !data_->getArgument(10)->isNull(); } +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); } +bool IfcTendon::hasCrossSectionArea() const { return !data_->getArgument(11)->isNull(); } +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, boost::optional< IfcTendonTypeEnum::IfcTendonTypeEnum > v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< 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); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcTendonTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_CrossSectionArea) { e->setArgument(11,(*v12_CrossSectionArea)); } else { e->setArgument(11); } 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, boost::optional< IfcTendonTypeEnum::IfcTendonTypeEnum > v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< 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); } if (v10_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcTendonTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_CrossSectionArea) { e->setArgument(11,(*v12_CrossSectionArea)); } else { e->setArgument(11); } 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::hasPredefinedType() const { return !entity->getArgument(9)->isNull(); } -IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum IfcTendonAnchor::PredefinedType() const { return IfcTendonAnchorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTendonAnchor::setPredefinedType(IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTendonAnchorTypeEnum::ToString(v)); } -bool IfcTendonAnchor::is(Type::Enum v) const { return v == Type::IfcTendonAnchor || IfcReinforcingElement::is(v); } -Type::Enum IfcTendonAnchor::type() const { return Type::IfcTendonAnchor; } +bool IfcTendonAnchor::hasPredefinedType() const { return !data_->getArgument(9)->isNull(); } +IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum IfcTendonAnchor::PredefinedType() const { return IfcTendonAnchorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTendonAnchor::setPredefinedType(IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTendonAnchorTypeEnum::ToString(v)); } + + +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, boost::optional< IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum > v10_PredefinedType) : 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_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcTendonAnchorTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } 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, boost::optional< IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum > v10_PredefinedType) : 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_PredefinedType) { e->setArgument(9,*v10_PredefinedType,IfcTendonAnchorTypeEnum::ToString(*v10_PredefinedType)); } else { e->setArgument(9); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTendonAnchorType -IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum IfcTendonAnchorType::PredefinedType() const { return IfcTendonAnchorTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTendonAnchorType::setPredefinedType(IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTendonAnchorTypeEnum::ToString(v)); } -bool IfcTendonAnchorType::is(Type::Enum v) const { return v == Type::IfcTendonAnchorType || IfcReinforcingElementType::is(v); } -Type::Enum IfcTendonAnchorType::type() const { return Type::IfcTendonAnchorType; } +IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum IfcTendonAnchorType::PredefinedType() const { return IfcTendonAnchorTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTendonAnchorType::setPredefinedType(IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTendonAnchorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTendonAnchorType::declaration() const { return *IfcTendonAnchorType_type; } Type::Enum IfcTendonAnchorType::Class() { return Type::IfcTendonAnchorType; } -IfcTendonAnchorType::IfcTendonAnchorType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendonAnchorType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTendonAnchorType::IfcTendonAnchorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v10_PredefinedType) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcTendonAnchorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcTendonAnchorType::IfcTendonAnchorType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendonAnchorType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTendonAnchorType::IfcTendonAnchorType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v10_PredefinedType) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcTendonAnchorTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTendonType -IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendonType::PredefinedType() const { return IfcTendonTypeEnum::FromString(*entity->getArgument(9)); } -void IfcTendonType::setPredefinedType(IfcTendonTypeEnum::IfcTendonTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcTendonTypeEnum::ToString(v)); } -bool IfcTendonType::hasNominalDiameter() const { return !entity->getArgument(10)->isNull(); } -double IfcTendonType::NominalDiameter() const { return *entity->getArgument(10); } -void IfcTendonType::setNominalDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -bool IfcTendonType::hasCrossSectionArea() const { return !entity->getArgument(11)->isNull(); } -double IfcTendonType::CrossSectionArea() const { return *entity->getArgument(11); } -void IfcTendonType::setCrossSectionArea(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcTendonType::hasSheethDiameter() const { return !entity->getArgument(12)->isNull(); } -double IfcTendonType::SheethDiameter() const { return *entity->getArgument(12); } -void IfcTendonType::setSheethDiameter(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcTendonType::is(Type::Enum v) const { return v == Type::IfcTendonType || IfcReinforcingElementType::is(v); } -Type::Enum IfcTendonType::type() const { return Type::IfcTendonType; } +IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendonType::PredefinedType() const { return IfcTendonTypeEnum::FromString(*data_->getArgument(9)); } +void IfcTendonType::setPredefinedType(IfcTendonTypeEnum::IfcTendonTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcTendonTypeEnum::ToString(v)); } +bool IfcTendonType::hasNominalDiameter() const { return !data_->getArgument(10)->isNull(); } +double IfcTendonType::NominalDiameter() const { return *data_->getArgument(10); } +void IfcTendonType::setNominalDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +bool IfcTendonType::hasCrossSectionArea() const { return !data_->getArgument(11)->isNull(); } +double IfcTendonType::CrossSectionArea() const { return *data_->getArgument(11); } +void IfcTendonType::setCrossSectionArea(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcTendonType::hasSheethDiameter() const { return !data_->getArgument(12)->isNull(); } +double IfcTendonType::SheethDiameter() const { return *data_->getArgument(12); } +void IfcTendonType::setSheethDiameter(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcTendonType::declaration() const { return *IfcTendonType_type; } Type::Enum IfcTendonType::Class() { return Type::IfcTendonType; } -IfcTendonType::IfcTendonType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendonType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTendonType::IfcTendonType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTendonTypeEnum::IfcTendonTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_CrossSectionArea, boost::optional< double > v13_SheethDiameter) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcTendonTypeEnum::ToString(v10_PredefinedType)); if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_CrossSectionArea) { e->setArgument(11,(*v12_CrossSectionArea)); } else { e->setArgument(11); } if (v13_SheethDiameter) { e->setArgument(12,(*v13_SheethDiameter)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcTendonType::IfcTendonType(IfcAbstractEntity* e) : IfcReinforcingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTendonType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTendonType::IfcTendonType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTendonTypeEnum::IfcTendonTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_CrossSectionArea, boost::optional< double > v13_SheethDiameter) : IfcReinforcingElementType((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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,IfcTendonTypeEnum::ToString(v10_PredefinedType)); if (v11_NominalDiameter) { e->setArgument(10,(*v11_NominalDiameter)); } else { e->setArgument(10); } if (v12_CrossSectionArea) { e->setArgument(11,(*v12_CrossSectionArea)); } else { e->setArgument(11); } if (v13_SheethDiameter) { e->setArgument(12,(*v13_SheethDiameter)); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTessellatedFaceSet -IfcCartesianPointList3D* IfcTessellatedFaceSet::Coordinates() const { return (IfcCartesianPointList3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); } -void IfcTessellatedFaceSet::setCoordinates(IfcCartesianPointList3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTessellatedFaceSet::hasNormals() const { return !entity->getArgument(1)->isNull(); } -std::vector< std::vector< double > > IfcTessellatedFaceSet::Normals() const { return *entity->getArgument(1); } -void IfcTessellatedFaceSet::setNormals(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTessellatedFaceSet::hasClosed() const { return !entity->getArgument(2)->isNull(); } -bool IfcTessellatedFaceSet::Closed() const { return *entity->getArgument(2); } -void IfcTessellatedFaceSet::setClosed(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -IfcIndexedColourMap::list::ptr IfcTessellatedFaceSet::HasColours() const { return entity->getInverse(Type::IfcIndexedColourMap, 0)->as(); } -IfcIndexedTextureMap::list::ptr IfcTessellatedFaceSet::HasTextures() const { return entity->getInverse(Type::IfcIndexedTextureMap, 1)->as(); } -bool IfcTessellatedFaceSet::is(Type::Enum v) const { return v == Type::IfcTessellatedFaceSet || IfcTessellatedItem::is(v); } -Type::Enum IfcTessellatedFaceSet::type() const { return Type::IfcTessellatedFaceSet; } +IfcCartesianPointList3D* IfcTessellatedFaceSet::Coordinates() const { return (IfcCartesianPointList3D*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(0))); } +void IfcTessellatedFaceSet::setCoordinates(IfcCartesianPointList3D* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +bool IfcTessellatedFaceSet::hasNormals() const { return !data_->getArgument(1)->isNull(); } +std::vector< std::vector< double > > IfcTessellatedFaceSet::Normals() const { return *data_->getArgument(1); } +void IfcTessellatedFaceSet::setNormals(std::vector< std::vector< double > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTessellatedFaceSet::hasClosed() const { return !data_->getArgument(2)->isNull(); } +bool IfcTessellatedFaceSet::Closed() const { return *data_->getArgument(2); } +void IfcTessellatedFaceSet::setClosed(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + +IfcIndexedColourMap::list::ptr IfcTessellatedFaceSet::HasColours() const { return data_->getInverse(Type::IfcIndexedColourMap, 0)->as(); } +IfcIndexedTextureMap::list::ptr IfcTessellatedFaceSet::HasTextures() const { return data_->getInverse(Type::IfcIndexedTextureMap, 1)->as(); } + +const IfcParse::entity& IfcTessellatedFaceSet::declaration() const { return *IfcTessellatedFaceSet_type; } Type::Enum IfcTessellatedFaceSet::Class() { return Type::IfcTessellatedFaceSet; } -IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcAbstractEntity* e) : IfcTessellatedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTessellatedFaceSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed) : IfcTessellatedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v2_Normals) { e->setArgument(1,(*v2_Normals)); } else { e->setArgument(1); } if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); } +IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcAbstractEntity* e) : IfcTessellatedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTessellatedFaceSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed) : IfcTessellatedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v2_Normals) { e->setArgument(1,(*v2_Normals)); } else { e->setArgument(1); } if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTessellatedItem -bool IfcTessellatedItem::is(Type::Enum v) const { return v == Type::IfcTessellatedItem || IfcGeometricRepresentationItem::is(v); } -Type::Enum IfcTessellatedItem::type() const { return Type::IfcTessellatedItem; } + + +const IfcParse::entity& IfcTessellatedItem::declaration() const { return *IfcTessellatedItem_type; } Type::Enum IfcTessellatedItem::Class() { return Type::IfcTessellatedItem; } -IfcTessellatedItem::IfcTessellatedItem(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTessellatedItem)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTessellatedItem::IfcTessellatedItem() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); } +IfcTessellatedItem::IfcTessellatedItem(IfcAbstractEntity* e) : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTessellatedItem)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTessellatedItem::IfcTessellatedItem() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); 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(); } -IfcTextStyleForDefinedFont* IfcTextStyle::TextCharacterAppearance() const { return (IfcTextStyleForDefinedFont*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(1))); } -void IfcTextStyle::setTextCharacterAppearance(IfcTextStyleForDefinedFont* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextStyle::hasTextStyle() const { return !entity->getArgument(2)->isNull(); } -IfcTextStyleTextModel* IfcTextStyle::TextStyle() const { return (IfcTextStyleTextModel*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcTextStyle::setTextStyle(IfcTextStyleTextModel* 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::hasModelOrDraughting() const { return !entity->getArgument(4)->isNull(); } -bool IfcTextStyle::ModelOrDraughting() const { return *entity->getArgument(4); } -void IfcTextStyle::setModelOrDraughting(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,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(); } +IfcTextStyleForDefinedFont* IfcTextStyle::TextCharacterAppearance() const { return (IfcTextStyleForDefinedFont*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(1))); } +void IfcTextStyle::setTextCharacterAppearance(IfcTextStyleForDefinedFont* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTextStyle::hasTextStyle() const { return !data_->getArgument(2)->isNull(); } +IfcTextStyleTextModel* IfcTextStyle::TextStyle() const { return (IfcTextStyleTextModel*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcTextStyle::setTextStyle(IfcTextStyleTextModel* 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); } +bool IfcTextStyle::hasModelOrDraughting() const { return !data_->getArgument(4)->isNull(); } +bool IfcTextStyle::ModelOrDraughting() const { return *data_->getArgument(4); } +void IfcTextStyle::setModelOrDraughting(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,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, IfcTextStyleForDefinedFont* v2_TextCharacterAppearance, IfcTextStyleTextModel* v3_TextStyle, IfcTextFontSelect* v4_TextFontStyle, boost::optional< bool > v5_ModelOrDraughting) : 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)); if (v5_ModelOrDraughting) { e->setArgument(4,(*v5_ModelOrDraughting)); } else { e->setArgument(4); } 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, IfcTextStyleForDefinedFont* v2_TextCharacterAppearance, IfcTextStyleTextModel* v3_TextStyle, IfcTextFontSelect* v4_TextFontStyle, boost::optional< bool > v5_ModelOrDraughting) : 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)); if (v5_ModelOrDraughting) { e->setArgument(4,(*v5_ModelOrDraughting)); } else { e->setArgument(4); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextStyleFontModel -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; } +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, 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)); e->setArgument(1,(v2_FontFamily)); 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, 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)); e->setArgument(1,(v2_FontFamily)); 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Colour)); e->setArgument(1,(v2_BackgroundColour)); entity = e; EntityBuffer::Add(this); } +IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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 IfcTextureCoordinate -IfcTemplatedEntityList< IfcSurfaceTexture >::ptr IfcTextureCoordinate::Maps() const { IfcEntityList::ptr es = *entity->getArgument(0); return es->as(); } -void IfcTextureCoordinate::setMaps(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v->generalize()); } -bool IfcTextureCoordinate::is(Type::Enum v) const { return v == Type::IfcTextureCoordinate || IfcPresentationItem::is(v); } -Type::Enum IfcTextureCoordinate::type() const { return Type::IfcTextureCoordinate; } +IfcTemplatedEntityList< IfcSurfaceTexture >::ptr IfcTextureCoordinate::Maps() const { IfcEntityList::ptr es = *data_->getArgument(0); return es->as(); } +void IfcTextureCoordinate::setMaps(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v->generalize()); } + + +const IfcParse::entity& IfcTextureCoordinate::declaration() const { return *IfcTextureCoordinate_type; } Type::Enum IfcTextureCoordinate::Class() { return Type::IfcTextureCoordinate; } -IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureCoordinate)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextureCoordinate::IfcTextureCoordinate(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); entity = e; EntityBuffer::Add(this); } +IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureCoordinate)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextureCoordinate::IfcTextureCoordinate(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureCoordinateGenerator -std::string IfcTextureCoordinateGenerator::Mode() const { return *entity->getArgument(1); } -void IfcTextureCoordinateGenerator::setMode(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTextureCoordinateGenerator::hasParameter() const { return !entity->getArgument(2)->isNull(); } -std::vector< double > /*[1:?]*/ IfcTextureCoordinateGenerator::Parameter() const { return *entity->getArgument(2); } -void IfcTextureCoordinateGenerator::setParameter(std::vector< double > /*[1:?]*/ v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,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(1); } +void IfcTextureCoordinateGenerator::setMode(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } +bool IfcTextureCoordinateGenerator::hasParameter() const { return !data_->getArgument(2)->isNull(); } +std::vector< double > /*[1:?]*/ IfcTextureCoordinateGenerator::Parameter() const { return *data_->getArgument(2); } +void IfcTextureCoordinateGenerator::setParameter(std::vector< double > /*[1:?]*/ v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,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(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, std::string v2_Mode, boost::optional< std::vector< double > /*[1:?]*/ > v3_Parameter) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_Mode)); if (v3_Parameter) { e->setArgument(2,(*v3_Parameter)); } else { e->setArgument(2); } 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(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, std::string v2_Mode, boost::optional< std::vector< double > /*[1:?]*/ > v3_Parameter) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_Mode)); if (v3_Parameter) { e->setArgument(2,(*v3_Parameter)); } else { e->setArgument(2); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureMap -IfcTemplatedEntityList< IfcTextureVertex >::ptr IfcTextureMap::Vertices() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as(); } -void IfcTextureMap::setVertices(IfcTemplatedEntityList< IfcTextureVertex >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); } -IfcFace* IfcTextureMap::MappedTo() const { return (IfcFace*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(2))); } -void IfcTextureMap::setMappedTo(IfcFace* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -bool IfcTextureMap::is(Type::Enum v) const { return v == Type::IfcTextureMap || IfcTextureCoordinate::is(v); } -Type::Enum IfcTextureMap::type() const { return Type::IfcTextureMap; } +IfcTemplatedEntityList< IfcTextureVertex >::ptr IfcTextureMap::Vertices() const { IfcEntityList::ptr es = *data_->getArgument(1); return es->as(); } +void IfcTextureMap::setVertices(IfcTemplatedEntityList< IfcTextureVertex >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v->generalize()); } +IfcFace* IfcTextureMap::MappedTo() const { return (IfcFace*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(2))); } +void IfcTextureMap::setMappedTo(IfcFace* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } + + +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< IfcSurfaceTexture >::ptr v1_Maps, IfcTemplatedEntityList< IfcTextureVertex >::ptr v2_Vertices, IfcFace* v3_MappedTo) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_Vertices)->generalize()); e->setArgument(2,(v3_MappedTo)); 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< IfcSurfaceTexture >::ptr v1_Maps, IfcTemplatedEntityList< IfcTextureVertex >::ptr v2_Vertices, IfcFace* v3_MappedTo) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_Vertices)->generalize()); e->setArgument(2,(v3_MappedTo)); 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 || IfcPresentationItem::is(v); } -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) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); entity = e; EntityBuffer::Add(this); } +IfcTextureVertex::IfcTextureVertex(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { 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) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTextureVertexList -std::vector< std::vector< double > > IfcTextureVertexList::TexCoordsList() const { return *entity->getArgument(0); } -void IfcTextureVertexList::setTexCoordsList(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -bool IfcTextureVertexList::is(Type::Enum v) const { return v == Type::IfcTextureVertexList || IfcPresentationItem::is(v); } -Type::Enum IfcTextureVertexList::type() const { return Type::IfcTextureVertexList; } +std::vector< std::vector< double > > IfcTextureVertexList::TexCoordsList() const { return *data_->getArgument(0); } +void IfcTextureVertexList::setTexCoordsList(std::vector< std::vector< double > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } + + +const IfcParse::entity& IfcTextureVertexList::declaration() const { return *IfcTextureVertexList_type; } Type::Enum IfcTextureVertexList::Class() { return Type::IfcTextureVertexList; } -IfcTextureVertexList::IfcTextureVertexList(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureVertexList)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTextureVertexList::IfcTextureVertexList(std::vector< std::vector< double > > v1_TexCoordsList) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TexCoordsList)); entity = e; EntityBuffer::Add(this); } +IfcTextureVertexList::IfcTextureVertexList(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureVertexList)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTextureVertexList::IfcTextureVertexList(std::vector< std::vector< double > > v1_TexCoordsList) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TexCoordsList)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcTimePeriod -std::string IfcTimePeriod::StartTime() const { return *entity->getArgument(0); } -void IfcTimePeriod::setStartTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); } -std::string IfcTimePeriod::EndTime() const { return *entity->getArgument(1); } -void IfcTimePeriod::setEndTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); } -bool IfcTimePeriod::is(Type::Enum v) const { return v == Type::IfcTimePeriod; } -Type::Enum IfcTimePeriod::type() const { return Type::IfcTimePeriod; } +std::string IfcTimePeriod::StartTime() const { return *data_->getArgument(0); } +void IfcTimePeriod::setStartTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(0,v); } +std::string IfcTimePeriod::EndTime() const { return *data_->getArgument(1); } +void IfcTimePeriod::setEndTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(1,v); } + + +const IfcParse::entity& IfcTimePeriod::declaration() const { return *IfcTimePeriod_type; } Type::Enum IfcTimePeriod::Class() { return Type::IfcTimePeriod; } -IfcTimePeriod::IfcTimePeriod(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimePeriod)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTimePeriod::IfcTimePeriod(std::string v1_StartTime, std::string v2_EndTime) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_StartTime)); e->setArgument(1,(v2_EndTime)); entity = e; EntityBuffer::Add(this); } +IfcTimePeriod::IfcTimePeriod(IfcAbstractEntity* e) : IfcUtil::IfcBaseEntity() { if (!e) return; if (!e->is(Type::IfcTimePeriod)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTimePeriod::IfcTimePeriod(std::string v1_StartTime, std::string v2_EndTime) : IfcUtil::IfcBaseEntity() { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_StartTime)); e->setArgument(1,(v2_EndTime)); 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); } -std::string IfcTimeSeries::StartTime() const { return *entity->getArgument(2); } -void IfcTimeSeries::setStartTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); } -std::string IfcTimeSeries::EndTime() const { return *entity->getArgument(3); } -void IfcTimeSeries::setEndTime(std::string 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); } -IfcExternalReferenceRelationship::list::ptr IfcTimeSeries::HasExternalReference() const { return entity->getInverse(Type::IfcExternalReferenceRelationship, 3)->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); } +std::string IfcTimeSeries::StartTime() const { return *data_->getArgument(2); } +void IfcTimeSeries::setStartTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(2,v); } +std::string IfcTimeSeries::EndTime() const { return *data_->getArgument(3); } +void IfcTimeSeries::setEndTime(std::string 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); } + +IfcExternalReferenceRelationship::list::ptr IfcTimeSeries::HasExternalReference() const { return data_->getInverse(Type::IfcExternalReferenceRelationship, 3)->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, std::string v3_StartTime, std::string 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, std::string v3_StartTime, std::string 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 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 IfcTransformer -bool IfcTransformer::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformer::PredefinedType() const { return IfcTransformerTypeEnum::FromString(*entity->getArgument(8)); } -void IfcTransformer::setPredefinedType(IfcTransformerTypeEnum::IfcTransformerTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcTransformerTypeEnum::ToString(v)); } -bool IfcTransformer::is(Type::Enum v) const { return v == Type::IfcTransformer || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcTransformer::type() const { return Type::IfcTransformer; } +bool IfcTransformer::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformer::PredefinedType() const { return IfcTransformerTypeEnum::FromString(*data_->getArgument(8)); } +void IfcTransformer::setPredefinedType(IfcTransformerTypeEnum::IfcTransformerTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcTransformerTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTransformer::declaration() const { return *IfcTransformer_type; } Type::Enum IfcTransformer::Class() { return Type::IfcTransformer; } -IfcTransformer::IfcTransformer(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransformer)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTransformer::IfcTransformer(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTransformerTypeEnum::IfcTransformerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcTransformerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcTransformer::IfcTransformer(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTransformer)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTransformer::IfcTransformer(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTransformerTypeEnum::IfcTransformerTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcTransformerTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElement::PredefinedType() const { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcTransportElement::setPredefinedType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcTransportElementTypeEnum::ToString(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::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElement::PredefinedType() const { return IfcTransportElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcTransportElement::setPredefinedType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcTransportElementTypeEnum::ToString(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_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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcTransportElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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_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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcTransportElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcTriangulatedFaceSet -std::vector< std::vector< int > > IfcTriangulatedFaceSet::CoordIndex() const { return *entity->getArgument(3); } -void IfcTriangulatedFaceSet::setCoordIndex(std::vector< std::vector< int > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcTriangulatedFaceSet::hasNormalIndex() const { return !entity->getArgument(4)->isNull(); } -std::vector< std::vector< int > > IfcTriangulatedFaceSet::NormalIndex() const { return *entity->getArgument(4); } -void IfcTriangulatedFaceSet::setNormalIndex(std::vector< std::vector< int > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcTriangulatedFaceSet::is(Type::Enum v) const { return v == Type::IfcTriangulatedFaceSet || IfcTessellatedFaceSet::is(v); } -Type::Enum IfcTriangulatedFaceSet::type() const { return Type::IfcTriangulatedFaceSet; } +std::vector< std::vector< int > > IfcTriangulatedFaceSet::CoordIndex() const { return *data_->getArgument(3); } +void IfcTriangulatedFaceSet::setCoordIndex(std::vector< std::vector< int > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcTriangulatedFaceSet::hasNormalIndex() const { return !data_->getArgument(4)->isNull(); } +std::vector< std::vector< int > > IfcTriangulatedFaceSet::NormalIndex() const { return *data_->getArgument(4); } +void IfcTriangulatedFaceSet::setNormalIndex(std::vector< std::vector< int > > v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } + + +const IfcParse::entity& IfcTriangulatedFaceSet::declaration() const { return *IfcTriangulatedFaceSet_type; } Type::Enum IfcTriangulatedFaceSet::Class() { return Type::IfcTriangulatedFaceSet; } -IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcAbstractEntity* e) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTriangulatedFaceSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed, std::vector< std::vector< int > > v4_CoordIndex, boost::optional< std::vector< std::vector< int > > > v5_NormalIndex) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v2_Normals) { e->setArgument(1,(*v2_Normals)); } else { e->setArgument(1); } if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } e->setArgument(3,(v4_CoordIndex)); if (v5_NormalIndex) { e->setArgument(4,(*v5_NormalIndex)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); } +IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcAbstractEntity* e) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTriangulatedFaceSet)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed, std::vector< std::vector< int > > v4_CoordIndex, boost::optional< std::vector< std::vector< int > > > v5_NormalIndex) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v2_Normals) { e->setArgument(1,(*v2_Normals)); } else { e->setArgument(1); } if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } e->setArgument(3,(v4_CoordIndex)); if (v5_NormalIndex) { e->setArgument(4,(*v5_NormalIndex)); } else { e->setArgument(4); } 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 IfcTubeBundle -bool IfcTubeBundle::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundle::PredefinedType() const { return IfcTubeBundleTypeEnum::FromString(*entity->getArgument(8)); } -void IfcTubeBundle::setPredefinedType(IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcTubeBundleTypeEnum::ToString(v)); } -bool IfcTubeBundle::is(Type::Enum v) const { return v == Type::IfcTubeBundle || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcTubeBundle::type() const { return Type::IfcTubeBundle; } +bool IfcTubeBundle::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundle::PredefinedType() const { return IfcTubeBundleTypeEnum::FromString(*data_->getArgument(8)); } +void IfcTubeBundle::setPredefinedType(IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcTubeBundleTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcTubeBundle::declaration() const { return *IfcTubeBundle_type; } Type::Enum IfcTubeBundle::Class() { return Type::IfcTubeBundle; } -IfcTubeBundle::IfcTubeBundle(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTubeBundle)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTubeBundle::IfcTubeBundle(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcTubeBundleTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcTubeBundle::IfcTubeBundle(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTubeBundle)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTubeBundle::IfcTubeBundle(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcTubeBundleTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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::Types() 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::Types() 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 IfcTypeProcess -bool IfcTypeProcess::hasIdentification() const { return !entity->getArgument(6)->isNull(); } -std::string IfcTypeProcess::Identification() const { return *entity->getArgument(6); } -void IfcTypeProcess::setIdentification(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTypeProcess::hasLongDescription() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTypeProcess::LongDescription() const { return *entity->getArgument(7); } -void IfcTypeProcess::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTypeProcess::hasProcessType() const { return !entity->getArgument(8)->isNull(); } -std::string IfcTypeProcess::ProcessType() const { return *entity->getArgument(8); } -void IfcTypeProcess::setProcessType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcRelAssignsToProcess::list::ptr IfcTypeProcess::OperatesOn() const { return entity->getInverse(Type::IfcRelAssignsToProcess, 6)->as(); } -bool IfcTypeProcess::is(Type::Enum v) const { return v == Type::IfcTypeProcess || IfcTypeObject::is(v); } -Type::Enum IfcTypeProcess::type() const { return Type::IfcTypeProcess; } +bool IfcTypeProcess::hasIdentification() const { return !data_->getArgument(6)->isNull(); } +std::string IfcTypeProcess::Identification() const { return *data_->getArgument(6); } +void IfcTypeProcess::setIdentification(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTypeProcess::hasLongDescription() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTypeProcess::LongDescription() const { return *data_->getArgument(7); } +void IfcTypeProcess::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcTypeProcess::hasProcessType() const { return !data_->getArgument(8)->isNull(); } +std::string IfcTypeProcess::ProcessType() const { return *data_->getArgument(8); } +void IfcTypeProcess::setProcessType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + +IfcRelAssignsToProcess::list::ptr IfcTypeProcess::OperatesOn() const { return data_->getInverse(Type::IfcRelAssignsToProcess, 6)->as(); } + +const IfcParse::entity& IfcTypeProcess::declaration() const { return *IfcTypeProcess_type; } Type::Enum IfcTypeProcess::Class() { return Type::IfcTypeProcess; } -IfcTypeProcess::IfcTypeProcess(IfcAbstractEntity* e) : IfcTypeObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeProcess)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTypeProcess::IfcTypeProcess(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType) : 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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcTypeProcess::IfcTypeProcess(IfcAbstractEntity* e) : IfcTypeObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeProcess)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTypeProcess::IfcTypeProcess(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType) : 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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ProcessType) { e->setArgument(8,(*v9_ProcessType)); } else { e->setArgument(8); } 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); } -IfcRelAssignsToProduct::list::ptr IfcTypeProduct::ReferencedBy() const { return entity->getInverse(Type::IfcRelAssignsToProduct, 6)->as(); } -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); } + +IfcRelAssignsToProduct::list::ptr IfcTypeProduct::ReferencedBy() const { return data_->getInverse(Type::IfcRelAssignsToProduct, 6)->as(); } + +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 IfcTypeResource -bool IfcTypeResource::hasIdentification() const { return !entity->getArgument(6)->isNull(); } -std::string IfcTypeResource::Identification() const { return *entity->getArgument(6); } -void IfcTypeResource::setIdentification(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v); } -bool IfcTypeResource::hasLongDescription() const { return !entity->getArgument(7)->isNull(); } -std::string IfcTypeResource::LongDescription() const { return *entity->getArgument(7); } -void IfcTypeResource::setLongDescription(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v); } -bool IfcTypeResource::hasResourceType() const { return !entity->getArgument(8)->isNull(); } -std::string IfcTypeResource::ResourceType() const { return *entity->getArgument(8); } -void IfcTypeResource::setResourceType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v); } -IfcRelAssignsToResource::list::ptr IfcTypeResource::ResourceOf() const { return entity->getInverse(Type::IfcRelAssignsToResource, 6)->as(); } -bool IfcTypeResource::is(Type::Enum v) const { return v == Type::IfcTypeResource || IfcTypeObject::is(v); } -Type::Enum IfcTypeResource::type() const { return Type::IfcTypeResource; } +bool IfcTypeResource::hasIdentification() const { return !data_->getArgument(6)->isNull(); } +std::string IfcTypeResource::Identification() const { return *data_->getArgument(6); } +void IfcTypeResource::setIdentification(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v); } +bool IfcTypeResource::hasLongDescription() const { return !data_->getArgument(7)->isNull(); } +std::string IfcTypeResource::LongDescription() const { return *data_->getArgument(7); } +void IfcTypeResource::setLongDescription(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v); } +bool IfcTypeResource::hasResourceType() const { return !data_->getArgument(8)->isNull(); } +std::string IfcTypeResource::ResourceType() const { return *data_->getArgument(8); } +void IfcTypeResource::setResourceType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v); } + +IfcRelAssignsToResource::list::ptr IfcTypeResource::ResourceOf() const { return data_->getInverse(Type::IfcRelAssignsToResource, 6)->as(); } + +const IfcParse::entity& IfcTypeResource::declaration() const { return *IfcTypeResource_type; } Type::Enum IfcTypeResource::Class() { return Type::IfcTypeResource; } -IfcTypeResource::IfcTypeResource(IfcAbstractEntity* e) : IfcTypeObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeResource)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcTypeResource::IfcTypeResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType) : 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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcTypeResource::IfcTypeResource(IfcAbstractEntity* e) : IfcTypeObject((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTypeResource)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcTypeResource::IfcTypeResource(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType) : 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_Identification) { e->setArgument(6,(*v7_Identification)); } else { e->setArgument(6); } if (v8_LongDescription) { e->setArgument(7,(*v8_LongDescription)); } else { e->setArgument(7); } if (v9_ResourceType) { e->setArgument(8,(*v9_ResourceType)); } else { e->setArgument(8); } 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::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); } + + +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) : 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); } 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) : 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); } 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 IfcUnitaryControlElement -bool IfcUnitaryControlElement::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum IfcUnitaryControlElement::PredefinedType() const { return IfcUnitaryControlElementTypeEnum::FromString(*entity->getArgument(8)); } -void IfcUnitaryControlElement::setPredefinedType(IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcUnitaryControlElementTypeEnum::ToString(v)); } -bool IfcUnitaryControlElement::is(Type::Enum v) const { return v == Type::IfcUnitaryControlElement || IfcDistributionControlElement::is(v); } -Type::Enum IfcUnitaryControlElement::type() const { return Type::IfcUnitaryControlElement; } +bool IfcUnitaryControlElement::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum IfcUnitaryControlElement::PredefinedType() const { return IfcUnitaryControlElementTypeEnum::FromString(*data_->getArgument(8)); } +void IfcUnitaryControlElement::setPredefinedType(IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcUnitaryControlElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcUnitaryControlElement::declaration() const { return *IfcUnitaryControlElement_type; } Type::Enum IfcUnitaryControlElement::Class() { return Type::IfcUnitaryControlElement; } -IfcUnitaryControlElement::IfcUnitaryControlElement(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryControlElement)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcUnitaryControlElement::IfcUnitaryControlElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcUnitaryControlElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcUnitaryControlElement::IfcUnitaryControlElement(IfcAbstractEntity* e) : IfcDistributionControlElement((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryControlElement)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcUnitaryControlElement::IfcUnitaryControlElement(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum > v9_PredefinedType) : IfcDistributionControlElement((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcUnitaryControlElementTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcUnitaryControlElementType -IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum IfcUnitaryControlElementType::PredefinedType() const { return IfcUnitaryControlElementTypeEnum::FromString(*entity->getArgument(9)); } -void IfcUnitaryControlElementType::setPredefinedType(IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcUnitaryControlElementTypeEnum::ToString(v)); } -bool IfcUnitaryControlElementType::is(Type::Enum v) const { return v == Type::IfcUnitaryControlElementType || IfcDistributionControlElementType::is(v); } -Type::Enum IfcUnitaryControlElementType::type() const { return Type::IfcUnitaryControlElementType; } +IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum IfcUnitaryControlElementType::PredefinedType() const { return IfcUnitaryControlElementTypeEnum::FromString(*data_->getArgument(9)); } +void IfcUnitaryControlElementType::setPredefinedType(IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcUnitaryControlElementTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcUnitaryControlElementType::declaration() const { return *IfcUnitaryControlElementType_type; } Type::Enum IfcUnitaryControlElementType::Class() { return Type::IfcUnitaryControlElementType; } -IfcUnitaryControlElementType::IfcUnitaryControlElementType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryControlElementType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcUnitaryControlElementType::IfcUnitaryControlElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum 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,IfcUnitaryControlElementTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcUnitaryControlElementType::IfcUnitaryControlElementType(IfcAbstractEntity* e) : IfcDistributionControlElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryControlElementType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcUnitaryControlElementType::IfcUnitaryControlElementType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum 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,IfcUnitaryControlElementTypeEnum::ToString(v10_PredefinedType)); data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcUnitaryEquipment -bool IfcUnitaryEquipment::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipment::PredefinedType() const { return IfcUnitaryEquipmentTypeEnum::FromString(*entity->getArgument(8)); } -void IfcUnitaryEquipment::setPredefinedType(IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcUnitaryEquipmentTypeEnum::ToString(v)); } -bool IfcUnitaryEquipment::is(Type::Enum v) const { return v == Type::IfcUnitaryEquipment || IfcEnergyConversionDevice::is(v); } -Type::Enum IfcUnitaryEquipment::type() const { return Type::IfcUnitaryEquipment; } +bool IfcUnitaryEquipment::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipment::PredefinedType() const { return IfcUnitaryEquipmentTypeEnum::FromString(*data_->getArgument(8)); } +void IfcUnitaryEquipment::setPredefinedType(IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcUnitaryEquipmentTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcUnitaryEquipment::declaration() const { return *IfcUnitaryEquipment_type; } Type::Enum IfcUnitaryEquipment::Class() { return Type::IfcUnitaryEquipment; } -IfcUnitaryEquipment::IfcUnitaryEquipment(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryEquipment)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcUnitaryEquipment::IfcUnitaryEquipment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcUnitaryEquipmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcUnitaryEquipment::IfcUnitaryEquipment(IfcAbstractEntity* e) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcUnitaryEquipment)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcUnitaryEquipment::IfcUnitaryEquipment(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum > v9_PredefinedType) : IfcEnergyConversionDevice((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcUnitaryEquipmentTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcValve -bool IfcValve::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcValveTypeEnum::IfcValveTypeEnum IfcValve::PredefinedType() const { return IfcValveTypeEnum::FromString(*entity->getArgument(8)); } -void IfcValve::setPredefinedType(IfcValveTypeEnum::IfcValveTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcValveTypeEnum::ToString(v)); } -bool IfcValve::is(Type::Enum v) const { return v == Type::IfcValve || IfcFlowController::is(v); } -Type::Enum IfcValve::type() const { return Type::IfcValve; } +bool IfcValve::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcValveTypeEnum::IfcValveTypeEnum IfcValve::PredefinedType() const { return IfcValveTypeEnum::FromString(*data_->getArgument(8)); } +void IfcValve::setPredefinedType(IfcValveTypeEnum::IfcValveTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcValveTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcValve::declaration() const { return *IfcValve_type; } Type::Enum IfcValve::Class() { return Type::IfcValve; } -IfcValve::IfcValve(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcValve)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcValve::IfcValve(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcValveTypeEnum::IfcValveTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcValveTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcValve::IfcValve(IfcAbstractEntity* e) : IfcFlowController((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcValve)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcValve::IfcValve(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcValveTypeEnum::IfcValveTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcValveTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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 IfcVibrationIsolator -bool IfcVibrationIsolator::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolator::PredefinedType() const { return IfcVibrationIsolatorTypeEnum::FromString(*entity->getArgument(8)); } -void IfcVibrationIsolator::setPredefinedType(IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcVibrationIsolatorTypeEnum::ToString(v)); } -bool IfcVibrationIsolator::is(Type::Enum v) const { return v == Type::IfcVibrationIsolator || IfcElementComponent::is(v); } -Type::Enum IfcVibrationIsolator::type() const { return Type::IfcVibrationIsolator; } +bool IfcVibrationIsolator::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolator::PredefinedType() const { return IfcVibrationIsolatorTypeEnum::FromString(*data_->getArgument(8)); } +void IfcVibrationIsolator::setPredefinedType(IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcVibrationIsolatorTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcVibrationIsolator::declaration() const { return *IfcVibrationIsolator_type; } Type::Enum IfcVibrationIsolator::Class() { return Type::IfcVibrationIsolator; } -IfcVibrationIsolator::IfcVibrationIsolator(IfcAbstractEntity* e) : IfcElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVibrationIsolator)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVibrationIsolator::IfcVibrationIsolator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcVibrationIsolatorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcVibrationIsolator::IfcVibrationIsolator(IfcAbstractEntity* e) : IfcElementComponent((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVibrationIsolator)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVibrationIsolator::IfcVibrationIsolator(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcVibrationIsolatorTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 || IfcElementComponentType::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) : IfcElementComponentType((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) : 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); } e->setArgument(9,v10_PredefinedType,IfcVibrationIsolatorTypeEnum::ToString(v10_PredefinedType)); entity = e; EntityBuffer::Add(this); } +IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcAbstractEntity* e) : IfcElementComponentType((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) : 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); } 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 IfcVoidingFeature -bool IfcVoidingFeature::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum IfcVoidingFeature::PredefinedType() const { return IfcVoidingFeatureTypeEnum::FromString(*entity->getArgument(8)); } -void IfcVoidingFeature::setPredefinedType(IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcVoidingFeatureTypeEnum::ToString(v)); } -bool IfcVoidingFeature::is(Type::Enum v) const { return v == Type::IfcVoidingFeature || IfcFeatureElementSubtraction::is(v); } -Type::Enum IfcVoidingFeature::type() const { return Type::IfcVoidingFeature; } +bool IfcVoidingFeature::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum IfcVoidingFeature::PredefinedType() const { return IfcVoidingFeatureTypeEnum::FromString(*data_->getArgument(8)); } +void IfcVoidingFeature::setPredefinedType(IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcVoidingFeatureTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcVoidingFeature::declaration() const { return *IfcVoidingFeature_type; } Type::Enum IfcVoidingFeature::Class() { return Type::IfcVoidingFeature; } -IfcVoidingFeature::IfcVoidingFeature(IfcAbstractEntity* e) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVoidingFeature)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcVoidingFeature::IfcVoidingFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum > v9_PredefinedType) : 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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcVoidingFeatureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcVoidingFeature::IfcVoidingFeature(IfcAbstractEntity* e) : IfcFeatureElementSubtraction((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcVoidingFeature)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcVoidingFeature::IfcVoidingFeature(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum > v9_PredefinedType) : 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_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcVoidingFeatureTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWall -bool IfcWall::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcWallTypeEnum::IfcWallTypeEnum IfcWall::PredefinedType() const { return IfcWallTypeEnum::FromString(*entity->getArgument(8)); } -void IfcWall::setPredefinedType(IfcWallTypeEnum::IfcWallTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcWallTypeEnum::ToString(v)); } -bool IfcWall::is(Type::Enum v) const { return v == Type::IfcWall || IfcBuildingElement::is(v); } -Type::Enum IfcWall::type() const { return Type::IfcWall; } +bool IfcWall::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcWallTypeEnum::IfcWallTypeEnum IfcWall::PredefinedType() const { return IfcWallTypeEnum::FromString(*data_->getArgument(8)); } +void IfcWall::setPredefinedType(IfcWallTypeEnum::IfcWallTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcWallTypeEnum::ToString(v)); } + + +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, boost::optional< IfcWallTypeEnum::IfcWallTypeEnum > 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,IfcWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcWallTypeEnum::IfcWallTypeEnum > 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,IfcWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWallElementedCase -bool IfcWallElementedCase::is(Type::Enum v) const { return v == Type::IfcWallElementedCase || IfcWall::is(v); } -Type::Enum IfcWallElementedCase::type() const { return Type::IfcWallElementedCase; } + + +const IfcParse::entity& IfcWallElementedCase::declaration() const { return *IfcWallElementedCase_type; } Type::Enum IfcWallElementedCase::Class() { return Type::IfcWallElementedCase; } -IfcWallElementedCase::IfcWallElementedCase(IfcAbstractEntity* e) : IfcWall((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWallElementedCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWallElementedCase::IfcWallElementedCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcWallElementedCase::IfcWallElementedCase(IfcAbstractEntity* e) : IfcWall((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWallElementedCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWallElementedCase::IfcWallElementedCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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, boost::optional< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType) : 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); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcWallTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 IfcWasteTerminal -bool IfcWasteTerminal::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminal::PredefinedType() const { return IfcWasteTerminalTypeEnum::FromString(*entity->getArgument(8)); } -void IfcWasteTerminal::setPredefinedType(IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcWasteTerminalTypeEnum::ToString(v)); } -bool IfcWasteTerminal::is(Type::Enum v) const { return v == Type::IfcWasteTerminal || IfcFlowTerminal::is(v); } -Type::Enum IfcWasteTerminal::type() const { return Type::IfcWasteTerminal; } +bool IfcWasteTerminal::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminal::PredefinedType() const { return IfcWasteTerminalTypeEnum::FromString(*data_->getArgument(8)); } +void IfcWasteTerminal::setPredefinedType(IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcWasteTerminalTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcWasteTerminal::declaration() const { return *IfcWasteTerminal_type; } Type::Enum IfcWasteTerminal::Class() { return Type::IfcWasteTerminal; } -IfcWasteTerminal::IfcWasteTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWasteTerminal)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWasteTerminal::IfcWasteTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcWasteTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcWasteTerminal::IfcWasteTerminal(IfcAbstractEntity* e) : IfcFlowTerminal((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWasteTerminal)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWasteTerminal::IfcWasteTerminal(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum > v9_PredefinedType) : IfcFlowTerminal((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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,IfcWasteTerminalTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } 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 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::hasPredefinedType() const { return !entity->getArgument(10)->isNull(); } -IfcWindowTypeEnum::IfcWindowTypeEnum IfcWindow::PredefinedType() const { return IfcWindowTypeEnum::FromString(*entity->getArgument(10)); } -void IfcWindow::setPredefinedType(IfcWindowTypeEnum::IfcWindowTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcWindowTypeEnum::ToString(v)); } -bool IfcWindow::hasPartitioningType() const { return !entity->getArgument(11)->isNull(); } -IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum IfcWindow::PartitioningType() const { return IfcWindowTypePartitioningEnum::FromString(*entity->getArgument(11)); } -void IfcWindow::setPartitioningType(IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v,IfcWindowTypePartitioningEnum::ToString(v)); } -bool IfcWindow::hasUserDefinedPartitioningType() const { return !entity->getArgument(12)->isNull(); } -std::string IfcWindow::UserDefinedPartitioningType() const { return *entity->getArgument(12); } -void IfcWindow::setUserDefinedPartitioningType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,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); } +bool IfcWindow::hasPredefinedType() const { return !data_->getArgument(10)->isNull(); } +IfcWindowTypeEnum::IfcWindowTypeEnum IfcWindow::PredefinedType() const { return IfcWindowTypeEnum::FromString(*data_->getArgument(10)); } +void IfcWindow::setPredefinedType(IfcWindowTypeEnum::IfcWindowTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcWindowTypeEnum::ToString(v)); } +bool IfcWindow::hasPartitioningType() const { return !data_->getArgument(11)->isNull(); } +IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum IfcWindow::PartitioningType() const { return IfcWindowTypePartitioningEnum::FromString(*data_->getArgument(11)); } +void IfcWindow::setPartitioningType(IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v,IfcWindowTypePartitioningEnum::ToString(v)); } +bool IfcWindow::hasUserDefinedPartitioningType() const { return !data_->getArgument(12)->isNull(); } +std::string IfcWindow::UserDefinedPartitioningType() const { return *data_->getArgument(12); } +void IfcWindow::setUserDefinedPartitioningType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,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, boost::optional< IfcWindowTypeEnum::IfcWindowTypeEnum > v11_PredefinedType, boost::optional< IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum > v12_PartitioningType, boost::optional< std::string > v13_UserDefinedPartitioningType) : 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcWindowTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_PartitioningType) { e->setArgument(11,*v12_PartitioningType,IfcWindowTypePartitioningEnum::ToString(*v12_PartitioningType)); } else { e->setArgument(11); } if (v13_UserDefinedPartitioningType) { e->setArgument(12,(*v13_UserDefinedPartitioningType)); } else { e->setArgument(12); } 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, boost::optional< IfcWindowTypeEnum::IfcWindowTypeEnum > v11_PredefinedType, boost::optional< IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum > v12_PartitioningType, boost::optional< std::string > v13_UserDefinedPartitioningType) : 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcWindowTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_PartitioningType) { e->setArgument(11,*v12_PartitioningType,IfcWindowTypePartitioningEnum::ToString(*v12_PartitioningType)); } else { e->setArgument(11); } if (v13_UserDefinedPartitioningType) { e->setArgument(12,(*v13_UserDefinedPartitioningType)); } else { e->setArgument(12); } 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::hasLiningOffset() const { return !entity->getArgument(13)->isNull(); } -double IfcWindowLiningProperties::LiningOffset() const { return *entity->getArgument(13); } -void IfcWindowLiningProperties::setLiningOffset(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v); } -bool IfcWindowLiningProperties::hasLiningToPanelOffsetX() const { return !entity->getArgument(14)->isNull(); } -double IfcWindowLiningProperties::LiningToPanelOffsetX() const { return *entity->getArgument(14); } -void IfcWindowLiningProperties::setLiningToPanelOffsetX(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(14,v); } -bool IfcWindowLiningProperties::hasLiningToPanelOffsetY() const { return !entity->getArgument(15)->isNull(); } -double IfcWindowLiningProperties::LiningToPanelOffsetY() const { return *entity->getArgument(15); } -void IfcWindowLiningProperties::setLiningToPanelOffsetY(double v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(15,v); } -bool IfcWindowLiningProperties::is(Type::Enum v) const { return v == Type::IfcWindowLiningProperties || IfcPreDefinedPropertySet::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); } +bool IfcWindowLiningProperties::hasLiningOffset() const { return !data_->getArgument(13)->isNull(); } +double IfcWindowLiningProperties::LiningOffset() const { return *data_->getArgument(13); } +void IfcWindowLiningProperties::setLiningOffset(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v); } +bool IfcWindowLiningProperties::hasLiningToPanelOffsetX() const { return !data_->getArgument(14)->isNull(); } +double IfcWindowLiningProperties::LiningToPanelOffsetX() const { return *data_->getArgument(14); } +void IfcWindowLiningProperties::setLiningToPanelOffsetX(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(14,v); } +bool IfcWindowLiningProperties::hasLiningToPanelOffsetY() const { return !data_->getArgument(15)->isNull(); } +double IfcWindowLiningProperties::LiningToPanelOffsetY() const { return *data_->getArgument(15); } +void IfcWindowLiningProperties::setLiningToPanelOffsetY(double v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(15,v); } + + +const IfcParse::entity& IfcWindowLiningProperties::declaration() const { return *IfcWindowLiningProperties_type; } Type::Enum IfcWindowLiningProperties::Class() { return Type::IfcWindowLiningProperties; } -IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntity* e) : IfcPreDefinedPropertySet((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, boost::optional< double > v14_LiningOffset, boost::optional< double > v15_LiningToPanelOffsetX, boost::optional< double > v16_LiningToPanelOffsetY) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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)); if (v14_LiningOffset) { e->setArgument(13,(*v14_LiningOffset)); } else { e->setArgument(13); } if (v15_LiningToPanelOffsetX) { e->setArgument(14,(*v15_LiningToPanelOffsetX)); } else { e->setArgument(14); } if (v16_LiningToPanelOffsetY) { e->setArgument(15,(*v16_LiningToPanelOffsetY)); } else { e->setArgument(15); } entity = e; EntityBuffer::Add(this); } +IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntity* e) : IfcPreDefinedPropertySet((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, boost::optional< double > v14_LiningOffset, boost::optional< double > v15_LiningToPanelOffsetX, boost::optional< double > v16_LiningToPanelOffsetY) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_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)); if (v14_LiningOffset) { e->setArgument(13,(*v14_LiningOffset)); } else { e->setArgument(13); } if (v15_LiningToPanelOffsetX) { e->setArgument(14,(*v15_LiningToPanelOffsetX)); } else { e->setArgument(14); } if (v16_LiningToPanelOffsetY) { e->setArgument(15,(*v16_LiningToPanelOffsetY)); } else { e->setArgument(15); } 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 || IfcPreDefinedPropertySet::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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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) : IfcPreDefinedPropertySet((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) : IfcPreDefinedPropertySet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); 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 IfcWindowStandardCase -bool IfcWindowStandardCase::is(Type::Enum v) const { return v == Type::IfcWindowStandardCase || IfcWindow::is(v); } -Type::Enum IfcWindowStandardCase::type() const { return Type::IfcWindowStandardCase; } + + +const IfcParse::entity& IfcWindowStandardCase::declaration() const { return *IfcWindowStandardCase_type; } Type::Enum IfcWindowStandardCase::Class() { return Type::IfcWindowStandardCase; } -IfcWindowStandardCase::IfcWindowStandardCase(IfcAbstractEntity* e) : IfcWindow((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowStandardCase)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWindowStandardCase::IfcWindowStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcWindowTypeEnum::IfcWindowTypeEnum > v11_PredefinedType, boost::optional< IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum > v12_PartitioningType, boost::optional< std::string > v13_UserDefinedPartitioningType) : IfcWindow((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcWindowTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_PartitioningType) { e->setArgument(11,*v12_PartitioningType,IfcWindowTypePartitioningEnum::ToString(*v12_PartitioningType)); } else { e->setArgument(11); } if (v13_UserDefinedPartitioningType) { e->setArgument(12,(*v13_UserDefinedPartitioningType)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcWindowStandardCase::IfcWindowStandardCase(IfcAbstractEntity* e) : IfcWindow((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowStandardCase)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWindowStandardCase::IfcWindowStandardCase(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcWindowTypeEnum::IfcWindowTypeEnum > v11_PredefinedType, boost::optional< IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum > v12_PartitioningType, boost::optional< std::string > v13_UserDefinedPartitioningType) : IfcWindow((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_GlobalId)); e->setArgument(1,(v2_OwnerHistory)); if (v3_Name) { e->setArgument(2,(*v3_Name)); } else { e->setArgument(2); } 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); } if (v11_PredefinedType) { e->setArgument(10,*v11_PredefinedType,IfcWindowTypeEnum::ToString(*v11_PredefinedType)); } else { e->setArgument(10); } if (v12_PartitioningType) { e->setArgument(11,*v12_PartitioningType,IfcWindowTypePartitioningEnum::ToString(*v12_PartitioningType)); } else { e->setArgument(11); } if (v13_UserDefinedPartitioningType) { e->setArgument(12,(*v13_UserDefinedPartitioningType)); } else { e->setArgument(12); } 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 IfcWindowType -IfcWindowTypeEnum::IfcWindowTypeEnum IfcWindowType::PredefinedType() const { return IfcWindowTypeEnum::FromString(*entity->getArgument(9)); } -void IfcWindowType::setPredefinedType(IfcWindowTypeEnum::IfcWindowTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v,IfcWindowTypeEnum::ToString(v)); } -IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum IfcWindowType::PartitioningType() const { return IfcWindowTypePartitioningEnum::FromString(*entity->getArgument(10)); } -void IfcWindowType::setPartitioningType(IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v,IfcWindowTypePartitioningEnum::ToString(v)); } -bool IfcWindowType::hasParameterTakesPrecedence() const { return !entity->getArgument(11)->isNull(); } -bool IfcWindowType::ParameterTakesPrecedence() const { return *entity->getArgument(11); } -void IfcWindowType::setParameterTakesPrecedence(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcWindowType::hasUserDefinedPartitioningType() const { return !entity->getArgument(12)->isNull(); } -std::string IfcWindowType::UserDefinedPartitioningType() const { return *entity->getArgument(12); } -void IfcWindowType::setUserDefinedPartitioningType(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); } -bool IfcWindowType::is(Type::Enum v) const { return v == Type::IfcWindowType || IfcBuildingElementType::is(v); } -Type::Enum IfcWindowType::type() const { return Type::IfcWindowType; } +IfcWindowTypeEnum::IfcWindowTypeEnum IfcWindowType::PredefinedType() const { return IfcWindowTypeEnum::FromString(*data_->getArgument(9)); } +void IfcWindowType::setPredefinedType(IfcWindowTypeEnum::IfcWindowTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v,IfcWindowTypeEnum::ToString(v)); } +IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum IfcWindowType::PartitioningType() const { return IfcWindowTypePartitioningEnum::FromString(*data_->getArgument(10)); } +void IfcWindowType::setPartitioningType(IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v,IfcWindowTypePartitioningEnum::ToString(v)); } +bool IfcWindowType::hasParameterTakesPrecedence() const { return !data_->getArgument(11)->isNull(); } +bool IfcWindowType::ParameterTakesPrecedence() const { return *data_->getArgument(11); } +void IfcWindowType::setParameterTakesPrecedence(bool v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcWindowType::hasUserDefinedPartitioningType() const { return !data_->getArgument(12)->isNull(); } +std::string IfcWindowType::UserDefinedPartitioningType() const { return *data_->getArgument(12); } +void IfcWindowType::setUserDefinedPartitioningType(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,v); } + + +const IfcParse::entity& IfcWindowType::declaration() const { return *IfcWindowType_type; } Type::Enum IfcWindowType::Class() { return Type::IfcWindowType; } -IfcWindowType::IfcWindowType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowType)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWindowType::IfcWindowType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWindowTypeEnum::IfcWindowTypeEnum v10_PredefinedType, IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v11_PartitioningType, boost::optional< bool > v12_ParameterTakesPrecedence, boost::optional< std::string > v13_UserDefinedPartitioningType) : 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,IfcWindowTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,v11_PartitioningType,IfcWindowTypePartitioningEnum::ToString(v11_PartitioningType)); if (v12_ParameterTakesPrecedence) { e->setArgument(11,(*v12_ParameterTakesPrecedence)); } else { e->setArgument(11); } if (v13_UserDefinedPartitioningType) { e->setArgument(12,(*v13_UserDefinedPartitioningType)); } else { e->setArgument(12); } entity = e; EntityBuffer::Add(this); } +IfcWindowType::IfcWindowType(IfcAbstractEntity* e) : IfcBuildingElementType((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWindowType)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWindowType::IfcWindowType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWindowTypeEnum::IfcWindowTypeEnum v10_PredefinedType, IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v11_PartitioningType, boost::optional< bool > v12_ParameterTakesPrecedence, boost::optional< std::string > v13_UserDefinedPartitioningType) : 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,IfcWindowTypeEnum::ToString(v10_PredefinedType)); e->setArgument(10,v11_PartitioningType,IfcWindowTypePartitioningEnum::ToString(v11_PartitioningType)); if (v12_ParameterTakesPrecedence) { e->setArgument(11,(*v12_ParameterTakesPrecedence)); } else { e->setArgument(11); } if (v13_UserDefinedPartitioningType) { e->setArgument(12,(*v13_UserDefinedPartitioningType)); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkCalendar -bool IfcWorkCalendar::hasWorkingTimes() const { return !entity->getArgument(6)->isNull(); } -IfcTemplatedEntityList< IfcWorkTime >::ptr IfcWorkCalendar::WorkingTimes() const { IfcEntityList::ptr es = *entity->getArgument(6); return es->as(); } -void IfcWorkCalendar::setWorkingTimes(IfcTemplatedEntityList< IfcWorkTime >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(6,v->generalize()); } -bool IfcWorkCalendar::hasExceptionTimes() const { return !entity->getArgument(7)->isNull(); } -IfcTemplatedEntityList< IfcWorkTime >::ptr IfcWorkCalendar::ExceptionTimes() const { IfcEntityList::ptr es = *entity->getArgument(7); return es->as(); } -void IfcWorkCalendar::setExceptionTimes(IfcTemplatedEntityList< IfcWorkTime >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(7,v->generalize()); } -bool IfcWorkCalendar::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); } -IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum IfcWorkCalendar::PredefinedType() const { return IfcWorkCalendarTypeEnum::FromString(*entity->getArgument(8)); } -void IfcWorkCalendar::setPredefinedType(IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(8,v,IfcWorkCalendarTypeEnum::ToString(v)); } -bool IfcWorkCalendar::is(Type::Enum v) const { return v == Type::IfcWorkCalendar || IfcControl::is(v); } -Type::Enum IfcWorkCalendar::type() const { return Type::IfcWorkCalendar; } +bool IfcWorkCalendar::hasWorkingTimes() const { return !data_->getArgument(6)->isNull(); } +IfcTemplatedEntityList< IfcWorkTime >::ptr IfcWorkCalendar::WorkingTimes() const { IfcEntityList::ptr es = *data_->getArgument(6); return es->as(); } +void IfcWorkCalendar::setWorkingTimes(IfcTemplatedEntityList< IfcWorkTime >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(6,v->generalize()); } +bool IfcWorkCalendar::hasExceptionTimes() const { return !data_->getArgument(7)->isNull(); } +IfcTemplatedEntityList< IfcWorkTime >::ptr IfcWorkCalendar::ExceptionTimes() const { IfcEntityList::ptr es = *data_->getArgument(7); return es->as(); } +void IfcWorkCalendar::setExceptionTimes(IfcTemplatedEntityList< IfcWorkTime >::ptr v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(7,v->generalize()); } +bool IfcWorkCalendar::hasPredefinedType() const { return !data_->getArgument(8)->isNull(); } +IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum IfcWorkCalendar::PredefinedType() const { return IfcWorkCalendarTypeEnum::FromString(*data_->getArgument(8)); } +void IfcWorkCalendar::setPredefinedType(IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(8,v,IfcWorkCalendarTypeEnum::ToString(v)); } + + +const IfcParse::entity& IfcWorkCalendar::declaration() const { return *IfcWorkCalendar_type; } Type::Enum IfcWorkCalendar::Class() { return Type::IfcWorkCalendar; } -IfcWorkCalendar::IfcWorkCalendar(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkCalendar)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWorkCalendar::IfcWorkCalendar(std::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_Identification, boost::optional< IfcTemplatedEntityList< IfcWorkTime >::ptr > v7_WorkingTimes, boost::optional< IfcTemplatedEntityList< IfcWorkTime >::ptr > v8_ExceptionTimes, boost::optional< IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum > v9_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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_WorkingTimes) { e->setArgument(6,(*v7_WorkingTimes)->generalize()); } else { e->setArgument(6); } if (v8_ExceptionTimes) { e->setArgument(7,(*v8_ExceptionTimes)->generalize()); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcWorkCalendarTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } entity = e; EntityBuffer::Add(this); } +IfcWorkCalendar::IfcWorkCalendar(IfcAbstractEntity* e) : IfcControl((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkCalendar)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWorkCalendar::IfcWorkCalendar(std::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_Identification, boost::optional< IfcTemplatedEntityList< IfcWorkTime >::ptr > v7_WorkingTimes, boost::optional< IfcTemplatedEntityList< IfcWorkTime >::ptr > v8_ExceptionTimes, boost::optional< IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum > v9_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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } if (v7_WorkingTimes) { e->setArgument(6,(*v7_WorkingTimes)->generalize()); } else { e->setArgument(6); } if (v8_ExceptionTimes) { e->setArgument(7,(*v8_ExceptionTimes)->generalize()); } else { e->setArgument(7); } if (v9_PredefinedType) { e->setArgument(8,*v9_PredefinedType,IfcWorkCalendarTypeEnum::ToString(*v9_PredefinedType)); } else { e->setArgument(8); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkControl -std::string IfcWorkControl::CreationDate() const { return *entity->getArgument(6); } -void IfcWorkControl::setCreationDate(std::string 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(); } -std::string IfcWorkControl::Duration() const { return *entity->getArgument(9); } -void IfcWorkControl::setDuration(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(9,v); } -bool IfcWorkControl::hasTotalFloat() const { return !entity->getArgument(10)->isNull(); } -std::string IfcWorkControl::TotalFloat() const { return *entity->getArgument(10); } -void IfcWorkControl::setTotalFloat(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(10,v); } -std::string IfcWorkControl::StartTime() const { return *entity->getArgument(11); } -void IfcWorkControl::setStartTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(11,v); } -bool IfcWorkControl::hasFinishTime() const { return !entity->getArgument(12)->isNull(); } -std::string IfcWorkControl::FinishTime() const { return *entity->getArgument(12); } -void IfcWorkControl::setFinishTime(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,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::CreationDate() const { return *data_->getArgument(6); } +void IfcWorkControl::setCreationDate(std::string 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(); } +std::string IfcWorkControl::Duration() const { return *data_->getArgument(9); } +void IfcWorkControl::setDuration(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(9,v); } +bool IfcWorkControl::hasTotalFloat() const { return !data_->getArgument(10)->isNull(); } +std::string IfcWorkControl::TotalFloat() const { return *data_->getArgument(10); } +void IfcWorkControl::setTotalFloat(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(10,v); } +std::string IfcWorkControl::StartTime() const { return *data_->getArgument(11); } +void IfcWorkControl::setStartTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(11,v); } +bool IfcWorkControl::hasFinishTime() const { return !data_->getArgument(12)->isNull(); } +std::string IfcWorkControl::FinishTime() const { return *data_->getArgument(12); } +void IfcWorkControl::setFinishTime(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(12,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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_FinishTime) { e->setArgument(12,(*v13_FinishTime)); } else { e->setArgument(12); } 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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime) : 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_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_FinishTime) { e->setArgument(12,(*v13_FinishTime)); } else { e->setArgument(12); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkPlan -bool IfcWorkPlan::hasPredefinedType() const { return !entity->getArgument(13)->isNull(); } -IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum IfcWorkPlan::PredefinedType() const { return IfcWorkPlanTypeEnum::FromString(*entity->getArgument(13)); } -void IfcWorkPlan::setPredefinedType(IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v,IfcWorkPlanTypeEnum::ToString(v)); } -bool IfcWorkPlan::is(Type::Enum v) const { return v == Type::IfcWorkPlan || IfcWorkControl::is(v); } -Type::Enum IfcWorkPlan::type() const { return Type::IfcWorkPlan; } +bool IfcWorkPlan::hasPredefinedType() const { return !data_->getArgument(13)->isNull(); } +IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum IfcWorkPlan::PredefinedType() const { return IfcWorkPlanTypeEnum::FromString(*data_->getArgument(13)); } +void IfcWorkPlan::setPredefinedType(IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v,IfcWorkPlanTypeEnum::ToString(v)); } + + +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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime, boost::optional< IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum > v14_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_FinishTime) { e->setArgument(12,(*v13_FinishTime)); } else { e->setArgument(12); } if (v14_PredefinedType) { e->setArgument(13,*v14_PredefinedType,IfcWorkPlanTypeEnum::ToString(*v14_PredefinedType)); } else { e->setArgument(13); } 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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime, boost::optional< IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum > v14_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_FinishTime) { e->setArgument(12,(*v13_FinishTime)); } else { e->setArgument(12); } if (v14_PredefinedType) { e->setArgument(13,*v14_PredefinedType,IfcWorkPlanTypeEnum::ToString(*v14_PredefinedType)); } else { e->setArgument(13); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkSchedule -bool IfcWorkSchedule::hasPredefinedType() const { return !entity->getArgument(13)->isNull(); } -IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum IfcWorkSchedule::PredefinedType() const { return IfcWorkScheduleTypeEnum::FromString(*entity->getArgument(13)); } -void IfcWorkSchedule::setPredefinedType(IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(13,v,IfcWorkScheduleTypeEnum::ToString(v)); } -bool IfcWorkSchedule::is(Type::Enum v) const { return v == Type::IfcWorkSchedule || IfcWorkControl::is(v); } -Type::Enum IfcWorkSchedule::type() const { return Type::IfcWorkSchedule; } +bool IfcWorkSchedule::hasPredefinedType() const { return !data_->getArgument(13)->isNull(); } +IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum IfcWorkSchedule::PredefinedType() const { return IfcWorkScheduleTypeEnum::FromString(*data_->getArgument(13)); } +void IfcWorkSchedule::setPredefinedType(IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(13,v,IfcWorkScheduleTypeEnum::ToString(v)); } + + +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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime, boost::optional< IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum > v14_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_FinishTime) { e->setArgument(12,(*v13_FinishTime)); } else { e->setArgument(12); } if (v14_PredefinedType) { e->setArgument(13,*v14_PredefinedType,IfcWorkScheduleTypeEnum::ToString(*v14_PredefinedType)); } else { e->setArgument(13); } 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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime, boost::optional< IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum > v14_PredefinedType) : 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); } if (v6_Identification) { e->setArgument(5,(*v6_Identification)); } else { e->setArgument(5); } 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)); if (v13_FinishTime) { e->setArgument(12,(*v13_FinishTime)); } else { e->setArgument(12); } if (v14_PredefinedType) { e->setArgument(13,*v14_PredefinedType,IfcWorkScheduleTypeEnum::ToString(*v14_PredefinedType)); } else { e->setArgument(13); } data_ = e; EntityBuffer::Add(this); } // Function implementations for IfcWorkTime -bool IfcWorkTime::hasRecurrencePattern() const { return !entity->getArgument(3)->isNull(); } -IfcRecurrencePattern* IfcWorkTime::RecurrencePattern() const { return (IfcRecurrencePattern*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(3))); } -void IfcWorkTime::setRecurrencePattern(IfcRecurrencePattern* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); } -bool IfcWorkTime::hasStart() const { return !entity->getArgument(4)->isNull(); } -std::string IfcWorkTime::Start() const { return *entity->getArgument(4); } -void IfcWorkTime::setStart(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); } -bool IfcWorkTime::hasFinish() const { return !entity->getArgument(5)->isNull(); } -std::string IfcWorkTime::Finish() const { return *entity->getArgument(5); } -void IfcWorkTime::setFinish(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcWorkTime::is(Type::Enum v) const { return v == Type::IfcWorkTime || IfcSchedulingTime::is(v); } -Type::Enum IfcWorkTime::type() const { return Type::IfcWorkTime; } +bool IfcWorkTime::hasRecurrencePattern() const { return !data_->getArgument(3)->isNull(); } +IfcRecurrencePattern* IfcWorkTime::RecurrencePattern() const { return (IfcRecurrencePattern*)((IfcUtil::IfcBaseClass*)(*data_->getArgument(3))); } +void IfcWorkTime::setRecurrencePattern(IfcRecurrencePattern* v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(3,v); } +bool IfcWorkTime::hasStart() const { return !data_->getArgument(4)->isNull(); } +std::string IfcWorkTime::Start() const { return *data_->getArgument(4); } +void IfcWorkTime::setStart(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(4,v); } +bool IfcWorkTime::hasFinish() const { return !data_->getArgument(5)->isNull(); } +std::string IfcWorkTime::Finish() const { return *data_->getArgument(5); } +void IfcWorkTime::setFinish(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcWorkTime::declaration() const { return *IfcWorkTime_type; } Type::Enum IfcWorkTime::Class() { return Type::IfcWorkTime; } -IfcWorkTime::IfcWorkTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkTime)) throw IfcException("Unable to find find keyword in schema"); entity = e; } -IfcWorkTime::IfcWorkTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, IfcRecurrencePattern* v4_RecurrencePattern, boost::optional< std::string > v5_Start, boost::optional< std::string > v6_Finish) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } e->setArgument(3,(v4_RecurrencePattern)); if (v5_Start) { e->setArgument(4,(*v5_Start)); } else { e->setArgument(4); } if (v6_Finish) { e->setArgument(5,(*v6_Finish)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcWorkTime::IfcWorkTime(IfcAbstractEntity* e) : IfcSchedulingTime((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcWorkTime)) throw IfcException("Unable to find find keyword in schema"); data_ = e; } +IfcWorkTime::IfcWorkTime(boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, IfcRecurrencePattern* v4_RecurrencePattern, boost::optional< std::string > v5_Start, boost::optional< std::string > v6_Finish) : IfcSchedulingTime((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } if (v2_DataOrigin) { e->setArgument(1,*v2_DataOrigin,IfcDataOriginEnum::ToString(*v2_DataOrigin)); } else { e->setArgument(1); } if (v3_UserDefinedDataOrigin) { e->setArgument(2,(*v3_UserDefinedDataOrigin)); } else { e->setArgument(2); } e->setArgument(3,(v4_RecurrencePattern)); if (v5_Start) { e->setArgument(4,(*v5_Start)); } else { e->setArgument(4); } if (v6_Finish) { e->setArgument(5,(*v6_Finish)); } else { e->setArgument(5); } 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::hasLongName() const { return !entity->getArgument(5)->isNull(); } -std::string IfcZone::LongName() const { return *entity->getArgument(5); } -void IfcZone::setLongName(std::string v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(5,v); } -bool IfcZone::is(Type::Enum v) const { return v == Type::IfcZone || IfcSystem::is(v); } -Type::Enum IfcZone::type() const { return Type::IfcZone; } +bool IfcZone::hasLongName() const { return !data_->getArgument(5)->isNull(); } +std::string IfcZone::LongName() const { return *data_->getArgument(5); } +void IfcZone::setLongName(std::string v) { if ( ! data_->isWritable() ) { data_ = new IfcWritableEntity(data_); } ((IfcWritableEntity*)data_)->setArgument(5,v); } + + +const IfcParse::entity& IfcZone::declaration() const { return *IfcZone_type; } Type::Enum IfcZone::Class() { return Type::IfcZone; } -IfcZone::IfcZone(IfcAbstractEntity* e) : IfcSystem((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, boost::optional< std::string > v6_LongName) : 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); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } entity = e; EntityBuffer::Add(this); } +IfcZone::IfcZone(IfcAbstractEntity* e) : IfcSystem((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, boost::optional< std::string > v6_LongName) : 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); } if (v6_LongName) { e->setArgument(5,(*v6_LongName)); } else { e->setArgument(5); } data_ = e; EntityBuffer::Add(this); } #endif diff --git a/src/ifcparse/Ifc4.h b/src/ifcparse/Ifc4.h index 4f01c4f55c..347fd153f3 100644 --- a/src/ifcparse/Ifc4.h +++ b/src/ifcparse/Ifc4.h @@ -34,9 +34,12 @@ #include #include "../ifcparse/IfcUtil.h" +#include "../ifcparse/IfcSchema.h" #include "../ifcparse/IfcException.h" #include "../ifcparse/Ifc4enum.h" +const IfcParse::schema_definition& get_schema(); + #define IfcSchema Ifc4 namespace Ifc4 { @@ -5740,10 +5743,7 @@ IfcWorkScheduleTypeEnum 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); @@ -5756,10 +5756,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); @@ -5775,10 +5772,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); @@ -5791,10 +5785,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); @@ -5803,10 +5794,7 @@ public: class IfcAreaDensityMeasure : 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 IfcAreaDensityMeasure (IfcAbstractEntity* e); IfcAreaDensityMeasure (double v); @@ -5821,10 +5809,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); @@ -5837,10 +5822,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); @@ -5891,10 +5873,7 @@ public: /// Figure 284 — Cardinal point extrusion class IfcCardinalPointReference : 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 IfcCardinalPointReference (IfcAbstractEntity* e); IfcCardinalPointReference (int v); @@ -5913,10 +5892,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); @@ -5972,10 +5948,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); @@ -5989,10 +5962,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); @@ -6006,10 +5976,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); @@ -6024,10 +5991,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); @@ -6041,10 +6005,7 @@ public: /// All given values should be provided in context and converted into a Gregorian date context and be shall be processable by a receiving application. class IfcDate : 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 IfcDate (IfcAbstractEntity* e); IfcDate (std::string v); @@ -6070,10 +6031,7 @@ public: /// HISTORY: New type in IFC2x4 class IfcDateTime : 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 IfcDateTime (IfcAbstractEntity* e); IfcDateTime (std::string v); @@ -6093,10 +6051,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); @@ -6138,10 +6093,7 @@ public: /// IFC2x4. class IfcDayInWeekNumber : 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 IfcDayInWeekNumber (IfcAbstractEntity* e); IfcDayInWeekNumber (int v); @@ -6155,10 +6107,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); @@ -6173,10 +6122,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); @@ -6189,10 +6135,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); @@ -6205,10 +6148,7 @@ public: /// HISTORY: New type in IFC2x4 class IfcDuration : 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 IfcDuration (IfcAbstractEntity* e); IfcDuration (std::string v); @@ -6222,10 +6162,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); @@ -6238,10 +6175,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); @@ -6254,10 +6188,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); @@ -6270,10 +6201,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); @@ -6288,10 +6216,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); @@ -6304,10 +6229,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); @@ -6320,10 +6242,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); @@ -6336,10 +6255,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); @@ -6361,10 +6277,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); @@ -6384,10 +6297,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); @@ -6418,10 +6328,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); @@ -6434,10 +6341,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); @@ -6450,10 +6354,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); @@ -6476,10 +6377,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); @@ -6492,10 +6390,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); @@ -6506,10 +6401,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); @@ -6531,10 +6423,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); @@ -6547,10 +6436,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); @@ -6563,10 +6449,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); @@ -6581,10 +6464,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); @@ -6599,10 +6479,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); @@ -6613,10 +6490,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); @@ -6629,10 +6503,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); @@ -6645,10 +6516,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); @@ -6670,10 +6538,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); @@ -6691,10 +6556,7 @@ public: /// HISTORY  New defined datatype in IFC2x4. class IfcLanguageId : public IfcIdentifier { 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 IfcLanguageId (IfcAbstractEntity* e); IfcLanguageId (std::string v); @@ -6709,10 +6571,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); @@ -6725,10 +6584,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); @@ -6741,10 +6597,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); @@ -6757,10 +6610,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); @@ -6773,10 +6623,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); @@ -6789,10 +6636,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); @@ -6805,10 +6649,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); @@ -6823,10 +6664,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); @@ -6841,10 +6679,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); @@ -6857,10 +6692,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); @@ -6873,10 +6705,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); @@ -6889,10 +6718,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); @@ -6905,10 +6731,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); @@ -6923,10 +6746,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); @@ -6941,10 +6761,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); @@ -6957,10 +6774,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); @@ -6973,10 +6787,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); @@ -6989,10 +6800,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); @@ -7009,10 +6817,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); @@ -7025,10 +6830,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); @@ -7041,10 +6843,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); @@ -7057,10 +6856,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); @@ -7072,10 +6868,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); @@ -7139,10 +6932,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); @@ -7155,10 +6945,7 @@ public: /// HISTORY New type in IFC Release 2x4. class IfcNonNegativeLengthMeasure : 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 IfcNonNegativeLengthMeasure (IfcAbstractEntity* e); IfcNonNegativeLengthMeasure (double v); @@ -7172,10 +6959,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); @@ -7186,10 +6970,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); @@ -7204,10 +6985,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); @@ -7220,10 +6998,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); @@ -7242,10 +7017,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); @@ -7259,10 +7031,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); @@ -7276,10 +7045,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); @@ -7292,10 +7058,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); @@ -7312,10 +7075,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); @@ -7328,10 +7088,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); @@ -7340,10 +7097,7 @@ public: class IfcPropertySetDefinitionSet : 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 IfcPropertySetDefinitionSet (IfcAbstractEntity* e); IfcPropertySetDefinitionSet (IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v); @@ -7356,10 +7110,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); @@ -7377,10 +7128,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); @@ -7395,10 +7143,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); @@ -7411,10 +7156,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); @@ -7428,10 +7170,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); @@ -7444,10 +7183,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); @@ -7460,10 +7196,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); @@ -7476,10 +7209,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); @@ -7492,10 +7222,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); @@ -7510,10 +7237,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); @@ -7522,10 +7246,7 @@ public: class IfcSoundPowerLevelMeasure : 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 IfcSoundPowerLevelMeasure (IfcAbstractEntity* e); IfcSoundPowerLevelMeasure (double v); @@ -7538,10 +7259,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); @@ -7550,10 +7268,7 @@ public: class IfcSoundPressureLevelMeasure : 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 IfcSoundPressureLevelMeasure (IfcAbstractEntity* e); IfcSoundPressureLevelMeasure (double v); @@ -7566,10 +7281,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); @@ -7582,10 +7294,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); @@ -7600,10 +7309,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); @@ -7620,10 +7326,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); @@ -7636,10 +7339,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); @@ -7652,10 +7352,7 @@ public: /// HISTORY  New type in IFC2x4. class IfcTemperatureRateOfChangeMeasure : 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 IfcTemperatureRateOfChangeMeasure (IfcAbstractEntity* e); IfcTemperatureRateOfChangeMeasure (double v); @@ -7674,10 +7371,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); @@ -7695,10 +7389,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); @@ -7719,10 +7410,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); @@ -7749,10 +7437,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); @@ -7770,10 +7455,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); @@ -7786,10 +7468,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); @@ -7802,10 +7481,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); @@ -7817,10 +7493,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); @@ -7832,10 +7505,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); @@ -7848,10 +7518,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); @@ -7866,10 +7533,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); @@ -7885,10 +7549,7 @@ public: /// HISTORY: New type in IFC2x4 class IfcTime : 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 IfcTime (IfcAbstractEntity* e); IfcTime (std::string v); @@ -7903,10 +7564,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); @@ -7918,10 +7576,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); @@ -7934,10 +7589,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); @@ -7952,10 +7604,7 @@ public: /// HISTORY New defined datatype in IFC 2x4. class IfcURIReference : 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 IfcURIReference (IfcAbstractEntity* e); IfcURIReference (std::string v); @@ -7968,10 +7617,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); @@ -7986,10 +7632,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); @@ -8002,10 +7645,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); @@ -8018,10 +7658,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); @@ -8034,10 +7671,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); @@ -8070,10 +7704,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); @@ -8086,10 +7717,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); @@ -8103,10 +7731,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); @@ -8143,14 +7768,8 @@ 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); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + 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); @@ -8181,15 +7800,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); @@ -8212,13 +7825,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); @@ -8294,14 +7901,8 @@ public: bool hasComponents() const; IfcTemplatedEntityList< IfcAppliedValue >::ptr Components() const; void setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDate; case 5: return Type::IfcDate; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::IfcArithmeticOperatorEnum; case 9: return Type::IfcAppliedValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AppliedValue"; case 3: return "UnitBasis"; case 4: return "ApplicableDate"; case 5: return "FixedUntilDate"; case 6: return "Category"; case 7: return "Condition"; case 8: return "ArithmeticOperator"; case 9: return "Components"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + 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, boost::optional< std::string > v5_ApplicableDate, boost::optional< std::string > v6_FixedUntilDate, boost::optional< std::string > v7_Category, boost::optional< std::string > v8_Condition, boost::optional< IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum > v9_ArithmeticOperator, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_Components); @@ -8365,18 +7966,12 @@ public: /// IFC2x4 CHANGE  New attribute for approval provision replacing IfcApprovalActorRelationship (being deleted). IfcActorSelect* GivingApproval() const; void setGivingApproval(IfcActorSelect* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDateTime; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcText; case 7: return Type::IfcActorSelect; case 8: return Type::IfcActorSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "TimeOfApproval"; case 4: return "Status"; case 5: return "Level"; case 6: return "Qualifier"; case 7: return "RequestingApproval"; case 8: return "GivingApproval"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects IfcTemplatedEntityList< IfcRelAssociatesApproval >::ptr ApprovedObjects() const; // INVERSE IfcRelAssociatesApproval::RelatingApproval IfcTemplatedEntityList< IfcResourceApprovalRelationship >::ptr ApprovedResources() const; // INVERSE IfcResourceApprovalRelationship::RelatingApproval IfcTemplatedEntityList< IfcApprovalRelationship >::ptr IsRelatedWith() const; // INVERSE IfcApprovalRelationship::RelatedApprovals 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_Identifier, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, boost::optional< std::string > v4_TimeOfApproval, boost::optional< std::string > v5_Status, boost::optional< std::string > v6_Level, boost::optional< std::string > v7_Qualifier, IfcActorSelect* v8_RequestingApproval, IfcActorSelect* v9_GivingApproval); @@ -8404,13 +7999,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); @@ -8458,13 +8047,7 @@ public: /// Rotational stiffness value about the z-axis of the coordinate system defined by the instance which uses this resource object. IfcModulusOfRotationalSubgradeReactionSelect* RotationalStiffnessByLengthZ() const; void setRotationalStiffnessByLengthZ(IfcModulusOfRotationalSubgradeReactionSelect* v); - virtual unsigned int getArgumentCount() const { return 7; } - 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; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcBoundaryCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcModulusOfTranslationalSubgradeReactionSelect; case 2: return Type::IfcModulusOfTranslationalSubgradeReactionSelect; case 3: return Type::IfcModulusOfTranslationalSubgradeReactionSelect; case 4: return Type::IfcModulusOfRotationalSubgradeReactionSelect; case 5: return Type::IfcModulusOfRotationalSubgradeReactionSelect; case 6: return Type::IfcModulusOfRotationalSubgradeReactionSelect; } return IfcBoundaryCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "TranslationalStiffnessByLengthX"; case 2: return "TranslationalStiffnessByLengthY"; case 3: return "TranslationalStiffnessByLengthZ"; 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, IfcModulusOfTranslationalSubgradeReactionSelect* v2_TranslationalStiffnessByLengthX, IfcModulusOfTranslationalSubgradeReactionSelect* v3_TranslationalStiffnessByLengthY, IfcModulusOfTranslationalSubgradeReactionSelect* v4_TranslationalStiffnessByLengthZ, IfcModulusOfRotationalSubgradeReactionSelect* v5_RotationalStiffnessByLengthX, IfcModulusOfRotationalSubgradeReactionSelect* v6_RotationalStiffnessByLengthY, IfcModulusOfRotationalSubgradeReactionSelect* v7_RotationalStiffnessByLengthZ); @@ -8497,13 +8080,7 @@ public: /// Translational stiffness value in z-direction of the coordinate system defined by the instance which uses this resource object. IfcModulusOfSubgradeReactionSelect* TranslationalStiffnessByAreaZ() const; void setTranslationalStiffnessByAreaZ(IfcModulusOfSubgradeReactionSelect* 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 IfcBoundaryCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcModulusOfSubgradeReactionSelect; case 2: return Type::IfcModulusOfSubgradeReactionSelect; case 3: return Type::IfcModulusOfSubgradeReactionSelect; } return IfcBoundaryCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "TranslationalStiffnessByAreaX"; case 2: return "TranslationalStiffnessByAreaY"; case 3: return "TranslationalStiffnessByAreaZ"; } 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, IfcModulusOfSubgradeReactionSelect* v2_TranslationalStiffnessByAreaX, IfcModulusOfSubgradeReactionSelect* v3_TranslationalStiffnessByAreaY, IfcModulusOfSubgradeReactionSelect* v4_TranslationalStiffnessByAreaZ); @@ -8551,13 +8128,7 @@ public: /// Rotational stiffness value about the z-axis of the coordinate system defined by the instance which uses this resource object. IfcRotationalStiffnessSelect* RotationalStiffnessZ() const; void setRotationalStiffnessZ(IfcRotationalStiffnessSelect* v); - virtual unsigned int getArgumentCount() const { return 7; } - 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; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcBoundaryCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcTranslationalStiffnessSelect; case 2: return Type::IfcTranslationalStiffnessSelect; case 3: return Type::IfcTranslationalStiffnessSelect; case 4: return Type::IfcRotationalStiffnessSelect; case 5: return Type::IfcRotationalStiffnessSelect; case 6: return Type::IfcRotationalStiffnessSelect; } return IfcBoundaryCondition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "TranslationalStiffnessX"; case 2: return "TranslationalStiffnessY"; case 3: return "TranslationalStiffnessZ"; 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, IfcTranslationalStiffnessSelect* v2_TranslationalStiffnessX, IfcTranslationalStiffnessSelect* v3_TranslationalStiffnessY, IfcTranslationalStiffnessSelect* v4_TranslationalStiffnessZ, IfcRotationalStiffnessSelect* v5_RotationalStiffnessX, IfcRotationalStiffnessSelect* v6_RotationalStiffnessY, IfcRotationalStiffnessSelect* v7_RotationalStiffnessZ); @@ -8579,13 +8150,7 @@ public: /// Defines the warping stiffness value. IfcWarpingStiffnessSelect* WarpingStiffness() const; void setWarpingStiffness(IfcWarpingStiffnessSelect* 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 IfcBoundaryNodeCondition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcWarpingStiffnessSelect; } 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, IfcTranslationalStiffnessSelect* v2_TranslationalStiffnessX, IfcTranslationalStiffnessSelect* v3_TranslationalStiffnessY, IfcTranslationalStiffnessSelect* v4_TranslationalStiffnessZ, IfcRotationalStiffnessSelect* v5_RotationalStiffnessX, IfcRotationalStiffnessSelect* v6_RotationalStiffnessY, IfcRotationalStiffnessSelect* v7_RotationalStiffnessZ, IfcWarpingStiffnessSelect* v8_WarpingStiffness); @@ -8607,13 +8172,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 (); @@ -8645,13 +8204,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); @@ -8675,13 +8228,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); @@ -8703,13 +8250,7 @@ public: /// Volume at which related object overlaps with the relating element, given in the LCS of the related element. IfcSolidOrShell* VolumeOnRelatedElement() const; void setVolumeOnRelatedElement(IfcSolidOrShell* 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::IfcSolidOrShell; case 1: return Type::IfcSolidOrShell; } return IfcConnectionGeometry::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "VolumeOnRelatingElement"; case 1: return "VolumeOnRelatedElement"; } 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(); IfcConnectionVolumeGeometry (IfcAbstractEntity* e); IfcConnectionVolumeGeometry (IfcSolidOrShell* v1_VolumeOnRelatingElement, IfcSolidOrShell* v2_VolumeOnRelatedElement); @@ -8763,15 +8304,9 @@ 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_STRING; case 6: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraintEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcActorSelect; case 5: return Type::IfcDateTime; case 6: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "ConstraintGrade"; case 3: return "ConstraintSource"; case 4: return "CreatingActor"; case 5: return "CreationTime"; case 6: return "UserDefinedGrade"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects IfcTemplatedEntityList< IfcResourceConstraintRelationship >::ptr PropertiesForConstraint() const; // INVERSE IfcResourceConstraintRelationship::RelatingConstraint - 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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade); @@ -8831,13 +8366,7 @@ public: /// Target coordinate reference system for the operation. IfcCoordinateReferenceSystem* TargetCRS() const; void setTargetCRS(IfcCoordinateReferenceSystem* v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCoordinateReferenceSystemSelect; case 1: return Type::IfcCoordinateReferenceSystem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SourceCRS"; case 1: return "TargetCRS"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoordinateOperation (IfcAbstractEntity* e); IfcCoordinateOperation (IfcCoordinateReferenceSystemSelect* v1_SourceCRS, IfcCoordinateReferenceSystem* v2_TargetCRS); @@ -8893,13 +8422,7 @@ public: /// other sea levels std::string VerticalDatum() const; void setVerticalDatum(std::string v); - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcIdentifier; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "GeodeticDatum"; case 3: return "VerticalDatum"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoordinateReferenceSystem (IfcAbstractEntity* e); IfcCoordinateReferenceSystem (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, std::string v3_GeodeticDatum, boost::optional< std::string > v4_VerticalDatum); @@ -8949,13 +8472,7 @@ public: /// In the absence of any well-defined standard, it is recommended that local agreements should be made to define allowable and understandable cost value types within a project or region. class IfcCostValue : public IfcAppliedValue { public: - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcAppliedValue::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcAppliedValue::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { 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, boost::optional< std::string > v5_ApplicableDate, boost::optional< std::string > v6_FixedUntilDate, boost::optional< std::string > v7_Category, boost::optional< std::string > v8_Condition, boost::optional< IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum > v9_ArithmeticOperator, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_Components); @@ -8980,13 +8497,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); @@ -9009,13 +8520,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); @@ -9061,13 +8566,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); @@ -9081,13 +8580,7 @@ public: /// HISTORY New entity in IFC2x4. class IfcExternalInformation : 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(); IfcExternalInformation (IfcAbstractEntity* e); IfcExternalInformation (); @@ -9129,14 +8622,8 @@ 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::IfcURIReference; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; case 1: return "Identification"; case 2: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr ExternalReferenceForResources() const; // INVERSE IfcExternalReferenceRelationship::RelatingReference - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr ExternalReferenceForResources() const; // INVERSE IfcExternalReferenceRelationship::RelatingReference + 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_Identification, boost::optional< std::string > v3_Name); @@ -9152,13 +8639,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_Identification, boost::optional< std::string > v3_Name); @@ -9173,13 +8654,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_Identification, boost::optional< std::string > v3_Name); @@ -9194,13 +8669,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_Identification, boost::optional< std::string > v3_Name); @@ -9242,17 +8711,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); @@ -9269,13 +8732,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_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDateTime; case 1: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TimeStamp"; case 1: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcIrregularTimeSeriesValue (IfcAbstractEntity* e); IfcIrregularTimeSeriesValue (std::string v1_TimeStamp, IfcEntityList::ptr v2_ListValues); @@ -9322,15 +8779,9 @@ public: bool hasDescription() const; std::string Description() const; void setDescription(std::string 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_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; } return IfcExternalInformation::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; case 2: return Type::IfcActorSelect; case 3: return Type::IfcDateTime; case 4: return Type::IfcURIReference; case 5: return Type::IfcText; } return IfcExternalInformation::getArgumentEntity(i); } - 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 "Location"; case 5: return "Description"; } return IfcExternalInformation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociatesLibrary >::ptr LibraryInfoForObjects() const; // INVERSE IfcRelAssociatesLibrary::RelatingLibrary + IfcTemplatedEntityList< IfcRelAssociatesLibrary >::ptr LibraryInfoForObjects() const; // INVERSE IfcRelAssociatesLibrary::RelatingLibrary IfcTemplatedEntityList< IfcLibraryReference >::ptr HasLibraryReferences() const; // INVERSE IfcLibraryReference::ReferencedLibrary - 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, IfcActorSelect* v3_Publisher, boost::optional< std::string > v4_VersionDate, boost::optional< std::string > v5_Location, boost::optional< std::string > v6_Description); @@ -9364,14 +8815,8 @@ public: /// The library information that is being referenced. IfcLibraryInformation* ReferencedLibrary() const; void setReferencedLibrary(IfcLibraryInformation* v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcText; case 4: return Type::IfcLanguageId; case 5: return Type::IfcLibraryInformation; } return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Description"; case 4: return "Language"; case 5: return "ReferencedLibrary"; } return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociatesLibrary >::ptr LibraryRefForObjects() const; // INVERSE IfcRelAssociatesLibrary::RelatingLibrary - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssociatesLibrary >::ptr LibraryRefForObjects() const; // INVERSE IfcRelAssociatesLibrary::RelatingLibrary + 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_Identification, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_Language, IfcLibraryInformation* v6_ReferencedLibrary); @@ -9405,13 +8850,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); @@ -9428,13 +8867,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); @@ -9484,13 +8917,7 @@ public: /// Scale to be used, when the units of the CRS are not identical to the units of the engineering coordinate system. If omited, the value of 1.0 is assumed. double Scale() const; void setScale(double v); - virtual unsigned int getArgumentCount() const { return 8; } - 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; case 7: return IfcUtil::Argument_DOUBLE; } return IfcCoordinateOperation::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; case 5: return Type::IfcReal; case 6: return Type::IfcReal; case 7: return Type::IfcReal; } return IfcCoordinateOperation::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "Eastings"; case 3: return "Northings"; case 4: return "OrthogonalHeight"; case 5: return "XAxisAbscissa"; case 6: return "XAxisOrdinate"; case 7: return "Scale"; } return IfcCoordinateOperation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMapConversion (IfcAbstractEntity* e); IfcMapConversion (IfcCoordinateReferenceSystemSelect* v1_SourceCRS, IfcCoordinateReferenceSystem* v2_TargetCRS, double v3_Eastings, double v4_Northings, double v5_OrthogonalHeight, boost::optional< double > v6_XAxisAbscissa, boost::optional< double > v7_XAxisOrdinate, boost::optional< double > v8_Scale); @@ -9509,13 +8936,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::IfcClassificationSelect; case 1: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialClassifications"; case 1: return "ClassifiedMaterial"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialClassificationRelationship (IfcAbstractEntity* e); IfcMaterialClassificationRelationship (IfcEntityList::ptr v1_MaterialClassifications, IfcMaterial* v2_ClassifiedMaterial); @@ -9547,16 +8968,10 @@ public: /// HISTORYÿ New entity in IFC2x4 class IfcMaterialDefinition : 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< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial + IfcTemplatedEntityList< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects IfcTemplatedEntityList< IfcMaterialProperties >::ptr HasProperties() const; // INVERSE IfcMaterialProperties::Material - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialDefinition (IfcAbstractEntity* e); IfcMaterialDefinition (); @@ -9628,14 +9043,8 @@ public: /// The relative priority of the layer, expressed as ratio measure, normalised to 0..1. Controls how layers intersect in connections and corners of building elements: a layer from one element protrudes into (i.e. displaces) a layer from another element in a joint of these elements if the former element's layer has higher priority than the latter. The priorty value for a material layer in an element has to be set and maintained by software applications, in relation to the material layers in connected elements. The usage has to be further specified for each element, especially to avoid simultanious use with IfcLayerOffset. double Priority() const; void setPriority(double 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_BOOL; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_DOUBLE; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; case 1: return Type::IfcNonNegativeLengthMeasure; case 2: return Type::IfcLogical; case 3: return Type::IfcLabel; case 4: return Type::IfcText; case 5: return Type::IfcLabel; case 6: return Type::IfcNormalisedRatioMeasure; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Material"; case 1: return "LayerThickness"; case 2: return "IsVentilated"; case 3: return "Name"; case 4: return "Description"; case 5: return "Category"; case 6: return "Priority"; } return IfcMaterialDefinition::getArgumentName(i); } - 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, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Category, boost::optional< double > v7_Priority); @@ -9691,13 +9100,7 @@ public: /// IFC2x4 CHANGE  The attribute has been added at the end of attribute list. 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_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialLayer; case 1: return Type::IfcLabel; case 2: return Type::IfcText; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialLayers"; case 1: return "LayerSetName"; case 2: return "Description"; } return IfcMaterialDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< std::string > v3_Description); @@ -9754,13 +9157,7 @@ public: /// The numerical value of layer offset, in the direction of the axis assigned by the attribute OffsetDirection. The OffsetValues[1] identifies the offset from the lower position along the axis direction (normally the start of the standard extrusion), the OffsetValues[2] identifies the offset from the upper position along the axis direction (normally the end of the standard extrusion), std::vector< double > /*[1:2]*/ OffsetValues() const; void setOffsetValues(std::vector< double > /*[1:2]*/ 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_AGGREGATE_OF_DOUBLE; } return IfcMaterialLayer::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcLayerSetDirectionEnum; case 8: return Type::IfcLengthMeasure; } return IfcMaterialLayer::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "OffsetDirection"; case 8: return "OffsetValues"; } return IfcMaterialLayer::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialLayerWithOffsets (IfcAbstractEntity* e); IfcMaterialLayerWithOffsets (IfcMaterial* v1_Material, double v2_LayerThickness, boost::optional< bool > v3_IsVentilated, boost::optional< std::string > v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Category, boost::optional< double > v7_Priority, IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum v8_OffsetDirection, std::vector< double > /*[1:2]*/ v9_OffsetValues); @@ -9788,13 +9185,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); @@ -9835,14 +9226,8 @@ public: /// Category of the material profile, e.g. the role it has in the profile set it belongs to. std::string Category() const; void setCategory(std::string 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_DOUBLE; case 5: return IfcUtil::Argument_STRING; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcMaterial; case 3: return Type::IfcProfileDef; case 4: return Type::IfcNormalisedRatioMeasure; case 5: return Type::IfcLabel; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Material"; case 3: return "Profile"; case 4: return "Priority"; case 5: return "Category"; } return IfcMaterialDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcMaterialProfileSet >::ptr ToMaterialProfileSet() const; // INVERSE IfcMaterialProfileSet::MaterialProfiles - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcMaterialProfileSet >::ptr ToMaterialProfileSet() const; // INVERSE IfcMaterialProfileSet::MaterialProfiles + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialProfile (IfcAbstractEntity* e); IfcMaterialProfile (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, IfcProfileDef* v4_Profile, boost::optional< double > v5_Priority, boost::optional< std::string > v6_Category); @@ -9876,13 +9261,7 @@ public: /// The referenced IfcCompositeProfileDef instance shall be composed of all of the IfcProfileDef instances which are used via the MaterialProfiles list in the current IfcMaterialProfileSet . IfcCompositeProfileDef* CompositeProfile() const; void setCompositeProfile(IfcCompositeProfileDef* 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_ENTITY_INSTANCE; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcMaterialProfile; case 3: return Type::IfcCompositeProfileDef; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "MaterialProfiles"; case 3: return "CompositeProfile"; } return IfcMaterialDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialProfileSet (IfcAbstractEntity* e); IfcMaterialProfileSet (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcMaterialProfile >::ptr v3_MaterialProfiles, IfcCompositeProfileDef* v4_CompositeProfile); @@ -9898,13 +9277,7 @@ public: /// The numerical value of profile offset, in the direction of the axis direction - always AXIS1 i.e. the axis along the extrusion path. The OffsetValues[1] identifies the offset from the lower position along the axis direction (normally the start of the standard extrusion), the OffsetValues[2] identifies the offset from the upper position along the axis direction (normally the end of the standard extrusion), std::vector< double > /*[1:2]*/ OffsetValues() const; void setOffsetValues(std::vector< double > /*[1:2]*/ 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_DOUBLE; } return IfcMaterialProfile::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcLengthMeasure; } return IfcMaterialProfile::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "OffsetValues"; } return IfcMaterialProfile::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialProfileWithOffsets (IfcAbstractEntity* e); IfcMaterialProfileWithOffsets (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, IfcProfileDef* v4_Profile, boost::optional< double > v5_Priority, boost::optional< std::string > v6_Category, std::vector< double > /*[1:2]*/ v7_OffsetValues); @@ -9943,14 +9316,8 @@ public: /// occurrence. class IfcMaterialUsageDefinition : 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< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialUsageDefinition (IfcAbstractEntity* e); IfcMaterialUsageDefinition (); @@ -9974,13 +9341,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); @@ -10055,13 +9416,7 @@ public: bool hasReferencePath() const; IfcReference* ReferencePath() const; void setReferencePath(IfcReference* v); - virtual unsigned int getArgumentCount() const { return 11; } - 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; case 10: 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; case 10: return Type::IfcReference; } 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"; case 10: return "ReferencePath"; } 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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, IfcBenchmarkEnum::IfcBenchmarkEnum v8_Benchmark, boost::optional< std::string > v9_ValueSource, IfcMetricValueSelect* v10_DataValue, IfcReference* v11_ReferencePath); @@ -10077,13 +9432,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. std::string Currency() const; void setCurrency(std::string v); - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Currency"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMonetaryUnit (IfcAbstractEntity* e); IfcMonetaryUnit (std::string v1_Currency); @@ -10102,13 +9451,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); @@ -10127,15 +9470,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 (); @@ -10169,13 +9506,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_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENUMERATION; 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::IfcConstraint; case 8: return Type::IfcLogicalOperatorEnum; 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 "LogicalAggregator"; 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, boost::optional< std::string > v6_CreationTime, boost::optional< std::string > v7_UserDefinedGrade, boost::optional< IfcTemplatedEntityList< IfcConstraint >::ptr > v8_BenchmarkValues, boost::optional< IfcLogicalOperatorEnum::IfcLogicalOperatorEnum > v9_LogicalAggregator, IfcObjectiveEnum::IfcObjectiveEnum v10_ObjectiveQualifier, boost::optional< std::string > v11_UserDefinedQualifier); @@ -10215,16 +9546,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 "Identification"; case 1: return "Name"; case 2: return "Description"; case 3: return "Roles"; case 4: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr IsRelatedBy() const; // INVERSE IfcOrganizationRelationship::RelatedOrganizations + IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr 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_Identification, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< IfcTemplatedEntityList< IfcActorRole >::ptr > v4_Roles, boost::optional< IfcTemplatedEntityList< IfcAddress >::ptr > v5_Addresses); @@ -10276,13 +9601,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, boost::optional< IfcChangeActionEnum::IfcChangeActionEnum > v4_ChangeAction, boost::optional< int > v5_LastModifiedDate, IfcPersonAndOrganization* v6_LastModifyingUser, IfcApplication* v7_LastModifyingApplication, int v8_CreationDate); @@ -10345,14 +9664,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 "Identification"; case 1: return "FamilyName"; case 2: return "GivenName"; case 3: return "MiddleNames"; case 4: return "PrefixTitles"; case 5: return "SuffixTitles"; case 6: return "Roles"; case 7: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPersonAndOrganization >::ptr EngagedIn() const; // INVERSE IfcPersonAndOrganization::ThePerson - bool is(Type::Enum v) const; - 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_Identification, 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); @@ -10376,13 +9689,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); @@ -10403,15 +9710,9 @@ 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< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects IfcTemplatedEntityList< IfcPhysicalComplexQuantity >::ptr PartOfComplex() const; // INVERSE IfcPhysicalComplexQuantity::HasQuantities - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPhysicalQuantity (IfcAbstractEntity* e); IfcPhysicalQuantity (std::string v1_Name, boost::optional< std::string > v2_Description); @@ -10433,13 +9734,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); @@ -10491,13 +9786,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); @@ -10506,13 +9795,7 @@ public: class IfcPresentationItem : 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(); IfcPresentationItem (IfcAbstractEntity* e); IfcPresentationItem (); @@ -10551,13 +9834,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); @@ -10594,13 +9871,7 @@ public: /// IFC2x4 CHANGE  The data type has been changed from IfcPresentationStyleSelect (now deprecated) to IfcPresentationStyle. IfcTemplatedEntityList< IfcPresentationStyle >::ptr LayerStyles() const; void setLayerStyles(IfcTemplatedEntityList< IfcPresentationStyle >::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::IfcPresentationStyle; } 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, IfcTemplatedEntityList< IfcPresentationStyle >::ptr v8_LayerStyles); @@ -10618,13 +9889,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); @@ -10640,13 +9905,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); @@ -10684,13 +9943,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); @@ -10876,15 +10129,9 @@ 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); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects IfcTemplatedEntityList< IfcProfileProperties >::ptr HasProperties() const; // INVERSE IfcProfileProperties::ProfileDefinition - 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); @@ -10937,13 +10184,7 @@ public: /// NOTE  Only length measures are in scope and all two or three axes of the map coordinate system shall have the same length unit. IfcNamedUnit* MapUnit() const; void setMapUnit(IfcNamedUnit* v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcCoordinateReferenceSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcIdentifier; case 5: return Type::IfcIdentifier; case 6: return Type::IfcNamedUnit; } return IfcCoordinateReferenceSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "MapProjection"; case 5: return "MapZone"; case 6: return "MapUnit"; } return IfcCoordinateReferenceSystem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProjectedCRS (IfcAbstractEntity* e); IfcProjectedCRS (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, std::string v3_GeodeticDatum, boost::optional< std::string > v4_VerticalDatum, boost::optional< std::string > v5_MapProjection, boost::optional< std::string > v6_MapZone, IfcNamedUnit* v7_MapUnit); @@ -10952,14 +10193,8 @@ public: class IfcPropertyAbstraction : 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< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyAbstraction (IfcAbstractEntity* e); IfcPropertyAbstraction (); @@ -11024,13 +10259,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; } return IfcPropertyAbstraction::getArgumentType(i); } - 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; } return IfcPropertyAbstraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "EnumerationValues"; case 2: return "Unit"; } return IfcPropertyAbstraction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -11053,13 +10282,7 @@ public: /// IFC2x4 CHANGE Attribute added to the end of the attribute list. std::string Formula() const; void setFormula(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_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcAreaMeasure; case 4: return Type::IfcLabel; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "AreaValue"; case 4: return "Formula"; } 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, boost::optional< std::string > v5_Formula); @@ -11082,13 +10305,7 @@ public: /// IFC2x4 CHANGE Attribute added to the end of the attribute list. std::string Formula() const; void setFormula(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_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcCountMeasure; case 4: return Type::IfcLabel; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "CountValue"; case 4: return "Formula"; } 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, boost::optional< std::string > v5_Formula); @@ -11111,13 +10328,7 @@ public: /// IFC2x4 CHANGE Attribute added to the end of the attribute list. std::string Formula() const; void setFormula(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_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcLengthMeasure; case 4: return Type::IfcLabel; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "LengthValue"; case 4: return "Formula"; } 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, boost::optional< std::string > v5_Formula); @@ -11140,13 +10351,7 @@ public: /// IFC2x4 CHANGE Attribute added to the end of the attribute list. std::string Formula() const; void setFormula(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_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcTimeMeasure; case 4: return Type::IfcLabel; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "TimeValue"; case 4: return "Formula"; } 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, boost::optional< std::string > v5_Formula); @@ -11169,13 +10374,7 @@ public: /// IFC2x4 CHANGE Attribute added to the end of the attribute list. std::string Formula() const; void setFormula(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_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcVolumeMeasure; case 4: return Type::IfcLabel; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "VolumeValue"; case 4: return "Formula"; } 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, boost::optional< std::string > v5_Formula); @@ -11198,13 +10397,7 @@ public: /// IFC2x4 CHANGE Attribute added to the end of the attribute list. std::string Formula() const; void setFormula(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_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcPhysicalSimpleQuantity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcMassMeasure; case 4: return Type::IfcLabel; } return IfcPhysicalSimpleQuantity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "WeightValue"; case 4: return "Formula"; } 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, boost::optional< std::string > v5_Formula); @@ -11269,13 +10462,7 @@ public: /// reflect the sequence of the time periods. IfcTemplatedEntityList< IfcTimePeriod >::ptr TimePeriods() const; void setTimePeriods(IfcTemplatedEntityList< IfcTimePeriod >::ptr v); - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_INT; case 2: return IfcUtil::Argument_AGGREGATE_OF_INT; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRecurrenceTypeEnum; case 1: return Type::IfcDayInMonthNumber; case 2: return Type::IfcDayInWeekNumber; case 3: return Type::IfcMonthInYearNumber; case 4: return Type::IfcInteger; case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::IfcTimePeriod; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RecurrenceType"; case 1: return "DayComponent"; case 2: return "WeekdayComponent"; case 3: return "MonthComponent"; case 4: return "Position"; case 5: return "Interval"; case 6: return "Occurrences"; case 7: return "TimePeriods"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRecurrencePattern (IfcAbstractEntity* e); IfcRecurrencePattern (IfcRecurrenceTypeEnum::IfcRecurrenceTypeEnum v1_RecurrenceType, boost::optional< std::vector< int > /*[1:?]*/ > v2_DayComponent, boost::optional< std::vector< int > /*[1:?]*/ > v3_WeekdayComponent, boost::optional< std::vector< int > /*[1:?]*/ > v4_MonthComponent, boost::optional< int > v5_Position, boost::optional< int > v6_Interval, boost::optional< int > v7_Occurrences, boost::optional< IfcTemplatedEntityList< IfcTimePeriod >::ptr > v8_TimePeriods); @@ -11304,13 +10491,7 @@ public: bool hasInnerReference() const; IfcReference* InnerReference() const; void setInnerReference(IfcReference* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; case 3: return Type::UNDEFINED; case 4: return Type::IfcReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TypeIdentifier"; case 1: return "AttributeIdentifier"; case 2: return "InstanceName"; case 3: return "ListPositions"; case 4: return "InnerReference"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReference (IfcAbstractEntity* e); IfcReference (boost::optional< std::string > v1_TypeIdentifier, boost::optional< std::string > v2_AttributeIdentifier, boost::optional< std::string > v3_InstanceName, boost::optional< std::vector< int > /*[1:?]*/ > v4_ListPositions, IfcReference* v5_InnerReference); @@ -11381,16 +10562,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); @@ -11418,14 +10593,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); @@ -11465,15 +10634,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 LayerAssignment() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems + IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignment() 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 (); @@ -11499,15 +10662,9 @@ 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< IfcShapeAspect >::ptr HasShapeAspects() const; // INVERSE IfcShapeAspect::PartOfProductDefinitionShape + IfcTemplatedEntityList< IfcShapeAspect >::ptr HasShapeAspects() const; // INVERSE IfcShapeAspect::PartOfProductDefinitionShape IfcTemplatedEntityList< IfcMappedItem >::ptr MapUsage() const; // INVERSE IfcMappedItem::MappingSource - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRepresentationMap (IfcAbstractEntity* e); IfcRepresentationMap (IfcAxis2Placement* v1_MappingOrigin, IfcRepresentation* v2_MappedRepresentation); @@ -11528,13 +10685,7 @@ public: /// A description that may apply additional information about the relationship. 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); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcResourceLevelRelationship (IfcAbstractEntity* e); IfcResourceLevelRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description); @@ -11573,13 +10724,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); @@ -11604,13 +10749,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); @@ -11637,13 +10776,7 @@ public: /// Value of the data origin if DataOrigin attribute is USERDEFINED. std::string UserDefinedDataOrigin() const; void setUserDefinedDataOrigin(std::string v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcDataOriginEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "DataOrigin"; case 2: return "UserDefinedDataOrigin"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSchedulingTime (IfcAbstractEntity* e); IfcSchedulingTime (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin); @@ -11713,13 +10846,7 @@ public: /// Reference to the product definition shape of which this class is an aspect. IfcProductRepresentationSelect* PartOfProductDefinitionShape() const; void setPartOfProductDefinitionShape(IfcProductRepresentationSelect* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShapeModel; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::UNDEFINED; case 4: return Type::IfcProductRepresentationSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ShapeRepresentations"; case 1: return "Name"; case 2: return "Description"; case 3: return "ProductDefinitional"; case 4: return "PartOfProductDefinitionShape"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + 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, IfcProductRepresentationSelect* v5_PartOfProductDefinitionShape); @@ -11745,14 +10872,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); @@ -11895,13 +11016,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); @@ -11917,13 +11032,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); @@ -11939,13 +11048,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); @@ -11972,13 +11075,7 @@ public: /// Locations of the load samples or result samples, given within the local coordinate system defined by the instance which uses this resource object. Each item in the list of locations pertains to the values list item at the same list index. This attribute is optional for configurations in which the locations are implicitly known from higher-level definitions. std::vector< std::vector< double > > Locations() const; void setLocations(std::vector< std::vector< double > > v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcStructuralLoad::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcStructuralLoadOrResult; case 2: return Type::IfcLengthMeasure; } return IfcStructuralLoad::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Values"; case 2: return "Locations"; } 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(); IfcStructuralLoadConfiguration (IfcAbstractEntity* e); IfcStructuralLoadConfiguration (boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values, boost::optional< std::vector< std::vector< double > > > v3_Locations); @@ -11989,13 +11086,7 @@ public: /// HISTORY: New abstract superclass in IFC 2x4, upwards compatibility of all subtypes is preserved. class IfcStructuralLoadOrResult : 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(); IfcStructuralLoadOrResult (IfcAbstractEntity* e); IfcStructuralLoadOrResult (boost::optional< std::string > v1_Name); @@ -12006,13 +11097,7 @@ public: /// HISTORY: New entity in IFC 2x2. class IfcStructuralLoadStatic : public IfcStructuralLoadOrResult { public: - virtual unsigned int getArgumentCount() const { return 1; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralLoadOrResult::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralLoadOrResult::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralLoadOrResult::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -12046,13 +11131,7 @@ public: /// I.e. a positive non-uniform temperature change in z induces a positive curvature of the member about y, or a negative bending moment about y if there are respective restraints. y and z are local member axes. double DeltaTZ() const; void setDeltaTZ(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 "DeltaTConstant"; case 2: return "DeltaTY"; case 3: return "DeltaTZ"; } 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_DeltaTConstant, boost::optional< double > v3_DeltaTY, boost::optional< double > v4_DeltaTZ); @@ -12065,13 +11144,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); @@ -12127,13 +11200,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::IfcStyleAssignmentSelect; 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, IfcEntityList::ptr v2_Styles, boost::optional< std::string > v3_Name); @@ -12148,13 +11215,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); @@ -12182,13 +11243,7 @@ public: /// Shear reinforcement. Specified as area per area, e.g. square metre per square metre (hence ratio measure, i.e. unitless). double ShearReinforcement() const; void setShearReinforcement(double 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_DOUBLE; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 3: return IfcUtil::Argument_DOUBLE; } return IfcStructuralLoadOrResult::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::IfcRatioMeasure; } return IfcStructuralLoadOrResult::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "SurfaceReinforcement1"; case 2: return "SurfaceReinforcement2"; case 3: return "ShearReinforcement"; } return IfcStructuralLoadOrResult::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceReinforcementArea (IfcAbstractEntity* e); IfcSurfaceReinforcementArea (boost::optional< std::string > v1_Name, boost::optional< std::vector< double > /*[2:3]*/ > v2_SurfaceReinforcement1, boost::optional< std::vector< double > /*[2:3]*/ > v3_SurfaceReinforcement2, boost::optional< double > v4_ShearReinforcement); @@ -12209,13 +11264,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); @@ -12250,13 +11299,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; } return IfcPresentationItem::getArgumentType(i); } - 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; } return IfcPresentationItem::getArgumentEntity(i); } - 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"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -12279,13 +11322,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcReal; case 1: return Type::IfcReal; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RefractionIndex"; case 1: return "DispersionFactor"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -12303,13 +11340,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcColourRgb; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SurfaceColour"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -12338,13 +11369,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurfaceTexture; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Textures"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -12476,15 +11501,9 @@ public: /// IFC2x4 CHANGE  New attribute added at the end of the attribute list. std::vector< std::string > /*[1:?]*/ Parameter() const; void setParameter(std::vector< std::string > /*[1:?]*/ v); - virtual unsigned int getArgumentCount() const { return 5; } - 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_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::IfcIdentifier; case 3: return Type::IfcCartesianTransformationOperator2D; case 4: return Type::IfcIdentifier; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RepeatS"; case 1: return "RepeatT"; case 2: return "Mode"; case 3: return "TextureTransform"; case 4: return "Parameter"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcTextureCoordinate >::ptr IsMappedBy() const; // INVERSE IfcTextureCoordinate::Maps + IfcTemplatedEntityList< IfcTextureCoordinate >::ptr IsMappedBy() const; // INVERSE IfcTextureCoordinate::Maps IfcTemplatedEntityList< IfcSurfaceStyleWithTextures >::ptr UsedInStyles() const; // INVERSE IfcSurfaceStyleWithTextures::Textures - 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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter); @@ -12522,13 +11541,7 @@ public: /// The column information associated with this table. IfcTemplatedEntityList< IfcTableColumn >::ptr Columns() const; void setColumns(IfcTemplatedEntityList< IfcTableColumn >::ptr v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcTableRow; case 2: return Type::IfcTableColumn; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Rows"; case 2: return "Columns"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTable (IfcAbstractEntity* e); IfcTable (boost::optional< std::string > v1_Name, boost::optional< IfcTemplatedEntityList< IfcTableRow >::ptr > v2_Rows, boost::optional< IfcTemplatedEntityList< IfcTableColumn >::ptr > v3_Columns); @@ -12565,13 +11578,7 @@ public: bool hasReferencePath() const; IfcReference* ReferencePath() const; void setReferencePath(IfcReference* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcUnit; case 4: return Type::IfcReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "Unit"; case 4: return "ReferencePath"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTableColumn (IfcAbstractEntity* e); IfcTableColumn (boost::optional< std::string > v1_Identifier, boost::optional< std::string > v2_Name, boost::optional< std::string > v3_Description, IfcUnit* v4_Unit, IfcReference* v5_ReferencePath); @@ -12602,14 +11609,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 (boost::optional< IfcEntityList::ptr > v1_RowCells, boost::optional< bool > v2_IsHeading); @@ -12764,13 +11765,7 @@ public: /// It is a measured value. double Completion() const; void setCompletion(double v); - virtual unsigned int getArgumentCount() const { return 20; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENUMERATION; 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_STRING; case 9: return IfcUtil::Argument_STRING; case 10: return IfcUtil::Argument_STRING; case 11: return IfcUtil::Argument_STRING; case 12: return IfcUtil::Argument_STRING; case 13: return IfcUtil::Argument_BOOL; case 14: return IfcUtil::Argument_STRING; case 15: return IfcUtil::Argument_STRING; case 16: return IfcUtil::Argument_STRING; case 17: return IfcUtil::Argument_STRING; case 18: return IfcUtil::Argument_STRING; case 19: return IfcUtil::Argument_DOUBLE; } return IfcSchedulingTime::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcTaskDurationEnum; case 4: return Type::IfcDuration; case 5: return Type::IfcDateTime; case 6: return Type::IfcDateTime; case 7: return Type::IfcDateTime; case 8: return Type::IfcDateTime; case 9: return Type::IfcDateTime; case 10: return Type::IfcDateTime; case 11: return Type::IfcDuration; case 12: return Type::IfcDuration; case 13: return Type::UNDEFINED; case 14: return Type::IfcDateTime; case 15: return Type::IfcDuration; case 16: return Type::IfcDateTime; case 17: return Type::IfcDateTime; case 18: return Type::IfcDuration; case 19: return Type::IfcPositiveRatioMeasure; } return IfcSchedulingTime::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "DurationType"; case 4: return "ScheduleDuration"; case 5: return "ScheduleStart"; case 6: return "ScheduleFinish"; case 7: return "EarlyStart"; case 8: return "EarlyFinish"; case 9: return "LateStart"; case 10: return "LateFinish"; case 11: return "FreeFloat"; case 12: return "TotalFloat"; case 13: return "IsCritical"; case 14: return "StatusTime"; case 15: return "ActualDuration"; case 16: return "ActualStart"; case 17: return "ActualFinish"; case 18: return "RemainingTime"; case 19: return "Completion"; } return IfcSchedulingTime::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTaskTime (IfcAbstractEntity* e); IfcTaskTime (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< IfcTaskDurationEnum::IfcTaskDurationEnum > v4_DurationType, boost::optional< std::string > v5_ScheduleDuration, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_EarlyStart, boost::optional< std::string > v9_EarlyFinish, boost::optional< std::string > v10_LateStart, boost::optional< std::string > v11_LateFinish, boost::optional< std::string > v12_FreeFloat, boost::optional< std::string > v13_TotalFloat, boost::optional< bool > v14_IsCritical, boost::optional< std::string > v15_StatusTime, boost::optional< std::string > v16_ActualDuration, boost::optional< std::string > v17_ActualStart, boost::optional< std::string > v18_ActualFinish, boost::optional< std::string > v19_RemainingTime, boost::optional< double > v20_Completion); @@ -12783,13 +11778,7 @@ class IfcTaskTimeRecurring : public IfcTaskTime { public: IfcRecurrencePattern* Recurrance() const; void setRecurrance(IfcRecurrencePattern* v); - virtual unsigned int getArgumentCount() const { return 21; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 20: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcTaskTime::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 20: return Type::IfcRecurrencePattern; } return IfcTaskTime::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 20: return "Recurrance"; } return IfcTaskTime::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTaskTimeRecurring (IfcAbstractEntity* e); IfcTaskTimeRecurring (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< IfcTaskDurationEnum::IfcTaskDurationEnum > v4_DurationType, boost::optional< std::string > v5_ScheduleDuration, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_EarlyStart, boost::optional< std::string > v9_EarlyFinish, boost::optional< std::string > v10_LateStart, boost::optional< std::string > v11_LateFinish, boost::optional< std::string > v12_FreeFloat, boost::optional< std::string > v13_TotalFloat, boost::optional< bool > v14_IsCritical, boost::optional< std::string > v15_StatusTime, boost::optional< std::string > v16_ActualDuration, boost::optional< std::string > v17_ActualStart, boost::optional< std::string > v18_ActualFinish, boost::optional< std::string > v19_RemainingTime, boost::optional< double > v20_Completion, IfcRecurrencePattern* v21_Recurrance); @@ -12836,13 +11825,7 @@ public: /// IDs or addresses for any other means of telecommunication, for example instant messaging, voice-over-IP, or file transfer protocols. The communication protocol is indicated by the URI value with scheme designations such as irc:, sip:, or ftp:. std::vector< std::string > /*[1:?]*/ MessagingIDs() const; void setMessagingIDs(std::vector< std::string > /*[1:?]*/ v); - virtual unsigned int getArgumentCount() const { return 9; } - 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; case 8: return IfcUtil::Argument_AGGREGATE_OF_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::IfcURIReference; case 8: return Type::IfcURIReference; } 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"; case 8: return "MessagingIDs"; } 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, boost::optional< std::vector< std::string > /*[1:?]*/ > v9_MessagingIDs); @@ -12901,13 +11884,7 @@ public: bool hasModelOrDraughting() const; bool ModelOrDraughting() const; void setModelOrDraughting(bool v); - virtual unsigned int getArgumentCount() const { return 5; } - 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; case 4: return IfcUtil::Argument_BOOL; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcTextStyleForDefinedFont; case 2: return Type::IfcTextStyleTextModel; case 3: return Type::IfcTextFontSelect; case 4: return Type::UNDEFINED; } 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"; case 4: return "ModelOrDraughting"; } 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, IfcTextStyleForDefinedFont* v2_TextCharacterAppearance, IfcTextStyleTextModel* v3_TextStyle, IfcTextFontSelect* v4_TextFontStyle, boost::optional< bool > v5_ModelOrDraughting); @@ -12940,13 +11917,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcColour; case 1: return Type::IfcColour; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Colour"; case 1: return "BackgroundColour"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -13003,13 +11974,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; } return IfcPresentationItem::getArgumentType(i); } - 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; } return IfcPresentationItem::getArgumentEntity(i); } - 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"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -13030,13 +11995,7 @@ class IfcTextureCoordinate : public IfcPresentationItem { public: IfcTemplatedEntityList< IfcSurfaceTexture >::ptr Maps() const; void setMaps(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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcSurfaceTexture; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Maps"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextureCoordinate (IfcAbstractEntity* e); IfcTextureCoordinate (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps); @@ -13082,13 +12041,7 @@ public: /// IFC2x4 CHANGE  Made optional data type restricted to REAL. std::vector< double > /*[1:?]*/ Parameter() const; void setParameter(std::vector< double > /*[1:?]*/ v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } return IfcTextureCoordinate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcLabel; case 2: return Type::IfcReal; } return IfcTextureCoordinate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Mode"; case 2: 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 (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, std::string v2_Mode, boost::optional< std::vector< double > /*[1:?]*/ > v3_Parameter); @@ -13154,13 +12107,7 @@ public: void setVertices(IfcTemplatedEntityList< IfcTextureVertex >::ptr v); IfcFace* MappedTo() const; void setMappedTo(IfcFace* v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcTextureCoordinate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcTextureVertex; case 2: return Type::IfcFace; } return IfcTextureCoordinate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Vertices"; case 2: return "MappedTo"; } 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< IfcSurfaceTexture >::ptr v1_Maps, IfcTemplatedEntityList< IfcTextureVertex >::ptr v2_Vertices, IfcFace* v3_MappedTo); @@ -13198,13 +12145,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcParameterValue; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -13215,13 +12156,7 @@ class IfcTextureVertexList : public IfcPresentationItem { public: std::vector< std::vector< double > > TexCoordsList() const; void setTexCoordsList(std::vector< std::vector< double > > 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_AGGREGATE_OF_DOUBLE; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcParameterValue; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TexCoordsList"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTextureVertexList (IfcAbstractEntity* e); IfcTextureVertexList (std::vector< std::vector< double > > v1_TexCoordsList); @@ -13241,13 +12176,7 @@ public: /// End time of the time period. std::string EndTime() const; void setEndTime(std::string v); - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTime; case 1: return Type::IfcTime; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "StartTime"; case 1: return "EndTime"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTimePeriod (IfcAbstractEntity* e); IfcTimePeriod (std::string v1_StartTime, std::string v2_EndTime); @@ -13290,14 +12219,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_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDateTime; case 3: return Type::IfcDateTime; case 4: return Type::IfcTimeSeriesDataTypeEnum; case 5: return Type::IfcDataOriginEnum; case 6: return Type::IfcLabel; case 7: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "StartTime"; case 3: return "EndTime"; case 4: return "TimeSeriesDataType"; case 5: return "DataOrigin"; case 6: return "UserDefinedDataOrigin"; case 7: return "Unit"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTimeSeries (IfcAbstractEntity* e); IfcTimeSeries (std::string v1_Name, boost::optional< std::string > v2_Description, std::string v3_StartTime, std::string v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit); @@ -13317,13 +12240,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); @@ -13336,13 +12253,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 (); @@ -13384,13 +12295,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); @@ -13406,13 +12311,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); @@ -13430,13 +12329,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 (); @@ -13456,13 +12349,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); @@ -13535,13 +12422,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); @@ -13576,13 +12457,7 @@ public: /// restricted by a recurrence pattern. std::string Finish() const; void setFinish(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; } return IfcSchedulingTime::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcRecurrencePattern; case 4: return Type::IfcDate; case 5: return Type::IfcDate; } return IfcSchedulingTime::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "RecurrencePattern"; case 4: return "Start"; case 5: return "Finish"; } return IfcSchedulingTime::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWorkTime (IfcAbstractEntity* e); IfcWorkTime (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, IfcRecurrencePattern* v4_RecurrencePattern, boost::optional< std::string > v5_Start, boost::optional< std::string > v6_Finish); @@ -13603,13 +12478,7 @@ public: /// The approvals that are related to another (relating) approval.IFC2x Edition 4 CHANGE The cardinality of this attribute has been changed to SET. IfcTemplatedEntityList< IfcApproval >::ptr RelatedApprovals() const; void setRelatedApprovals(IfcTemplatedEntityList< IfcApproval >::ptr 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_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcApproval; case 3: return Type::IfcApproval; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingApproval"; case 3: return "RelatedApprovals"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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 (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcApproval* v3_RelatingApproval, IfcTemplatedEntityList< IfcApproval >::ptr v4_RelatedApprovals); @@ -13638,13 +12507,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); @@ -13670,13 +12533,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); @@ -13706,13 +12563,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); @@ -13735,13 +12586,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. boost::dynamic_bitset<> RasterCode() const; void setRasterCode(boost::dynamic_bitset<> 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_BINARY; } return IfcSurfaceTexture::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::UNDEFINED; } return IfcSurfaceTexture::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "RasterFormat"; case 6: 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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_RasterFormat, boost::dynamic_bitset<> v7_RasterCode); @@ -13781,13 +12626,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); @@ -13870,15 +12709,9 @@ public: /// IFC2x4 CHANGE  New attribute added at the end of the attribute list. std::vector< std::string > /*[1:?]*/ ReferenceTokens() const; void setReferenceTokens(std::vector< std::string > /*[1:?]*/ 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_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_STRING; } return IfcExternalInformation::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; case 2: return Type::IfcDate; case 3: return Type::IfcLabel; case 4: return Type::IfcText; case 5: return Type::IfcURIReference; case 6: return Type::IfcIdentifier; } return IfcExternalInformation::getArgumentEntity(i); } - 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"; case 4: return "Description"; case 5: return "Location"; case 6: return "ReferenceTokens"; } return IfcExternalInformation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociatesClassification >::ptr ClassificationForObjects() const; // INVERSE IfcRelAssociatesClassification::RelatingClassification + IfcTemplatedEntityList< IfcRelAssociatesClassification >::ptr ClassificationForObjects() const; // INVERSE IfcRelAssociatesClassification::RelatingClassification IfcTemplatedEntityList< IfcClassificationReference >::ptr HasReferences() const; // INVERSE IfcClassificationReference::ReferencedSource - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcClassification (IfcAbstractEntity* e); IfcClassification (boost::optional< std::string > v1_Source, boost::optional< std::string > v2_Edition, boost::optional< std::string > v3_EditionDate, std::string v4_Name, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Location, boost::optional< std::vector< std::string > /*[1:?]*/ > v7_ReferenceTokens); @@ -13923,15 +12756,9 @@ public: bool hasSort() const; std::string Sort() const; void setSort(std::string v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; } return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcClassificationReferenceSelect; case 4: return Type::IfcText; case 5: return Type::IfcIdentifier; } return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ReferencedSource"; case 4: return "Description"; case 5: return "Sort"; } return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociatesClassification >::ptr ClassificationRefForObjects() const; // INVERSE IfcRelAssociatesClassification::RelatingClassification + IfcTemplatedEntityList< IfcRelAssociatesClassification >::ptr ClassificationRefForObjects() const; // INVERSE IfcRelAssociatesClassification::RelatingClassification IfcTemplatedEntityList< IfcClassificationReference >::ptr HasReferences() const; // INVERSE IfcClassificationReference::ReferencedSource - 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_Identification, boost::optional< std::string > v3_Name, IfcClassificationReferenceSelect* v4_ReferencedSource, boost::optional< std::string > v5_Description, boost::optional< std::string > v6_Sort); @@ -13942,13 +12769,7 @@ class IfcColourRgbList : public IfcPresentationItem { public: std::vector< std::vector< double > > ColourList() const; void setColourList(std::vector< std::vector< double > > 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_AGGREGATE_OF_DOUBLE; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNormalisedRatioMeasure; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ColourList"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcColourRgbList (IfcAbstractEntity* e); IfcColourRgbList (std::vector< std::vector< double > > v1_ColourList); @@ -13969,13 +12790,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -14027,13 +12842,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); @@ -14053,13 +12862,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); @@ -14088,13 +12891,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); @@ -14136,13 +12933,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); @@ -14160,14 +12951,8 @@ 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); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + 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); @@ -14228,14 +13013,8 @@ 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); } - IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects + 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); @@ -14264,13 +13043,7 @@ public: /// A positive or negative offset to add after the inherited ConversionFactor was applied. double ConversionOffset() const; void setConversionOffset(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 IfcConversionBasedUnit::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcReal; } return IfcConversionBasedUnit::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "ConversionOffset"; } return IfcConversionBasedUnit::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConversionBasedUnitWithOffset (IfcAbstractEntity* e); IfcConversionBasedUnitWithOffset (IfcDimensionalExponents* v1_Dimensions, IfcUnitEnum::IfcUnitEnum v2_UnitType, std::string v3_Name, IfcMeasureWithUnit* v4_ConversionFactor, double v5_ConversionOffset); @@ -14310,13 +13083,7 @@ public: /// The source from which an exchange rate is obtained. IfcLibraryInformation* RateSource() const; void setRateSource(IfcLibraryInformation* v); - virtual unsigned int getArgumentCount() const { return 7; } - 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_DOUBLE; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcMonetaryUnit; case 3: return Type::IfcMonetaryUnit; case 4: return Type::IfcPositiveRatioMeasure; case 5: return Type::IfcDateTime; case 6: return Type::IfcLibraryInformation; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingMonetaryUnit"; case 3: return "RelatedMonetaryUnit"; case 4: return "ExchangeRate"; case 5: return "RateDateTime"; case 6: return "RateSource"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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 (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMonetaryUnit* v3_RelatingMonetaryUnit, IfcMonetaryUnit* v4_RelatedMonetaryUnit, double v5_ExchangeRate, boost::optional< std::string > v6_RateDateTime, IfcLibraryInformation* v7_RateSource); @@ -14360,13 +13127,7 @@ public: bool hasModelOrDraughting() const; bool ModelOrDraughting() const; void setModelOrDraughting(bool v); - virtual unsigned int getArgumentCount() const { return 5; } - 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; case 4: return IfcUtil::Argument_BOOL; } 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; case 4: return Type::UNDEFINED; } 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"; case 4: return "ModelOrDraughting"; } 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, boost::optional< bool > v5_ModelOrDraughting); @@ -14387,13 +13148,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurveStyleFontPattern; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "PatternList"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -14423,13 +13178,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; } return IfcPresentationItem::getArgumentType(i); } - 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; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "CurveFont"; case 2: return "CurveFontScaling"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -14452,13 +13201,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; case 1: return Type::IfcPositiveLengthMeasure; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "VisibleSegmentLength"; case 1: return "InvisibleSegmentLength"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -14561,13 +13304,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); @@ -14672,17 +13409,11 @@ 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_STRING; 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_STRING; case 11: return IfcUtil::Argument_STRING; case 12: return IfcUtil::Argument_STRING; case 13: return IfcUtil::Argument_STRING; case 14: return IfcUtil::Argument_STRING; case 15: return IfcUtil::Argument_ENUMERATION; case 16: return IfcUtil::Argument_ENUMERATION; } return IfcExternalInformation::getArgumentType(i); } - 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::IfcURIReference; 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::IfcDateTime; case 11: return Type::IfcDateTime; case 12: return Type::IfcIdentifier; case 13: return Type::IfcDate; case 14: return Type::IfcDate; case 15: return Type::IfcDocumentConfidentialityEnum; case 16: return Type::IfcDocumentStatusEnum; } return IfcExternalInformation::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "Name"; case 2: return "Description"; case 3: return "Location"; 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"; } return IfcExternalInformation::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociatesDocument >::ptr DocumentInfoForObjects() const; // INVERSE IfcRelAssociatesDocument::RelatingDocument + IfcTemplatedEntityList< IfcRelAssociatesDocument >::ptr DocumentInfoForObjects() const; // INVERSE IfcRelAssociatesDocument::RelatingDocument IfcTemplatedEntityList< IfcDocumentReference >::ptr HasDocumentReferences() const; // INVERSE IfcDocumentReference::ReferencedDocument 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_Identification, std::string v2_Name, boost::optional< std::string > v3_Description, boost::optional< std::string > v4_Location, 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, boost::optional< std::string > v11_CreationTime, boost::optional< std::string > v12_LastRevisionTime, boost::optional< std::string > v13_ElectronicFormat, boost::optional< std::string > v14_ValidFrom, boost::optional< std::string > v15_ValidUntil, boost::optional< IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum > v16_Confidentiality, boost::optional< IfcDocumentStatusEnum::IfcDocumentStatusEnum > v17_Status); @@ -14709,13 +13440,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 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcDocumentInformation; case 3: return Type::IfcDocumentInformation; case 4: return Type::IfcLabel; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingDocument"; case 3: return "RelatedDocuments"; case 4: return "RelationshipType"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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 (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcDocumentInformation* v3_RelatingDocument, IfcTemplatedEntityList< IfcDocumentInformation >::ptr v4_RelatedDocuments, boost::optional< std::string > v5_RelationshipType); @@ -14746,14 +13471,8 @@ public: /// The document that is referenced. IfcDocumentInformation* ReferencedDocument() const; void setReferencedDocument(IfcDocumentInformation* v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcExternalReference::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcText; case 4: return Type::IfcDocumentInformation; } return IfcExternalReference::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Description"; case 4: return "ReferencedDocument"; } return IfcExternalReference::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssociatesDocument >::ptr DocumentRefForObjects() const; // INVERSE IfcRelAssociatesDocument::RelatingDocument - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssociatesDocument >::ptr DocumentRefForObjects() const; // INVERSE IfcRelAssociatesDocument::RelatingDocument + 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_Identification, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcDocumentInformation* v5_ReferencedDocument); @@ -14816,13 +13535,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); @@ -14869,13 +13582,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); @@ -14928,13 +13635,7 @@ public: /// ScheduleDataOrigin. std::string ScheduleDate() const; void setScheduleDate(std::string v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; } return IfcSchedulingTime::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcDateTime; case 4: return Type::IfcDateTime; case 5: return Type::IfcDateTime; case 6: return Type::IfcDateTime; } return IfcSchedulingTime::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ActualDate"; case 4: return "EarlyDate"; case 5: return "LateDate"; case 6: return "ScheduleDate"; } return IfcSchedulingTime::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEventTime (IfcAbstractEntity* e); IfcEventTime (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< std::string > v4_ActualDate, boost::optional< std::string > v5_EarlyDate, boost::optional< std::string > v6_LateDate, boost::optional< std::string > v7_ScheduleDate); @@ -14953,13 +13654,7 @@ public: void setDescription(std::string v); IfcTemplatedEntityList< IfcProperty >::ptr Properties() const; void setProperties(IfcTemplatedEntityList< IfcProperty >::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; } return IfcPropertyAbstraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcText; case 2: return Type::IfcProperty; } return IfcPropertyAbstraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Properties"; } return IfcPropertyAbstraction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExtendedProperties (IfcAbstractEntity* e); IfcExtendedProperties (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties); @@ -14982,13 +13677,7 @@ public: /// Objects within the list of IfcResourceObjectSelect that can be tagged by an external reference to a dictionary, library, catalogue, classification or documentation. IfcEntityList::ptr RelatedResourceObjects() const; void setRelatedResourceObjects(IfcEntityList::ptr 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_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcExternalReference; case 3: return Type::IfcResourceObjectSelect; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingReference"; case 3: return "RelatedResourceObjects"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternalReferenceRelationship (IfcAbstractEntity* e); IfcExternalReferenceRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcExternalReference* v3_RelatingReference, IfcEntityList::ptr v4_RelatedResourceObjects); @@ -15043,14 +13732,8 @@ 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); } - IfcTemplatedEntityList< IfcTextureMap >::ptr HasTextureMaps() const; // INVERSE IfcTextureMap::MappedTo - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcTextureMap >::ptr HasTextureMaps() const; // INVERSE IfcTextureMap::MappedTo + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFace (IfcAbstractEntity* e); IfcFace (IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds); @@ -15069,13 +13752,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); @@ -15088,13 +13765,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); @@ -15144,13 +13815,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); @@ -15195,13 +13860,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); @@ -15250,13 +13909,7 @@ public: bool hasModelorDraughting() const; bool ModelorDraughting() const; void setModelorDraughting(bool v); - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } return IfcPresentationStyle::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcFillStyleSelect; case 2: return Type::UNDEFINED; } return IfcPresentationStyle::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "FillStyles"; case 2: return "ModelorDraughting"; } 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, boost::optional< bool > v3_ModelorDraughting); @@ -15329,14 +13982,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); @@ -15363,13 +14010,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 (); @@ -15416,13 +14057,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); @@ -15440,13 +14075,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); @@ -15509,13 +14138,7 @@ public: /// IFC2x4 CHANGE The select of an explict direction has been added. IfcGridPlacementDirectionSelect* PlacementRefDirection() const; void setPlacementRefDirection(IfcGridPlacementDirectionSelect* 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::IfcGridPlacementDirectionSelect; } 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, IfcGridPlacementDirectionSelect* v2_PlacementRefDirection); @@ -15544,13 +14167,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); @@ -15596,13 +14213,7 @@ public: /// Location, provided as an URI, at which the image texture is electronically published. std::string URLReference() const; void setURLReference(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 IfcSurfaceTexture::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcURIReference; } return IfcSurfaceTexture::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: 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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, std::string v6_URLReference); @@ -15621,13 +14232,7 @@ public: void setColours(IfcColourRgbList* v); std::vector< int > /*[1:?]*/ ColourIndex() const; void setColourIndex(std::vector< int > /*[1:?]*/ 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_AGGREGATE_OF_INT; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTessellatedFaceSet; case 1: return Type::IfcSurfaceStyleShading; case 2: return Type::IfcColourRgbList; case 3: return Type::UNDEFINED; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappedTo"; case 1: return "Overrides"; case 2: return "Colours"; case 3: return "ColourIndex"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcIndexedColourMap (IfcAbstractEntity* e); IfcIndexedColourMap (IfcTessellatedFaceSet* v1_MappedTo, IfcSurfaceStyleShading* v2_Overrides, IfcColourRgbList* v3_Colours, std::vector< int > /*[1:?]*/ v4_ColourIndex); @@ -15640,13 +14245,7 @@ public: void setMappedTo(IfcTessellatedFaceSet* v); IfcTextureVertexList* TexCoords() const; void setTexCoords(IfcTextureVertexList* 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 IfcTextureCoordinate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcTessellatedFaceSet; case 2: return Type::IfcTextureVertexList; } return IfcTextureCoordinate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "MappedTo"; case 2: return "TexCoords"; } 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(); IfcIndexedTextureMap (IfcAbstractEntity* e); IfcIndexedTextureMap (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords); @@ -15659,13 +14258,7 @@ public: bool hasTexCoordIndex() const; std::vector< std::vector< int > > TexCoordIndex() const; void setTexCoordIndex(std::vector< std::vector< int > > 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_AGGREGATE_OF_INT; } return IfcIndexedTextureMap::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::UNDEFINED; } return IfcIndexedTextureMap::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "TexCoordIndex"; } return IfcIndexedTextureMap::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcIndexedTriangleTextureMap (IfcAbstractEntity* e); IfcIndexedTriangleTextureMap (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords, boost::optional< std::vector< std::vector< int > > > v4_TexCoordIndex); @@ -15681,13 +14274,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, std::string v3_StartTime, std::string v4_EndTime, IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum v5_TimeSeriesDataType, IfcDataOriginEnum::IfcDataOriginEnum v6_DataOrigin, boost::optional< std::string > v7_UserDefinedDataOrigin, IfcUnit* v8_Unit, IfcTemplatedEntityList< IfcIrregularTimeSeriesValue >::ptr v9_Values); @@ -15740,13 +14327,7 @@ public: /// measurement (work time or elapsed time). IfcTaskDurationEnum::IfcTaskDurationEnum DurationType() const; void setDurationType(IfcTaskDurationEnum::IfcTaskDurationEnum 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 IfcSchedulingTime::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcTimeOrRatioSelect; case 4: return Type::IfcTaskDurationEnum; } return IfcSchedulingTime::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "LagValue"; case 4: return "DurationType"; } return IfcSchedulingTime::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLagTime (IfcAbstractEntity* e); IfcLagTime (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, IfcTimeOrRatioSelect* v4_LagValue, IfcTaskDurationEnum::IfcTaskDurationEnum v5_DurationType); @@ -15780,13 +14361,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); @@ -15801,13 +14376,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); @@ -15828,13 +14397,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); @@ -15869,13 +14432,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); @@ -15915,13 +14472,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); @@ -15961,13 +14512,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); @@ -16035,13 +14580,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); @@ -16075,13 +14614,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 (); @@ -16114,13 +14647,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); @@ -16178,16 +14705,10 @@ public: /// IFC2x4 CHANGE  The attribute has been added at the end of attribute list. std::string Category() const; void setCategory(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; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcLabel; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Category"; } return IfcMaterialDefinition::getArgumentName(i); } - 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< IfcMaterialRelationship >::ptr IsRelatedWith() const; // INVERSE IfcMaterialRelationship::RelatedMaterials IfcTemplatedEntityList< IfcMaterialRelationship >::ptr RelatesTo() const; // INVERSE IfcMaterialRelationship::RelatingMaterial - 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, boost::optional< std::string > v2_Description, boost::optional< std::string > v3_Category); @@ -16223,14 +14744,8 @@ public: /// Category of the material constituent, e.g. the role it has in the constituent set it belongs to. std::string Category() const; void setCategory(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_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_STRING; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcMaterial; case 3: return Type::IfcNormalisedRatioMeasure; case 4: return Type::IfcLabel; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Material"; case 3: return "Fraction"; case 4: return "Category"; } return IfcMaterialDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcMaterialConstituentSet >::ptr ToMaterialConstituentSet() const; // INVERSE IfcMaterialConstituentSet::MaterialConstituents - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcMaterialConstituentSet >::ptr ToMaterialConstituentSet() const; // INVERSE IfcMaterialConstituentSet::MaterialConstituents + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialConstituent (IfcAbstractEntity* e); IfcMaterialConstituent (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_Material, boost::optional< double > v4_Fraction, boost::optional< std::string > v5_Category); @@ -16267,13 +14782,7 @@ public: /// Identification of the constituents from which the material constituent set is composed. IfcTemplatedEntityList< IfcMaterialConstituent >::ptr MaterialConstituents() const; void setMaterialConstituents(IfcTemplatedEntityList< IfcMaterialConstituent >::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; } return IfcMaterialDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcMaterialConstituent; } return IfcMaterialDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "MaterialConstituents"; } return IfcMaterialDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialConstituentSet (IfcAbstractEntity* e); IfcMaterialConstituentSet (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, boost::optional< IfcTemplatedEntityList< IfcMaterialConstituent >::ptr > v3_MaterialConstituents); @@ -16314,13 +14823,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); @@ -16457,13 +14960,7 @@ public: /// NOTE 2  The ReferenceExtent for IfcWallStandardCase is the reference height starting at z=0 being the XY plane of the object coordinate system. double ReferenceExtent() const; void setReferenceExtent(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_ENUMERATION; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_DOUBLE; case 4: return IfcUtil::Argument_DOUBLE; } return IfcMaterialUsageDefinition::getArgumentType(i); } - 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; case 4: return Type::IfcPositiveLengthMeasure; } return IfcMaterialUsageDefinition::getArgumentEntity(i); } - 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"; case 4: return "ReferenceExtent"; } return IfcMaterialUsageDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< double > v5_ReferenceExtent); @@ -16496,13 +14993,7 @@ public: /// NOTE 2  The ReferenceExtent for IfcBeamStandardCase, IfcColumnStandardCase, and IfcMemberStandardCase is the reference length starting at z=0 being the XY plane of the object coordinate system. double ReferenceExtent() const; void setReferenceExtent(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_INT; case 2: return IfcUtil::Argument_DOUBLE; } return IfcMaterialUsageDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterialProfileSet; case 1: return Type::IfcCardinalPointReference; case 2: return Type::IfcPositiveLengthMeasure; } return IfcMaterialUsageDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ForProfileSet"; case 1: return "CardinalPoint"; case 2: return "ReferenceExtent"; } return IfcMaterialUsageDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialProfileSetUsage (IfcAbstractEntity* e); IfcMaterialProfileSetUsage (IfcMaterialProfileSet* v1_ForProfileSet, boost::optional< int > v2_CardinalPoint, boost::optional< double > v3_ReferenceExtent); @@ -16543,13 +15034,7 @@ public: /// Index reference to a significant point in the second section profile. Describes how this section is aligned relative to the axis of the member it is associated with. This parametric specification of profile alignment can be provided redundantly to the explicit alignment defined by ForProfileSet.MaterialProfiles[*].Profile. int CardinalEndPoint() const; void setCardinalEndPoint(int 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_INT; } return IfcMaterialProfileSetUsage::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcMaterialProfileSet; case 4: return Type::IfcCardinalPointReference; } return IfcMaterialProfileSetUsage::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ForProfileEndSet"; case 4: return "CardinalEndPoint"; } return IfcMaterialProfileSetUsage::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialProfileSetUsageTapering (IfcAbstractEntity* e); IfcMaterialProfileSetUsageTapering (IfcMaterialProfileSet* v1_ForProfileSet, boost::optional< int > v2_CardinalPoint, boost::optional< double > v3_ReferenceExtent, IfcMaterialProfileSet* v4_ForProfileEndSet, boost::optional< int > v5_CardinalEndPoint); @@ -16584,13 +15069,7 @@ public: /// IFC2x4 CHANGE The datatype has been changed to supertype IfcMaterialDefinition. IfcMaterialDefinition* Material() const; void setMaterial(IfcMaterialDefinition* 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 IfcExtendedProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcMaterialDefinition; } return IfcExtendedProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "Material"; } return IfcExtendedProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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 (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties, IfcMaterialDefinition* v4_Material); @@ -16612,13 +15091,7 @@ public: /// The amount of related material in the whole (composite material or material set). Expressed as proportion (percentage) of weight or volume, or as any other appropriate value. 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 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcMaterial; case 3: return Type::IfcMaterial; case 4: return Type::IfcLabel; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingMaterial"; case 3: return "RelatedMaterials"; case 4: return "Expression"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMaterialRelationship (IfcAbstractEntity* e); IfcMaterialRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcMaterial* v3_RelatingMaterial, IfcTemplatedEntityList< IfcMaterial >::ptr v4_RelatedMaterials, boost::optional< std::string > v5_Expression); @@ -16653,13 +15126,7 @@ public: /// HISTORY  New entity in IFC2x4. class IfcMirroredProfileDef : public IfcDerivedProfileDef { public: - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDerivedProfileDef::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDerivedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDerivedProfileDef::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMirroredProfileDef (IfcAbstractEntity* e); IfcMirroredProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcProfileDef* v3_ParentProfile, boost::optional< std::string > v5_Label); @@ -16717,20 +15184,14 @@ 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< IfcRelNests >::ptr Nests() const; // INVERSE IfcRelNests::RelatedObjects IfcTemplatedEntityList< IfcRelNests >::ptr IsNestedBy() const; // INVERSE IfcRelNests::RelatingObject IfcTemplatedEntityList< IfcRelDeclares >::ptr HasContext() const; // INVERSE IfcRelDeclares::RelatedDefinitions IfcTemplatedEntityList< IfcRelAggregates >::ptr IsDecomposedBy() const; // INVERSE IfcRelAggregates::RelatingObject IfcTemplatedEntityList< IfcRelAggregates >::ptr Decomposes() const; // INVERSE IfcRelAggregates::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); @@ -16797,13 +15258,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); @@ -16823,13 +15278,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 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcOrganization; case 3: return Type::IfcOrganization; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingOrganization"; case 3: return "RelatedOrganizations"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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 (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcOrganization* v3_RelatingOrganization, IfcTemplatedEntityList< IfcOrganization >::ptr v4_RelatedOrganizations); @@ -16850,13 +15299,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); @@ -16911,13 +15354,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); @@ -16942,13 +15379,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); @@ -16981,13 +15412,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); @@ -17027,13 +15452,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 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_INT; case 8: return IfcUtil::Argument_AGGREGATE_OF_BINARY; } return IfcSurfaceTexture::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::IfcInteger; case 8: return Type::UNDEFINED; } return IfcSurfaceTexture::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Width"; case 6: return "Height"; case 7: return "ColourComponents"; case 8: 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, boost::optional< std::string > v3_Mode, IfcCartesianTransformationOperator2D* v4_TextureTransform, boost::optional< std::vector< std::string > /*[1:?]*/ > v5_Parameter, int v6_Width, int v7_Height, int v8_ColourComponents, std::vector< boost::dynamic_bitset<> > /*[1:?]*/ v9_Pixel); @@ -17053,13 +15472,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); @@ -17078,13 +15491,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); @@ -17097,13 +15504,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 (); @@ -17126,13 +15527,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); @@ -17158,13 +15553,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); @@ -17214,13 +15603,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); @@ -17292,13 +15675,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); @@ -17316,13 +15693,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; } return IfcPresentationItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } return IfcPresentationItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } return IfcPresentationItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -17331,13 +15702,7 @@ public: class IfcPreDefinedProperties : public IfcPropertyAbstraction { public: - virtual unsigned int getArgumentCount() const { return 0; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPropertyAbstraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPropertyAbstraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPropertyAbstraction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPreDefinedProperties (IfcAbstractEntity* e); IfcPreDefinedProperties (); @@ -17356,13 +15721,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); @@ -17382,15 +15741,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); @@ -17412,13 +15765,7 @@ public: /// Profile definition which is qualified by these properties. IfcProfileDef* ProfileDefinition() const; void setProfileDefinition(IfcProfileDef* 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 IfcExtendedProperties::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcProfileDef; } return IfcExtendedProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ProfileDefinition"; } return IfcExtendedProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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_Name, boost::optional< std::string > v2_Description, IfcTemplatedEntityList< IfcProperty >::ptr v3_Properties, IfcProfileDef* v4_ProfileDefinition); @@ -17437,17 +15784,11 @@ 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; } return IfcPropertyAbstraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcText; } return IfcPropertyAbstraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } return IfcPropertyAbstraction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcPropertySet >::ptr PartOfPset() const; // INVERSE IfcPropertySet::HasProperties + IfcTemplatedEntityList< IfcPropertySet >::ptr PartOfPset() const; // INVERSE IfcPropertySet::HasProperties 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); @@ -17505,15 +15846,9 @@ 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< IfcRelDeclares >::ptr HasContext() const; // INVERSE IfcRelDeclares::RelatedDefinitions + IfcTemplatedEntityList< IfcRelDeclares >::ptr HasContext() const; // INVERSE IfcRelDeclares::RelatedDefinitions 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(); IfcPropertyDefinition (IfcAbstractEntity* e); IfcPropertyDefinition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -17540,13 +15875,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 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcProperty; case 3: return Type::IfcProperty; case 4: return Type::IfcText; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "DependingProperty"; case 3: return "DependantProperty"; case 4: return "Expression"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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 (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcProperty* v3_DependingProperty, IfcProperty* v4_DependantProperty, boost::optional< std::string > v5_Expression); @@ -17596,16 +15925,10 @@ 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< IfcTypeObject >::ptr DefinesType() const; // INVERSE IfcTypeObject::HasPropertySets + IfcTemplatedEntityList< IfcTypeObject >::ptr DefinesType() const; // INVERSE IfcTypeObject::HasPropertySets IfcTemplatedEntityList< IfcRelDefinesByTemplate >::ptr IsDefinedBy() const; // INVERSE IfcRelDefinesByTemplate::RelatedPropertySets IfcTemplatedEntityList< IfcRelDefinesByProperties >::ptr DefinesOccurrence() const; // INVERSE IfcRelDefinesByProperties::RelatingPropertyDefinition - 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); @@ -17638,13 +15961,7 @@ public: /// HISTORY  New Entity in IFC2x4. class IfcPropertyTemplateDefinition : 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); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyTemplateDefinition (IfcAbstractEntity* e); IfcPropertyTemplateDefinition (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -17653,13 +15970,7 @@ public: class IfcQuantitySet : public IfcPropertySetDefinition { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { 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(); IfcQuantitySet (IfcAbstractEntity* e); IfcQuantitySet (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -17707,13 +16018,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); @@ -17732,13 +16037,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, std::string v3_StartTime, std::string 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); @@ -17777,13 +16076,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; } return IfcPreDefinedProperties::getArgumentType(i); } - 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; } return IfcPreDefinedProperties::getArgumentEntity(i); } - 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"; } return IfcPreDefinedProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -17799,13 +16092,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); @@ -17825,13 +16112,7 @@ public: /// The approval for the resource objects selected. IfcApproval* RelatingApproval() const; void setRelatingApproval(IfcApproval* 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 IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcResourceObjectSelect; case 3: return Type::IfcApproval; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatedResourceObjects"; case 3: return "RelatingApproval"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcResourceApprovalRelationship (IfcAbstractEntity* e); IfcResourceApprovalRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcEntityList::ptr v3_RelatedResourceObjects, IfcApproval* v4_RelatingApproval); @@ -17865,13 +16146,7 @@ public: /// The properties to which a constraint is to be related. IfcEntityList::ptr RelatedResourceObjects() const; void setRelatedResourceObjects(IfcEntityList::ptr 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_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcResourceLevelRelationship::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 2: return Type::IfcConstraint; case 3: return Type::IfcResourceObjectSelect; } return IfcResourceLevelRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 2: return "RelatingConstraint"; case 3: return "RelatedResourceObjects"; } return IfcResourceLevelRelationship::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcResourceConstraintRelationship (IfcAbstractEntity* e); IfcResourceConstraintRelationship (boost::optional< std::string > v1_Name, boost::optional< std::string > v2_Description, IfcConstraint* v3_RelatingConstraint, IfcEntityList::ptr v4_RelatedResourceObjects); @@ -17956,13 +16231,7 @@ public: /// Indicates the percent completion of this resource. If the resource is assigned to a task, then indicates completion of the task on behalf of the resource; if the resource is partitioned into sub-allocations, then indicates overall completion of sub-allocations. double Completion() const; void setCompletion(double v); - virtual unsigned int getArgumentCount() const { return 18; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_DOUBLE; 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_BOOL; case 10: return IfcUtil::Argument_STRING; case 11: return IfcUtil::Argument_STRING; case 12: return IfcUtil::Argument_DOUBLE; case 13: return IfcUtil::Argument_STRING; case 14: return IfcUtil::Argument_STRING; case 15: return IfcUtil::Argument_STRING; case 16: return IfcUtil::Argument_DOUBLE; case 17: return IfcUtil::Argument_DOUBLE; } return IfcSchedulingTime::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcDuration; case 4: return Type::IfcPositiveRatioMeasure; case 5: return Type::IfcDateTime; case 6: return Type::IfcDateTime; case 7: return Type::IfcLabel; case 8: return Type::IfcDuration; case 9: return Type::UNDEFINED; case 10: return Type::IfcDateTime; case 11: return Type::IfcDuration; case 12: return Type::IfcPositiveRatioMeasure; case 13: return Type::IfcDateTime; case 14: return Type::IfcDateTime; case 15: return Type::IfcDuration; case 16: return Type::IfcPositiveRatioMeasure; case 17: return Type::IfcPositiveRatioMeasure; } return IfcSchedulingTime::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ScheduleWork"; case 4: return "ScheduleUsage"; case 5: return "ScheduleStart"; case 6: return "ScheduleFinish"; case 7: return "ScheduleContour"; case 8: return "LevelingDelay"; case 9: return "IsOverAllocated"; case 10: return "StatusTime"; case 11: return "ActualWork"; case 12: return "ActualUsage"; case 13: return "ActualStart"; case 14: return "ActualFinish"; case 15: return "RemainingWork"; case 16: return "RemainingUsage"; case 17: return "Completion"; } return IfcSchedulingTime::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcResourceTime (IfcAbstractEntity* e); IfcResourceTime (boost::optional< std::string > v1_Name, boost::optional< IfcDataOriginEnum::IfcDataOriginEnum > v2_DataOrigin, boost::optional< std::string > v3_UserDefinedDataOrigin, boost::optional< std::string > v4_ScheduleWork, boost::optional< double > v5_ScheduleUsage, boost::optional< std::string > v6_ScheduleStart, boost::optional< std::string > v7_ScheduleFinish, boost::optional< std::string > v8_ScheduleContour, boost::optional< std::string > v9_LevelingDelay, boost::optional< bool > v10_IsOverAllocated, boost::optional< std::string > v11_StatusTime, boost::optional< std::string > v12_ActualWork, boost::optional< double > v13_ActualUsage, boost::optional< std::string > v14_ActualStart, boost::optional< std::string > v15_ActualFinish, boost::optional< std::string > v16_RemainingWork, boost::optional< double > v17_RemainingUsage, boost::optional< double > v18_Completion); @@ -18010,13 +16279,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); @@ -18040,13 +16303,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; } return IfcPreDefinedProperties::getArgumentType(i); } - 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; } return IfcPreDefinedProperties::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SectionType"; case 1: return "StartProfile"; case 2: return "EndProfile"; } return IfcPreDefinedProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -18081,13 +16338,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; } return IfcPreDefinedProperties::getArgumentType(i); } - 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; } return IfcPreDefinedProperties::getArgumentEntity(i); } - 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"; } return IfcPreDefinedProperties::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -18157,13 +16408,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); @@ -18185,13 +16430,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); @@ -18202,13 +16441,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); @@ -18240,13 +16473,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); @@ -18259,13 +16486,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 (); @@ -18308,13 +16529,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); @@ -18342,13 +16557,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); @@ -18391,13 +16600,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); @@ -18413,13 +16616,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); @@ -18463,13 +16660,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); @@ -18490,13 +16681,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); @@ -18517,13 +16702,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); @@ -18541,13 +16720,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 (); @@ -18649,13 +16822,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); @@ -18689,13 +16856,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); @@ -18781,13 +16942,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, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam); @@ -18810,13 +16965,7 @@ public: /// The fillet that is equally applied to all transitions between the segments of the IfcPolyline, providing the geometric representation for the Directrix. If omited, no fillet is applied to the segments. double FilletRadius() const; void setFilletRadius(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 IfcSweptDiskSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcPositiveLengthMeasure; } return IfcSweptDiskSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "FilletRadius"; } return IfcSweptDiskSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSweptDiskSolidPolygonal (IfcAbstractEntity* e); IfcSweptDiskSolidPolygonal (IfcCurve* v1_Directrix, double v2_Radius, boost::optional< double > v3_InnerRadius, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, boost::optional< double > v6_FilletRadius); @@ -18837,13 +16986,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); @@ -18916,13 +17059,7 @@ public: /// Slope of web of the profile. double FlangeSlope() const; void setFlangeSlope(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::IfcNonNegativeLengthMeasure; case 8: return Type::IfcNonNegativeLengthMeasure; case 9: return Type::IfcNonNegativeLengthMeasure; case 10: return Type::IfcPlaneAngleMeasure; case 11: return Type::IfcPlaneAngleMeasure; } 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"; } 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); @@ -18931,13 +17068,7 @@ public: class IfcTessellatedItem : 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(); IfcTessellatedItem (IfcAbstractEntity* e); IfcTessellatedItem (); @@ -18965,13 +17096,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); @@ -18994,13 +17119,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); @@ -19097,13 +17216,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, 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); @@ -19161,13 +17274,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); @@ -19224,14 +17331,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::IfcIdentifier; 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 Types() const; // INVERSE IfcRelDefinesByType::RelatingType - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelDefinesByType >::ptr Types() 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); @@ -19284,14 +17385,8 @@ public: /// The type denotes a particular type that indicates the process 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 ProcessType() const; void setProcessType(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_STRING; case 8: return IfcUtil::Argument_STRING; } return IfcTypeObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcIdentifier; case 7: return Type::IfcText; case 8: return Type::IfcLabel; } return IfcTypeObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "Identification"; case 7: return "LongDescription"; case 8: return "ProcessType"; } return IfcTypeObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelAssignsToProcess >::ptr OperatesOn() const; // INVERSE IfcRelAssignsToProcess::RelatingProcess - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelAssignsToProcess >::ptr OperatesOn() const; // INVERSE IfcRelAssignsToProcess::RelatingProcess + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTypeProcess (IfcAbstractEntity* e); IfcTypeProcess (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType); @@ -19375,14 +17470,8 @@ 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); } - 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(); 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); @@ -19419,14 +17508,8 @@ public: /// The type denotes a particular type that indicates the resource 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 ResourceType() const; void setResourceType(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_STRING; case 8: return IfcUtil::Argument_STRING; } return IfcTypeObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcIdentifier; case 7: return Type::IfcText; case 8: return Type::IfcLabel; } return IfcTypeObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "Identification"; case 7: return "LongDescription"; case 8: return "ResourceType"; } return IfcTypeObject::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(); IfcTypeResource (IfcAbstractEntity* e); IfcTypeResource (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType); @@ -19489,13 +17572,7 @@ public: /// Slope of flange of the profile. double FlangeSlope() const; void setFlangeSlope(double v); - virtual unsigned int getArgumentCount() const { return 10; } - 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; } 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::IfcNonNegativeLengthMeasure; case 8: return Type::IfcNonNegativeLengthMeasure; case 9: return Type::IfcPlaneAngleMeasure; } 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"; } 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); @@ -19516,13 +17593,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); @@ -19545,13 +17616,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); @@ -19589,13 +17654,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); @@ -19650,13 +17709,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::IfcNonNegativeLengthMeasure; case 8: return Type::IfcNonNegativeLengthMeasure; } 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); @@ -19677,13 +17730,7 @@ public: /// HISTORY  New entity in IFC2x4 class IfcAdvancedFace : public IfcFaceSurface { public: - virtual unsigned int getArgumentCount() const { return 3; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcFaceSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcFaceSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcFaceSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAdvancedFace (IfcAbstractEntity* e); IfcAdvancedFace (IfcTemplatedEntityList< IfcFaceBound >::ptr v1_Bounds, IfcSurface* v2_FaceSurface, bool v3_SameSense); @@ -19723,13 +17770,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); @@ -19815,13 +17856,7 @@ public: bool hasTopFlangeSlope() const; double TopFlangeSlope() const; void setTopFlangeSlope(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::IfcNonNegativeLengthMeasure; case 8: return Type::IfcPositiveLengthMeasure; case 9: return Type::IfcPositiveLengthMeasure; case 10: return Type::IfcNonNegativeLengthMeasure; case 11: return Type::IfcNonNegativeLengthMeasure; case 12: return Type::IfcPlaneAngleMeasure; case 13: return Type::IfcNonNegativeLengthMeasure; case 14: return Type::IfcPlaneAngleMeasure; } return IfcParameterizedProfileDef::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "BottomFlangeWidth"; case 4: return "OverallDepth"; case 5: return "WebThickness"; case 6: return "BottomFlangeThickness"; case 7: return "BottomFlangeFilletRadius"; case 8: return "TopFlangeWidth"; case 9: return "TopFlangeThickness"; case 10: return "TopFlangeFilletRadius"; case 11: return "BottomFlangeEdgeRadius"; case 12: return "BottomFlangeSlope"; case 13: return "TopFlangeEdgeRadius"; case 14: return "TopFlangeSlope"; } 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(); IfcAsymmetricIShapeProfileDef (IfcAbstractEntity* e); IfcAsymmetricIShapeProfileDef (IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_BottomFlangeWidth, double v5_OverallDepth, double v6_WebThickness, double v7_BottomFlangeThickness, boost::optional< double > v8_BottomFlangeFilletRadius, double v9_TopFlangeWidth, boost::optional< double > v10_TopFlangeThickness, boost::optional< double > v11_TopFlangeFilletRadius, boost::optional< double > v12_BottomFlangeEdgeRadius, boost::optional< double > v13_BottomFlangeSlope, boost::optional< double > v14_TopFlangeEdgeRadius, boost::optional< double > v15_TopFlangeSlope); @@ -19843,13 +17878,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); @@ -19873,13 +17902,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); @@ -19910,13 +17933,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); @@ -19959,13 +17976,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); @@ -19985,13 +17996,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 (); @@ -20033,13 +18038,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); @@ -20080,13 +18079,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); @@ -20133,13 +18126,7 @@ public: /// Internal fillet radius according the above illustration (= r1). double InternalFilletRadius() const; void setInternalFilletRadius(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::IfcNonNegativeLengthMeasure; } 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"; } 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); @@ -20157,13 +18144,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); @@ -20172,13 +18153,7 @@ public: class IfcCartesianPointList : 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(); IfcCartesianPointList (IfcAbstractEntity* e); IfcCartesianPointList (); @@ -20189,13 +18164,7 @@ class IfcCartesianPointList3D : public IfcCartesianPointList { public: std::vector< std::vector< double > > CoordList() const; void setCoordList(std::vector< std::vector< double > > 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_AGGREGATE_OF_DOUBLE; } return IfcCartesianPointList::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; } return IfcCartesianPointList::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "CoordList"; } return IfcCartesianPointList::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCartesianPointList3D (IfcAbstractEntity* e); IfcCartesianPointList3D (std::vector< std::vector< double > > v1_CoordList); @@ -20251,13 +18220,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); @@ -20270,13 +18233,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); @@ -20299,13 +18256,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); @@ -20323,13 +18274,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); @@ -20358,13 +18303,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); @@ -20387,13 +18326,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); @@ -20450,13 +18383,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); @@ -20487,13 +18414,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); @@ -20513,13 +18434,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); @@ -20545,14 +18460,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); @@ -20583,13 +18492,7 @@ public: bool hasBaseQuantity() const; IfcPhysicalQuantity* BaseQuantity() const; void setBaseQuantity(IfcPhysicalQuantity* 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_ENTITY_INSTANCE; } return IfcTypeResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAppliedValue; case 10: return Type::IfcPhysicalQuantity; } return IfcTypeResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "BaseCosts"; case 10: return "BaseQuantity"; } return IfcTypeResource::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionResourceType (IfcAbstractEntity* e); IfcConstructionResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity); @@ -20639,15 +18542,9 @@ public: /// IFC2x4 CHANGE  The attribute has been changed to be optional. Change made with upward compatibility for file based exchange. 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 4: return IfcUtil::Argument_STRING; 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 IfcObjectDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcLabel; case 7: return Type::IfcRepresentationContext; case 8: return Type::IfcUnitAssignment; } return IfcObjectDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "ObjectType"; case 5: return "LongName"; case 6: return "Phase"; case 7: return "RepresentationContexts"; case 8: return "UnitsInContext"; } return IfcObjectDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelDefinesByProperties >::ptr IsDefinedBy() const; // INVERSE IfcRelDefinesByProperties::RelatedObjects + IfcTemplatedEntityList< IfcRelDefinesByProperties >::ptr IsDefinedBy() const; // INVERSE IfcRelDefinesByProperties::RelatedObjects IfcTemplatedEntityList< IfcRelDeclares >::ptr Declares() const; // INVERSE IfcRelDeclares::RelatingContext - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcContext (IfcAbstractEntity* e); IfcContext (std::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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext); @@ -20668,13 +18565,7 @@ public: /// Defines types of crew resources. IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum 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 IfcConstructionResourceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcCrewResourceTypeEnum; } return IfcConstructionResourceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "PredefinedType"; } return IfcConstructionResourceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCrewResourceType (IfcAbstractEntity* e); IfcCrewResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v12_PredefinedType); @@ -20690,13 +18581,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); @@ -20748,13 +18633,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); @@ -20772,13 +18651,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 (); @@ -20808,13 +18681,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); @@ -20851,13 +18718,7 @@ public: void setBoundaries(IfcTemplatedEntityList< IfcBoundaryCurve >::ptr v); bool ImplicitOuter() const; void setImplicitOuter(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_AGGREGATE_OF_ENTITY_INSTANCE; case 2: 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::IfcBoundaryCurve; case 2: return Type::UNDEFINED; } return IfcBoundedSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisSurface"; case 1: return "Boundaries"; case 2: return "ImplicitOuter"; } 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(); IfcCurveBoundedSurface (IfcAbstractEntity* e); IfcCurveBoundedSurface (IfcSurface* v1_BasisSurface, IfcTemplatedEntityList< IfcBoundaryCurve >::ptr v2_Boundaries, bool v3_ImplicitOuter); @@ -20875,13 +18736,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); @@ -20927,13 +18782,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); @@ -20955,13 +18804,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); @@ -21056,13 +18899,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 IfcQuantitySet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcPhysicalQuantity; } return IfcQuantitySet::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "MethodOfMeasurement"; case 5: return "Quantities"; } return IfcQuantitySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -21097,13 +18934,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); @@ -21119,13 +18950,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); @@ -21155,13 +18980,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); @@ -21190,13 +19009,7 @@ public: /// declared as USERDEFINED. std::string UserDefinedEventTriggerType() const; void setUserDefinedEventTriggerType(std::string v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_ENUMERATION; case 11: return IfcUtil::Argument_STRING; } return IfcTypeProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcEventTypeEnum; case 10: return Type::IfcEventTriggerTypeEnum; case 11: return Type::IfcLabel; } return IfcTypeProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "EventTriggerType"; case 11: return "UserDefinedEventTriggerType"; } return IfcTypeProcess::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEventType (IfcAbstractEntity* e); IfcEventType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcEventTypeEnum::IfcEventTypeEnum v10_PredefinedType, IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum v11_EventTriggerType, boost::optional< std::string > v12_UserDefinedEventTriggerType); @@ -21279,13 +19092,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); @@ -21394,13 +19201,7 @@ public: /// The surface defining the end of the swept area. It is given as a profile definition. The position coordinate system of the EndSwptArea is generated by translating the SELF\IfcSweptAreaSolid.Position along the SELF\IfcExtrudedAreaSolid.ExtrudedDirection by the distance of SELF\IfcExtrudedAreaSolid.Depth. IfcProfileDef* EndSweptArea() const; void setEndSweptArea(IfcProfileDef* 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 IfcExtrudedAreaSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcProfileDef; } return IfcExtrudedAreaSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "EndSweptArea"; } return IfcExtrudedAreaSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExtrudedAreaSolidTapered (IfcAbstractEntity* e); IfcExtrudedAreaSolidTapered (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcDirection* v3_ExtrudedDirection, double v4_Depth, IfcProfileDef* v5_EndSweptArea); @@ -21423,13 +19224,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); @@ -21511,13 +19306,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); @@ -21539,13 +19328,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_AGGREGATE_OF_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::IfcVector; case 1: return Type::IfcStyledItem; 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 (IfcTemplatedEntityList< IfcVector >::ptr v1_TilingPattern, IfcTemplatedEntityList< IfcStyledItem >::ptr v2_Tiles, double v3_TilingScale); @@ -21627,13 +19410,7 @@ public: /// The direction providing the fixed axis1 (x-axis) direction for orienting the swept area during the sweeping operation along the Directrix. IfcDirection* FixedReference() const; void setFixedReference(IfcDirection* 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::IfcDirection; } 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 "FixedReference"; } 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(); IfcFixedReferenceSweptAreaSolid (IfcAbstractEntity* e); IfcFixedReferenceSweptAreaSolid (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcCurve* v3_Directrix, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, IfcDirection* v6_FixedReference); @@ -21669,13 +19446,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); @@ -21727,13 +19498,7 @@ public: bool hasPredefinedType() const; IfcFurnitureTypeEnum::IfcFurnitureTypeEnum PredefinedType() const; void setPredefinedType(IfcFurnitureTypeEnum::IfcFurnitureTypeEnum 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_ENUMERATION; } return IfcFurnishingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcAssemblyPlaceEnum; case 10: return Type::IfcFurnitureTypeEnum; } return IfcFurnishingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "AssemblyPlace"; case 10: return "PredefinedType"; } 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, boost::optional< IfcFurnitureTypeEnum::IfcFurnitureTypeEnum > v11_PredefinedType); @@ -21805,13 +19570,7 @@ public: /// Predefined types to define the particular type of the geographic element. There may be property set definitions available for each predefined type. IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum PredefinedType() const; void setPredefinedType(IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum 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::IfcGeographicElementTypeEnum; } 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(); IfcGeographicElementType (IfcAbstractEntity* e); IfcGeographicElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum v10_PredefinedType); @@ -21826,13 +19585,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); @@ -21928,13 +19681,7 @@ public: bool hasFlangeSlope() const; double FlangeSlope() const; void setFlangeSlope(double v); - virtual unsigned int getArgumentCount() const { return 10; } - 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; } 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::IfcNonNegativeLengthMeasure; case 8: return Type::IfcNonNegativeLengthMeasure; case 9: return Type::IfcPlaneAngleMeasure; } 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"; case 8: return "FlangeEdgeRadius"; case 9: return "FlangeSlope"; } 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, boost::optional< double > v9_FlangeEdgeRadius, boost::optional< double > v10_FlangeSlope); @@ -22019,13 +19766,7 @@ public: /// Slope of the inner face of each leg of the profile. double LegSlope() const; void setLegSlope(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::IfcNonNegativeLengthMeasure; case 7: return Type::IfcNonNegativeLengthMeasure; case 8: return Type::IfcPlaneAngleMeasure; } 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"; } 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); @@ -22047,13 +19788,7 @@ public: /// Defines types of labor resources. IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum 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 IfcConstructionResourceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcLaborResourceTypeEnum; } return IfcConstructionResourceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "PredefinedType"; } return IfcConstructionResourceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLaborResourceType (IfcAbstractEntity* e); IfcLaborResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v12_PredefinedType); @@ -22080,13 +19815,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); @@ -22160,13 +19889,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); @@ -22261,17 +19984,11 @@ 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< IfcRelDefinesByObject >::ptr IsDeclaredBy() const; // INVERSE IfcRelDefinesByObject::RelatedObjects + IfcTemplatedEntityList< IfcRelDefinesByObject >::ptr IsDeclaredBy() const; // INVERSE IfcRelDefinesByObject::RelatedObjects IfcTemplatedEntityList< IfcRelDefinesByObject >::ptr Declares() const; // INVERSE IfcRelDefinesByObject::RelatingObject IfcTemplatedEntityList< IfcRelDefinesByType >::ptr IsTypedBy() const; // INVERSE IfcRelDefinesByType::RelatedObjects IfcTemplatedEntityList< IfcRelDefinesByProperties >::ptr IsDefinedBy() const; // INVERSE IfcRelDefinesByProperties::RelatedObjects - bool is(Type::Enum v) const; - Type::Enum type() const; + 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); @@ -22299,13 +20016,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); @@ -22340,13 +20051,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); @@ -22359,13 +20064,7 @@ public: void setBasisSurface(IfcSurface* v); IfcCurve* ReferenceCurve() const; void setReferenceCurve(IfcCurve* 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::IfcSurface; case 1: return Type::IfcCurve; } return IfcCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "BasisSurface"; case 1: return "ReferenceCurve"; } 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(); IfcPcurve (IfcAbstractEntity* e); IfcPcurve (IfcSurface* v1_BasisSurface, IfcCurve* v2_ReferenceCurve); @@ -22383,13 +20082,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); @@ -22433,13 +20126,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); @@ -22452,13 +20139,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); @@ -22473,13 +20154,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); @@ -22507,13 +20182,7 @@ public: /// DefinesType. class IfcPreDefinedPropertySet : public IfcPropertySetDefinition { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPropertySetDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPropertySetDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { 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(); IfcPreDefinedPropertySet (IfcAbstractEntity* e); IfcPreDefinedPropertySet (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -22538,13 +20207,7 @@ public: /// the type required may be set. IfcProcedureTypeEnum::IfcProcedureTypeEnum PredefinedType() const; void setPredefinedType(IfcProcedureTypeEnum::IfcProcedureTypeEnum 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 IfcTypeProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcProcedureTypeEnum; } return IfcTypeProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcTypeProcess::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProcedureType (IfcAbstractEntity* e); IfcProcedureType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcProcedureTypeEnum::IfcProcedureTypeEnum v10_PredefinedType); @@ -22607,16 +20270,10 @@ public: /// IFC2x4 CHANGE  New attribute. std::string LongDescription() const; void setLongDescription(std::string 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_STRING; } return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcText; } return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Identification"; case 6: return "LongDescription"; } return IfcObject::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelSequence >::ptr IsPredecessorTo() const; // INVERSE IfcRelSequence::RelatingProcess + IfcTemplatedEntityList< IfcRelSequence >::ptr IsPredecessorTo() const; // INVERSE IfcRelSequence::RelatingProcess IfcTemplatedEntityList< IfcRelSequence >::ptr IsSuccessorFrom() const; // INVERSE IfcRelSequence::RelatedProcess IfcTemplatedEntityList< IfcRelAssignsToProcess >::ptr OperatesOn() const; // INVERSE IfcRelAssignsToProcess::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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription); @@ -22725,14 +20382,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); @@ -22784,13 +20435,7 @@ public: /// There shall only be one project within the exchange context. This is enforced by the global rule IfcSingleProjectInstance. class IfcProject : public IfcContext { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcContext::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcContext::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcContext::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext); @@ -22822,13 +20467,7 @@ public: /// An IfcProjectLibrary may be decomposed into sub libraries using the relationship IfcRelNests. Sub libraries are accessed by the IfcProjectLibrary through the inverse attribute IsNestedBy. class IfcProjectLibrary : public IfcContext { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcContext::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcContext::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcContext::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProjectLibrary (IfcAbstractEntity* e); IfcProjectLibrary (std::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, boost::optional< IfcTemplatedEntityList< IfcRepresentationContext >::ptr > v8_RepresentationContexts, IfcUnitAssignment* v9_UnitsInContext); @@ -22962,13 +20601,7 @@ public: /// IFC2x4 CHANGE  The attribute has been added at the end of the attribute list. IfcValue* SetPointValue() const; void setSetPointValue(IfcValue* 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_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: 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; case 5: return Type::IfcValue; } 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"; case 5: return "SetPointValue"; } 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, IfcValue* v6_SetPointValue); @@ -23065,13 +20698,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, boost::optional< IfcEntityList::ptr > v3_EnumerationValues, IfcPropertyEnumeration* v4_EnumerationReference); @@ -23156,13 +20783,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, boost::optional< IfcEntityList::ptr > v3_ListValues, IfcUnit* v4_Unit); @@ -23197,13 +20818,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::IfcText; 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); @@ -23267,13 +20882,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); @@ -23335,14 +20944,8 @@ public: /// Set of IfcPropertyTemplate's that are defined within the scope of the IfcPropertySetTemplate. IfcTemplatedEntityList< IfcPropertyTemplate >::ptr HasPropertyTemplates() const; void setHasPropertyTemplates(IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPropertyTemplateDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPropertySetTemplateTypeEnum; case 5: return Type::IfcIdentifier; case 6: return Type::IfcPropertyTemplate; } return IfcPropertyTemplateDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "TemplateType"; case 5: return "ApplicableEntity"; case 6: return "HasPropertyTemplates"; } return IfcPropertyTemplateDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelDefinesByTemplate >::ptr Defines() const; // INVERSE IfcRelDefinesByTemplate::RelatingTemplate - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelDefinesByTemplate >::ptr Defines() const; // INVERSE IfcRelDefinesByTemplate::RelatingTemplate + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertySetTemplate (IfcAbstractEntity* e); IfcPropertySetTemplate (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcPropertySetTemplateTypeEnum::IfcPropertySetTemplateTypeEnum > v5_TemplateType, boost::optional< std::string > v6_ApplicableEntity, IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v7_HasPropertyTemplates); @@ -23408,13 +21011,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); @@ -23604,13 +21201,7 @@ public: /// IFC2x4 CHANGE  The attribute has been added at the end of the attribute list. IfcCurveInterpolationEnum::IfcCurveInterpolationEnum CurveInterpolation() const; void setCurveInterpolation(IfcCurveInterpolationEnum::IfcCurveInterpolationEnum v); - virtual unsigned int getArgumentCount() const { return 8; } - 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; case 7: return IfcUtil::Argument_ENUMERATION; } 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; case 7: return Type::IfcCurveInterpolationEnum; } 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"; case 7: return "CurveInterpolation"; } 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, boost::optional< IfcEntityList::ptr > v3_DefiningValues, boost::optional< IfcEntityList::ptr > v4_DefinedValues, boost::optional< std::string > v5_Expression, IfcUnit* v6_DefiningUnit, IfcUnit* v7_DefinedUnit, boost::optional< IfcCurveInterpolationEnum::IfcCurveInterpolationEnum > v8_CurveInterpolation); @@ -23642,15 +21233,9 @@ public: /// HISTORY New Entity in IFC2x4. class IfcPropertyTemplate : public IfcPropertyTemplateDefinition { public: - virtual unsigned int getArgumentCount() const { return 4; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPropertyTemplateDefinition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPropertyTemplateDefinition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPropertyTemplateDefinition::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcComplexPropertyTemplate >::ptr PartOfComplexTemplate() const; // INVERSE IfcComplexPropertyTemplate::HasPropertyTemplates + IfcTemplatedEntityList< IfcComplexPropertyTemplate >::ptr PartOfComplexTemplate() const; // INVERSE IfcComplexPropertyTemplate::HasPropertyTemplates IfcTemplatedEntityList< IfcPropertySetTemplate >::ptr PartOfPsetTemplate() const; // INVERSE IfcPropertySetTemplate::HasPropertyTemplates - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPropertyTemplate (IfcAbstractEntity* e); IfcPropertyTemplate (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -23682,13 +21267,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); @@ -23729,13 +21308,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::IfcNonNegativeLengthMeasure; case 7: return Type::IfcNonNegativeLengthMeasure; } 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); @@ -23840,13 +21413,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); @@ -23890,13 +21457,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); @@ -23938,13 +21499,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 IfcPreDefinedPropertySet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcSectionReinforcementProperties; } return IfcPreDefinedPropertySet::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "DefinitionType"; case 5: return "ReinforcementSectionDefinitions"; } return IfcPreDefinedPropertySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -23972,13 +21527,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); @@ -24003,13 +21552,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); @@ -24025,13 +21568,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); @@ -24055,13 +21592,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); @@ -24081,13 +21612,7 @@ public: /// Factor provided as a ratio measure that identifies the fraction or weighted factor that applies to the group assignment. double Factor() const; void setFactor(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 IfcRelAssignsToGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcRatioMeasure; } return IfcRelAssignsToGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "Factor"; } return IfcRelAssignsToGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelAssignsToGroupByFactor (IfcAbstractEntity* e); IfcRelAssignsToGroupByFactor (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, double v8_Factor); @@ -24127,13 +21652,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::IfcProcessSelect; 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, IfcProcessSelect* v7_RelatingProcess, IfcMeasureWithUnit* v8_QuantityInProcess); @@ -24154,13 +21673,7 @@ public: /// IFC2x4 CHANGE Datatype expanded to include IfcProduct and IfcTypeProduct. IfcProductSelect* RelatingProduct() const; void setRelatingProduct(IfcProductSelect* 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::IfcProductSelect; } 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, IfcProductSelect* v7_RelatingProduct); @@ -24179,13 +21692,7 @@ public: /// IFC2x4 CHANGE Datatype expanded to include IfcResource and IfcTypeResource. IfcResourceSelect* RelatingResource() const; void setRelatingResource(IfcResourceSelect* 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::IfcResourceSelect; } 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, IfcResourceSelect* v7_RelatingResource); @@ -24239,13 +21746,7 @@ public: /// IFC2x4 CHANGE  The attribute datatype has been changed from IfcRoot to IfcDefinitionSelect. IfcEntityList::ptr RelatedObjects() const; void setRelatedObjects(IfcEntityList::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::IfcDefinitionSelect; } 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, IfcEntityList::ptr v5_RelatedObjects); @@ -24259,13 +21760,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, IfcEntityList::ptr v5_RelatedObjects, IfcApproval* v6_RelatingApproval); @@ -24306,13 +21801,7 @@ public: /// Classification applied to the objects. IfcClassificationSelect* RelatingClassification() const; void setRelatingClassification(IfcClassificationSelect* 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::IfcClassificationSelect; } 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, IfcEntityList::ptr v5_RelatedObjects, IfcClassificationSelect* v6_RelatingClassification); @@ -24331,13 +21820,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, IfcEntityList::ptr v5_RelatedObjects, boost::optional< std::string > v6_Intent, IfcConstraint* v7_RelatingConstraint); @@ -24355,13 +21838,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, IfcEntityList::ptr v5_RelatedObjects, IfcDocumentSelect* v6_RelatingDocument); @@ -24379,13 +21856,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, IfcEntityList::ptr v5_RelatedObjects, IfcLibrarySelect* v6_RelatingLibrary); @@ -24490,13 +21961,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, IfcEntityList::ptr v5_RelatedObjects, IfcMaterialSelect* v6_RelatingMaterial); @@ -24507,13 +21972,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); @@ -24554,13 +22013,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); @@ -24612,13 +22065,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_DOUBLE; case 8: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; 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< double > /*[0:?]*/ v8_RelatingPriorities, std::vector< double > /*[0:?]*/ v9_RelatedPriorities, IfcConnectionTypeEnum::IfcConnectionTypeEnum v10_RelatedConnectionType, IfcConnectionTypeEnum::IfcConnectionTypeEnum v11_RelatingConnectionType); @@ -24659,13 +22106,7 @@ public: /// IFC2x4 CHANGE Data type extended to IfcObjectDefinition to enable elements and element types for the port relationship. IfcDistributionElement* RelatedElement() const; void setRelatedElement(IfcDistributionElement* 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::IfcDistributionElement; } 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, IfcDistributionElement* v6_RelatedElement); @@ -24697,13 +22138,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); @@ -24720,13 +22155,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); @@ -24784,13 +22213,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); @@ -24818,13 +22241,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); @@ -24863,13 +22280,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); @@ -24947,13 +22358,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. IfcSpatialElement* RelatingStructure() const; void setRelatingStructure(IfcSpatialElement* 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::IfcSpatialElement; } 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, IfcSpatialElement* v6_RelatingStructure); @@ -24985,13 +22390,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); @@ -25033,13 +22432,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 "RelatingSpace"; 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_RelatingSpace, IfcTemplatedEntityList< IfcCovering >::ptr v6_RelatedCoverings); @@ -25064,13 +22457,7 @@ public: /// Set of object or property definitions that are assigned to a context and to which the unit and representation context definitions of that context apply. IfcEntityList::ptr RelatedDefinitions() const; void setRelatedDefinitions(IfcEntityList::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::IfcContext; case 5: return Type::IfcDefinitionSelect; } return IfcRelationship::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingContext"; case 5: return "RelatedDefinitions"; } 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(); IfcRelDeclares (IfcAbstractEntity* e); IfcRelDeclares (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcContext* v5_RelatingContext, IfcEntityList::ptr v6_RelatedDefinitions); @@ -25108,13 +22495,7 @@ public: /// IFC2x4 CHANGE The differentiation between the aggregation and nesting is determined to be a non-ordered or an ordered collection of parts. The attributes RelatingObject and RelatedObjects have been demoted to the subtypes. class IfcRelDecomposes : 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(); IfcRelDecomposes (IfcAbstractEntity* e); IfcRelDecomposes (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -25149,13 +22530,7 @@ public: /// IfcRelDefinesByType. class IfcRelDefines : 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(); IfcRelDefines (IfcAbstractEntity* e); IfcRelDefines (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description); @@ -25184,13 +22559,7 @@ public: /// Object being part of an object type decomposition, acting as the "declaring part" in the relationship. IfcObject* RelatingObject() const; void setRelatingObject(IfcObject* 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 IfcRelDefines::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObject; case 5: return Type::IfcObject; } return IfcRelDefines::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedObjects"; case 5: return "RelatingObject"; } 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(); IfcRelDefinesByObject (IfcAbstractEntity* e); IfcRelDefinesByObject (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcObject >::ptr v5_RelatedObjects, IfcObject* v6_RelatingObject); @@ -25219,13 +22588,7 @@ public: /// Reference to the property set definition for that object or set of objects. IfcPropertySetDefinitionSelect* RelatingPropertyDefinition() const; void setRelatingPropertyDefinition(IfcPropertySetDefinitionSelect* 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 IfcRelDefines::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObjectDefinition; case 5: return Type::IfcPropertySetDefinitionSelect; } return IfcRelDefines::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedObjects"; 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< IfcObjectDefinition >::ptr v5_RelatedObjects, IfcPropertySetDefinitionSelect* v6_RelatingPropertyDefinition); @@ -25251,13 +22614,7 @@ public: /// Property set template that provides the common definition of related property sets. IfcPropertySetTemplate* RelatingTemplate() const; void setRelatingTemplate(IfcPropertySetTemplate* 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 IfcRelDefines::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPropertySetDefinition; case 5: return Type::IfcPropertySetTemplate; } return IfcRelDefines::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedPropertySets"; case 5: return "RelatingTemplate"; } 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(); IfcRelDefinesByTemplate (IfcAbstractEntity* e); IfcRelDefinesByTemplate (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr v5_RelatedPropertySets, IfcPropertySetTemplate* v6_RelatingTemplate); @@ -25341,13 +22698,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 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelDefines::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObject; case 5: return Type::IfcTypeObject; } return IfcRelDefines::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatedObjects"; 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); @@ -25372,13 +22723,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); @@ -25399,13 +22744,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); @@ -25479,13 +22818,7 @@ public: /// Logical value indicating whether the interference geometry should be subtracted from the RelatingElement (if TRUE), or whether it should be either subtracted from the RelatingElement or the RelatedElement (if FALSE), or whether no indication can be provided (if UNKNOWN). bool ImpliedOrder() const; void setImpliedOrder(bool 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_STRING; case 8: return IfcUtil::Argument_BOOL; } return IfcRelConnects::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcElement; case 6: return Type::IfcConnectionGeometry; case 7: return Type::IfcIdentifier; case 8: return Type::UNDEFINED; } return IfcRelConnects::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingElement"; case 5: return "RelatedElement"; case 6: return "InterferenceGeometry"; case 7: return "InterferenceType"; case 8: return "ImpliedOrder"; } 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(); IfcRelInterferesElements (IfcAbstractEntity* e); IfcRelInterferesElements (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcElement* v5_RelatingElement, IfcElement* v6_RelatedElement, IfcConnectionGeometry* v7_InterferenceGeometry, boost::optional< std::string > v8_InterferenceType, bool v9_ImpliedOrder); @@ -25528,13 +22861,7 @@ public: /// IFC2x4 CHANGE  The attribute has been demoted from the supertype IfcRelDecomposes and defines the ordered set of parts within the nest. 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 IfcRelDecomposes::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObjectDefinition; case 5: return Type::IfcObjectDefinition; } return IfcRelDecomposes::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingObject"; case 5: return "RelatedObjects"; } 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); @@ -25580,13 +22907,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 IfcRelDecomposes::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcFeatureElementAddition; } return IfcRelDecomposes::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingElement"; case 5: return "RelatedFeatureElement"; } 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(); 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); @@ -25652,13 +22973,7 @@ public: /// IFC2x Edition 4 CHANGE  The attribute relatingStructure as been promoted to the new supertype IfcSpatialElement with upward compatibility for file based exchange. IfcSpatialElement* RelatingStructure() const; void setRelatingStructure(IfcSpatialElement* 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::IfcSpatialElement; } 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, IfcSpatialElement* v6_RelatingStructure); @@ -25751,13 +23066,7 @@ public: /// Added in IFC 2x4 std::string UserDefinedSequenceType() const; void setUserDefinedSequenceType(std::string 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_STRING; } 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::IfcLagTime; case 7: return Type::IfcSequenceEnum; case 8: return Type::IfcLabel; } 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"; case 8: return "UserDefinedSequenceType"; } 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, IfcLagTime* v7_TimeLag, boost::optional< IfcSequenceEnum::IfcSequenceEnum > v8_SequenceType, boost::optional< std::string > v9_UserDefinedSequenceType); @@ -25796,13 +23105,7 @@ public: /// IFC2x Edition 4 CHANGE  The data type has been changed from IfcSpatialStructureElement to IfcSpatialElement with upward compatibility for file based exchange. IfcTemplatedEntityList< IfcSpatialElement >::ptr RelatedBuildings() const; void setRelatedBuildings(IfcTemplatedEntityList< IfcSpatialElement >::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::IfcSpatialElement; } 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< IfcSpatialElement >::ptr v6_RelatedBuildings); @@ -25995,13 +23298,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::IfcSpaceBoundarySelect; 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, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary); @@ -26061,14 +23358,8 @@ public: /// Reference to the host, or parent, space boundary within which this inner boundary is defined. IfcRelSpaceBoundary1stLevel* ParentBoundary() const; void setParentBoundary(IfcRelSpaceBoundary1stLevel* v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcRelSpaceBoundary::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcRelSpaceBoundary1stLevel; } return IfcRelSpaceBoundary::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "ParentBoundary"; } return IfcRelSpaceBoundary::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelSpaceBoundary1stLevel >::ptr InnerBoundaries() const; // INVERSE IfcRelSpaceBoundary1stLevel::ParentBoundary - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelSpaceBoundary1stLevel >::ptr InnerBoundaries() const; // INVERSE IfcRelSpaceBoundary1stLevel::ParentBoundary + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelSpaceBoundary1stLevel (IfcAbstractEntity* e); IfcRelSpaceBoundary1stLevel (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary, IfcRelSpaceBoundary1stLevel* v10_ParentBoundary); @@ -26113,14 +23404,8 @@ public: /// Reference to the other space boundary of the pair of two space boundaries on either side of a space separating thermal boundary element. IfcRelSpaceBoundary2ndLevel* CorrespondingBoundary() const; void setCorrespondingBoundary(IfcRelSpaceBoundary2ndLevel* 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 IfcRelSpaceBoundary1stLevel::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcRelSpaceBoundary2ndLevel; } return IfcRelSpaceBoundary1stLevel::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "CorrespondingBoundary"; } return IfcRelSpaceBoundary1stLevel::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelSpaceBoundary2ndLevel >::ptr Corresponds() const; // INVERSE IfcRelSpaceBoundary2ndLevel::CorrespondingBoundary - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelSpaceBoundary2ndLevel >::ptr Corresponds() const; // INVERSE IfcRelSpaceBoundary2ndLevel::CorrespondingBoundary + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRelSpaceBoundary2ndLevel (IfcAbstractEntity* e); IfcRelSpaceBoundary2ndLevel (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, IfcSpaceBoundarySelect* v5_RelatingSpace, IfcElement* v6_RelatedBuildingElement, IfcConnectionGeometry* v7_ConnectionGeometry, IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum v8_PhysicalOrVirtualBoundary, IfcInternalOrExternalEnum::IfcInternalOrExternalEnum v9_InternalOrExternalBoundary, IfcRelSpaceBoundary1stLevel* v10_ParentBoundary, IfcRelSpaceBoundary2ndLevel* v11_CorrespondingBoundary); @@ -26139,13 +23424,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 IfcRelDecomposes::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcElement; case 5: return Type::IfcFeatureElementSubtraction; } return IfcRelDecomposes::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingBuildingElement"; case 5: return "RelatedOpeningElement"; } 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(); 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); @@ -26178,13 +23457,7 @@ class IfcReparametrisedCompositeCurveSegment : public IfcCompositeCurveSegment { public: double ParamLength() const; void setParamLength(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 IfcCompositeCurveSegment::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::IfcParameterValue; } return IfcCompositeCurveSegment::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "ParamLength"; } return IfcCompositeCurveSegment::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReparametrisedCompositeCurveSegment (IfcAbstractEntity* e); IfcReparametrisedCompositeCurveSegment (IfcTransitionCode::IfcTransitionCode v1_Transition, bool v2_SameSense, IfcCurve* v3_ParentCurve, double v4_ParamLength); @@ -26220,14 +23493,8 @@ public: /// IFC2x4 NOTE:  The attribute LongDescription is added replacing the ResourceGroup attribute at subtype IfcConstructionResource. std::string LongDescription() const; void setLongDescription(std::string 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_STRING; } return IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; case 6: return Type::IfcText; } return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Identification"; case 6: return "LongDescription"; } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription); @@ -26317,13 +23584,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); @@ -26391,13 +23652,7 @@ class IfcRevolvedAreaSolidTapered : public IfcRevolvedAreaSolid { public: IfcProfileDef* EndSweptArea() const; void setEndSweptArea(IfcProfileDef* 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 IfcRevolvedAreaSolid::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcProfileDef; } return IfcRevolvedAreaSolid::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "EndSweptArea"; } return IfcRevolvedAreaSolid::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRevolvedAreaSolidTapered (IfcAbstractEntity* e); IfcRevolvedAreaSolidTapered (IfcProfileDef* v1_SweptArea, IfcAxis2Placement3D* v2_Position, IfcAxis1Placement* v3_Axis, double v4_Angle, IfcProfileDef* v5_EndSweptArea); @@ -26476,13 +23731,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); @@ -26577,13 +23826,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); @@ -26699,13 +23942,7 @@ public: /// READONLYLOCKED: Properties of this template are locked and read-only. They may only be accessed by the owning application. IfcStateEnum::IfcStateEnum AccessState() const; void setAccessState(IfcStateEnum::IfcStateEnum v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_STRING; case 11: return IfcUtil::Argument_ENUMERATION; } return IfcPropertyTemplate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcSimplePropertyTemplateTypeEnum; case 5: return Type::IfcLabel; case 6: return Type::IfcLabel; case 7: return Type::IfcPropertyEnumeration; case 8: return Type::IfcUnit; case 9: return Type::IfcUnit; case 10: return Type::IfcLabel; case 11: return Type::IfcStateEnum; } return IfcPropertyTemplate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "TemplateType"; case 5: return "PrimaryMeasureType"; case 6: return "SecondaryMeasureType"; case 7: return "Enumerators"; case 8: return "PrimaryUnit"; case 9: return "SecondaryUnit"; case 10: return "Expression"; case 11: return "AccessState"; } return IfcPropertyTemplate::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSimplePropertyTemplate (IfcAbstractEntity* e); IfcSimplePropertyTemplate (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< IfcSimplePropertyTemplateTypeEnum::IfcSimplePropertyTemplateTypeEnum > v5_TemplateType, boost::optional< std::string > v6_PrimaryMeasureType, boost::optional< std::string > v7_SecondaryMeasureType, IfcPropertyEnumeration* v8_Enumerators, IfcUnit* v9_PrimaryUnit, IfcUnit* v10_SecondaryUnit, boost::optional< std::string > v11_Expression, boost::optional< IfcStateEnum::IfcStateEnum > v12_AccessState); @@ -26751,16 +23988,10 @@ public: /// NOTE In many scenarios the Name attribute refers to the short name or number of a spacial element, and the LongName refers to the full name. std::string LongName() const; void setLongName(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::IfcLabel; } return IfcProduct::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "LongName"; } return IfcProduct::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainsElements() const; // INVERSE IfcRelContainedInSpatialStructure::RelatingStructure + IfcTemplatedEntityList< IfcRelContainedInSpatialStructure >::ptr ContainsElements() const; // INVERSE IfcRelContainedInSpatialStructure::RelatingStructure IfcTemplatedEntityList< IfcRelServicesBuildings >::ptr ServicedBySystems() const; // INVERSE IfcRelServicesBuildings::RelatedBuildings IfcTemplatedEntityList< IfcRelReferencedInSpatialStructure >::ptr ReferencesElements() const; // INVERSE IfcRelReferencedInSpatialStructure::RelatingStructure - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpatialElement (IfcAbstractEntity* e); IfcSpatialElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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); @@ -26804,13 +24035,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(); IfcSpatialElementType (IfcAbstractEntity* e); IfcSpatialElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -26900,13 +24125,7 @@ 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 8: return IfcUtil::Argument_ENUMERATION; } return IfcSpatialElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElementCompositionEnum; } return IfcSpatialElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "CompositionType"; } return IfcSpatialElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - 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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType); @@ -26948,13 +24167,7 @@ public: /// Release IFC2x Edition 3. class IfcSpatialStructureElementType : public IfcSpatialElementType { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcSpatialElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcSpatialElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcSpatialElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -27016,13 +24229,7 @@ public: /// Predefined types to define the particular type of the spatial zone. There may be property set definitions available for each predefined type. IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum PredefinedType() const; void setPredefinedType(IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum 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 IfcSpatialElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSpatialZoneTypeEnum; } return IfcSpatialElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcSpatialElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpatialZone (IfcAbstractEntity* e); IfcSpatialZone (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum > v9_PredefinedType); @@ -27067,13 +24274,7 @@ public: bool hasLongName() const; std::string LongName() const; void setLongName(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_ENUMERATION; case 10: return IfcUtil::Argument_STRING; } return IfcSpatialElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSpatialZoneTypeEnum; case 10: return Type::IfcLabel; } return IfcSpatialElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "LongName"; } return IfcSpatialElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpatialZoneType (IfcAbstractEntity* e); IfcSpatialZoneType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSpatialZoneTypeEnum::IfcSpatialZoneTypeEnum v10_PredefinedType, boost::optional< std::string > v11_LongName); @@ -27134,13 +24335,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); @@ -27265,14 +24460,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); @@ -27367,14 +24556,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); @@ -27386,14 +24569,8 @@ 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< IfcRelConnectsStructuralMember >::ptr ConnectedBy() const; // INVERSE IfcRelConnectsStructuralMember::RelatingStructuralMember - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelConnectsStructuralMember >::ptr ConnectedBy() const; // INVERSE IfcRelConnectsStructuralMember::RelatingStructuralMember + 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); @@ -27421,13 +24598,7 @@ 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); } - bool is(Type::Enum v) const; - Type::Enum type() const; + 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); @@ -27463,13 +24634,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::IfcStructuralSurfaceMemberTypeEnum; 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, IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness); @@ -27495,13 +24660,7 @@ public: /// In case of aggregation, instances of IfcStructuralSurfaceMemberVarying may have a topology representation which contains a single IfcConnectedFaceSet, based upon the faces of the parts. Otherwise, definitions at IfcStructuralSurfaceMember apply. class IfcStructuralSurfaceMemberVarying : public IfcStructuralSurfaceMember { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralSurfaceMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralSurfaceMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { 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, IfcStructuralSurfaceMemberTypeEnum::IfcStructuralSurfaceMemberTypeEnum v8_PredefinedType, boost::optional< double > v9_Thickness); @@ -27534,13 +24693,7 @@ public: /// Type of reaction according to its distribution of load values. IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum PredefinedType() const; void setPredefinedType(IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum 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 IfcStructuralReaction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcStructuralSurfaceActivityTypeEnum; } return IfcStructuralReaction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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(); IfcStructuralSurfaceReaction (IfcAbstractEntity* e); IfcStructuralSurfaceReaction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v10_PredefinedType); @@ -27562,13 +24715,7 @@ public: /// Defines types of subcontract resources. IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum 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 IfcConstructionResourceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcSubContractResourceTypeEnum; } return IfcConstructionResourceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "PredefinedType"; } return IfcConstructionResourceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSubContractResourceType (IfcAbstractEntity* e); IfcSubContractResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v12_PredefinedType); @@ -27658,13 +24805,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, boost::optional< double > v4_StartParam, boost::optional< double > v5_EndParam, IfcSurface* v6_ReferenceSurface); @@ -27691,13 +24832,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); @@ -27725,13 +24860,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); @@ -27773,13 +24902,7 @@ public: bool hasPredefinedType() const; IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum PredefinedType() const; void setPredefinedType(IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum 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::IfcSystemFurnitureElementTypeEnum; } return IfcFurnishingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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, boost::optional< IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum > v10_PredefinedType); @@ -28081,13 +25204,7 @@ public: /// Added in IFC 2x4 IfcTaskTypeEnum::IfcTaskTypeEnum PredefinedType() const; void setPredefinedType(IfcTaskTypeEnum::IfcTaskTypeEnum v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_BOOL; case 10: return IfcUtil::Argument_INT; case 11: return IfcUtil::Argument_ENTITY_INSTANCE; case 12: return IfcUtil::Argument_ENUMERATION; } return IfcProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcLabel; case 8: return Type::IfcLabel; case 9: return Type::UNDEFINED; case 10: return Type::UNDEFINED; case 11: return Type::IfcTaskTime; case 12: return Type::IfcTaskTypeEnum; } return IfcProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "Status"; case 8: return "WorkMethod"; case 9: return "IsMilestone"; case 10: return "Priority"; case 11: return "TaskTime"; case 12: return "PredefinedType"; } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_WorkMethod, bool v10_IsMilestone, boost::optional< int > v11_Priority, IfcTaskTime* v12_TaskTime, boost::optional< IfcTaskTypeEnum::IfcTaskTypeEnum > v13_PredefinedType); @@ -28144,13 +25261,7 @@ public: /// The method of work used in carrying out a task. std::string WorkMethod() const; void setWorkMethod(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_ENUMERATION; case 10: return IfcUtil::Argument_STRING; } return IfcTypeProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTaskTypeEnum; case 10: return Type::IfcLabel; } return IfcTypeProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "WorkMethod"; } return IfcTypeProcess::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTaskType (IfcAbstractEntity* e); IfcTaskType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ProcessType, IfcTaskTypeEnum::IfcTaskTypeEnum v10_PredefinedType, boost::optional< std::string > v11_WorkMethod); @@ -28169,15 +25280,9 @@ public: bool hasClosed() const; bool Closed() const; void setClosed(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_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_BOOL; } return IfcTessellatedItem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPointList3D; case 1: return Type::IfcParameterValue; case 2: return Type::UNDEFINED; } return IfcTessellatedItem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; case 1: return "Normals"; case 2: return "Closed"; } return IfcTessellatedItem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcIndexedColourMap >::ptr HasColours() const; // INVERSE IfcIndexedColourMap::MappedTo + IfcTemplatedEntityList< IfcIndexedColourMap >::ptr HasColours() const; // INVERSE IfcIndexedColourMap::MappedTo IfcTemplatedEntityList< IfcIndexedTextureMap >::ptr HasTextures() const; // INVERSE IfcIndexedTextureMap::MappedTo - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTessellatedFaceSet (IfcAbstractEntity* e); IfcTessellatedFaceSet (IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed); @@ -28251,13 +25356,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); @@ -28272,13 +25371,7 @@ public: bool hasNormalIndex() const; std::vector< std::vector< int > > NormalIndex() const; void setNormalIndex(std::vector< std::vector< int > > v); - virtual unsigned int getArgumentCount() const { return 5; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT; } return IfcTessellatedFaceSet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; } return IfcTessellatedFaceSet::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "CoordIndex"; case 4: return "NormalIndex"; } return IfcTessellatedFaceSet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTriangulatedFaceSet (IfcAbstractEntity* e); IfcTriangulatedFaceSet (IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed, std::vector< std::vector< int > > v4_CoordIndex, boost::optional< std::vector< std::vector< int > > > v5_NormalIndex); @@ -28452,13 +25545,7 @@ public: /// IFC2x4 CHANGE: New attribute added at the end of the entity definition. double LiningToPanelOffsetY() const; void setLiningToPanelOffsetY(double v); - virtual unsigned int getArgumentCount() const { return 16; } - 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; case 13: return IfcUtil::Argument_DOUBLE; case 14: return IfcUtil::Argument_DOUBLE; case 15: return IfcUtil::Argument_DOUBLE; } return IfcPreDefinedPropertySet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcNonNegativeLengthMeasure; case 6: return Type::IfcNonNegativeLengthMeasure; case 7: return Type::IfcNonNegativeLengthMeasure; 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; case 13: return Type::IfcLengthMeasure; case 14: return Type::IfcLengthMeasure; case 15: return Type::IfcLengthMeasure; } return IfcPreDefinedPropertySet::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"; case 13: return "LiningOffset"; case 14: return "LiningToPanelOffsetX"; case 15: return "LiningToPanelOffsetY"; } return IfcPreDefinedPropertySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< double > v14_LiningOffset, boost::optional< double > v15_LiningToPanelOffsetX, boost::optional< double > v16_LiningToPanelOffsetY); @@ -28534,13 +25621,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 IfcPreDefinedPropertySet::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 IfcPreDefinedPropertySet::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 IfcPreDefinedPropertySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -28566,14 +25647,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); @@ -28614,13 +25689,7 @@ public: /// Figure 249 — Advanced Brep class IfcAdvancedBrep : 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(); IfcAdvancedBrep (IfcAbstractEntity* e); IfcAdvancedBrep (IfcClosedShell* v1_Outer); @@ -28651,13 +25720,7 @@ class IfcAdvancedBrepWithVoids : public IfcAdvancedBrep { public: 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 IfcAdvancedBrep::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcClosedShell; } return IfcAdvancedBrep::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Voids"; } return IfcAdvancedBrep::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAdvancedBrepWithVoids (IfcAbstractEntity* e); IfcAdvancedBrepWithVoids (IfcClosedShell* v1_Outer, IfcTemplatedEntityList< IfcClosedShell >::ptr v2_Voids); @@ -28838,14 +25901,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); @@ -28943,13 +26000,7 @@ public: /// Flag to indicate whether, or not, surface is self-intersecting; this is for information only. bool SelfIntersect() const; void setSelfIntersect(bool 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_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_BOOL; 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::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::IfcCartesianPoint; case 3: return Type::IfcBSplineSurfaceForm; case 4: return Type::UNDEFINED; 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 "UDegree"; case 1: return "VDegree"; case 2: return "ControlPointsList"; case 3: return "SurfaceForm"; case 4: return "UClosed"; case 5: return "VClosed"; case 6: return "SelfIntersect"; } 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(); IfcBSplineSurface (IfcAbstractEntity* e); IfcBSplineSurface (int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect); @@ -28979,13 +26030,7 @@ public: /// The description of the knot type. IfcKnotType::IfcKnotType KnotSpec() const; void setKnotSpec(IfcKnotType::IfcKnotType v); - virtual unsigned int getArgumentCount() const { return 12; } - 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_AGGREGATE_OF_DOUBLE; case 10: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 11: return IfcUtil::Argument_ENUMERATION; } return IfcBSplineSurface::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::IfcParameterValue; case 10: return Type::IfcParameterValue; case 11: return Type::IfcKnotType; } return IfcBSplineSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "UMultiplicities"; case 8: return "VMultiplicities"; case 9: return "UKnots"; case 10: return "VKnots"; case 11: return "KnotSpec"; } return IfcBSplineSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBSplineSurfaceWithKnots (IfcAbstractEntity* e); IfcBSplineSurfaceWithKnots (int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec); @@ -29099,13 +26144,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); @@ -29120,13 +26159,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); @@ -29144,13 +26177,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 (); @@ -29348,13 +26375,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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType, boost::optional< double > v10_ElevationOfRefHeight, boost::optional< double > v11_ElevationOfTerrain, IfcPostalAddress* v12_BuildingAddress); @@ -29391,13 +26412,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); @@ -29587,13 +26602,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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType, boost::optional< double > v10_Elevation); @@ -29629,13 +26638,7 @@ public: /// Identifies the predefined types of a chimney element from which the type required may be set. IfcChimneyTypeEnum::IfcChimneyTypeEnum PredefinedType() const; void setPredefinedType(IfcChimneyTypeEnum::IfcChimneyTypeEnum 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::IfcChimneyTypeEnum; } 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(); IfcChimneyType (IfcAbstractEntity* e); IfcChimneyType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcChimneyTypeEnum::IfcChimneyTypeEnum v10_PredefinedType); @@ -29664,13 +26667,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); @@ -29679,13 +26676,7 @@ public: class IfcCivilElementType : 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(); IfcCivilElementType (IfcAbstractEntity* e); IfcCivilElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -29794,13 +26785,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); @@ -29829,13 +26814,7 @@ public: /// Reference to a set of property templates. It should only be provided, if the PropertyType is set to COMPLEX. IfcTemplatedEntityList< IfcPropertyTemplate >::ptr HasPropertyTemplates() const; void setHasPropertyTemplates(IfcTemplatedEntityList< IfcPropertyTemplate >::ptr v); - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcPropertyTemplate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcLabel; case 5: return Type::IfcComplexPropertyTemplateTypeEnum; case 6: return Type::IfcPropertyTemplate; } return IfcPropertyTemplate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "UsageName"; case 5: return "TemplateType"; case 6: return "HasPropertyTemplates"; } return IfcPropertyTemplate::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcComplexPropertyTemplate (IfcAbstractEntity* e); IfcComplexPropertyTemplate (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_UsageName, boost::optional< IfcComplexPropertyTemplateTypeEnum::IfcComplexPropertyTemplateTypeEnum > v6_TemplateType, boost::optional< IfcTemplatedEntityList< IfcPropertyTemplate >::ptr > v7_HasPropertyTemplates); @@ -29915,13 +26894,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); @@ -29940,13 +26913,7 @@ public: /// HISTORY New entity in IFC2x4. class IfcCompositeCurveOnSurface : 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(); IfcCompositeCurveOnSurface (IfcAbstractEntity* e); IfcCompositeCurveOnSurface (IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect); @@ -29962,13 +26929,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); @@ -29992,13 +26953,7 @@ public: /// Defines types of construction equipment resources. IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum 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 IfcConstructionResourceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcConstructionEquipmentResourceTypeEnum; } return IfcConstructionResourceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "PredefinedType"; } return IfcConstructionResourceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionEquipmentResourceType (IfcAbstractEntity* e); IfcConstructionEquipmentResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v12_PredefinedType); @@ -30022,13 +26977,7 @@ public: /// Defines types of construction material resources. IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum 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 IfcConstructionResourceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcConstructionMaterialResourceTypeEnum; } return IfcConstructionResourceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "PredefinedType"; } return IfcConstructionResourceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionMaterialResourceType (IfcAbstractEntity* e); IfcConstructionMaterialResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v12_PredefinedType); @@ -30052,13 +27001,7 @@ public: /// Defines types of construction product resources. IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum 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 IfcConstructionResourceType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 11: return Type::IfcConstructionProductResourceTypeEnum; } return IfcConstructionResourceType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 11: return "PredefinedType"; } return IfcConstructionResourceType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcConstructionProductResourceType (IfcAbstractEntity* e); IfcConstructionProductResourceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< std::string > v7_Identification, boost::optional< std::string > v8_LongDescription, boost::optional< std::string > v9_ResourceType, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v10_BaseCosts, IfcPhysicalQuantity* v11_BaseQuantity, IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v12_PredefinedType); @@ -30150,13 +27093,7 @@ public: bool hasBaseQuantity() const; IfcPhysicalQuantity* BaseQuantity() const; void setBaseQuantity(IfcPhysicalQuantity* v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcResourceTime; case 8: return Type::IfcAppliedValue; case 9: return Type::IfcPhysicalQuantity; } return IfcResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "Usage"; case 8: return "BaseCosts"; case 9: 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity); @@ -30182,14 +27119,8 @@ public: /// IFC2x4 CHANGE Attribute unified by promoting from various subtypes of IfcControl. std::string Identification() const; void setIdentification(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 IfcObject::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcIdentifier; } return IfcObject::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Identification"; } 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, boost::optional< std::string > v6_Identification); @@ -30258,13 +27189,7 @@ public: /// IFC2x4 CHANGE The attribute has been added. IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr CostQuantities() const; void setCostQuantities(IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_ENUMERATION; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcCostItemTypeEnum; case 7: return Type::IfcCostValue; case 8: return Type::IfcPhysicalQuantity; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "PredefinedType"; case 7: return "CostValues"; case 8: return "CostQuantities"; } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcCostItemTypeEnum::IfcCostItemTypeEnum > v7_PredefinedType, boost::optional< IfcTemplatedEntityList< IfcCostValue >::ptr > v8_CostValues, boost::optional< IfcTemplatedEntityList< IfcPhysicalQuantity >::ptr > v9_CostQuantities); @@ -30327,13 +27252,7 @@ public: /// IFC2x4 CHANGE Type changed from IfcDateTimeSelect. std::string UpdateDate() const; void setUpdateDate(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_ENUMERATION; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcCostScheduleTypeEnum; case 7: return Type::IfcLabel; case 8: return Type::IfcDateTime; case 9: return Type::IfcDateTime; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "PredefinedType"; case 7: return "Status"; case 8: return "SubmittedOn"; case 9: return "UpdateDate"; } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_SubmittedOn, boost::optional< std::string > v10_UpdateDate); @@ -30423,13 +27342,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); @@ -30453,13 +27366,7 @@ public: /// IFC2x4 New attribute IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcCrewResourceTypeEnum; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "PredefinedType"; } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcCrewResourceTypeEnum::IfcCrewResourceTypeEnum > v11_PredefinedType); @@ -30491,13 +27398,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); @@ -30562,13 +27463,7 @@ public: /// The radius of the cylindrical surface. 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 IfcElementarySurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcPositiveLengthMeasure; } return IfcElementarySurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Radius"; } 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(); IfcCylindricalSurface (IfcAbstractEntity* e); IfcCylindricalSurface (IfcAxis2Placement3D* v1_Position, double v2_Radius); @@ -30604,13 +27499,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); @@ -30683,13 +27572,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); @@ -30863,13 +27746,7 @@ public: /// IFC2x4 CHANGE: New attribute added at the end of the entity definition. double LiningToPanelOffsetY() const; void setLiningToPanelOffsetY(double v); - virtual unsigned int getArgumentCount() const { return 17; } - 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; case 15: return IfcUtil::Argument_DOUBLE; case 16: return IfcUtil::Argument_DOUBLE; } return IfcPreDefinedPropertySet::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcPositiveLengthMeasure; case 5: return Type::IfcNonNegativeLengthMeasure; case 6: return Type::IfcPositiveLengthMeasure; case 7: return Type::IfcNonNegativeLengthMeasure; case 8: return Type::IfcNonNegativeLengthMeasure; 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; case 15: return Type::IfcLengthMeasure; case 16: return Type::IfcLengthMeasure; } return IfcPreDefinedPropertySet::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"; case 15: return "LiningToPanelOffsetX"; case 16: return "LiningToPanelOffsetY"; } return IfcPreDefinedPropertySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< double > v16_LiningToPanelOffsetX, boost::optional< double > v17_LiningToPanelOffsetY); @@ -30945,13 +27822,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 IfcPreDefinedPropertySet::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 IfcPreDefinedPropertySet::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 IfcPreDefinedPropertySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -31101,13 +27972,7 @@ public: bool hasUserDefinedOperationType() const; std::string UserDefinedOperationType() const; void setUserDefinedOperationType(std::string v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_ENUMERATION; case 11: return IfcUtil::Argument_BOOL; case 12: return IfcUtil::Argument_STRING; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDoorTypeEnum; case 10: return Type::IfcDoorTypeOperationEnum; case 11: return Type::UNDEFINED; case 12: return Type::IfcLabel; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "OperationType"; case 11: return "ParameterTakesPrecedence"; case 12: return "UserDefinedOperationType"; } 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(); IfcDoorType (IfcAbstractEntity* e); IfcDoorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcDoorTypeEnum::IfcDoorTypeEnum v10_PredefinedType, IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum v11_OperationType, boost::optional< bool > v12_ParameterTakesPrecedence, boost::optional< std::string > v13_UserDefinedOperationType); @@ -31187,13 +28052,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); @@ -31214,13 +28073,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); @@ -31286,12 +28139,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< IfcRelFillsElement >::ptr FillsVoids() const; // INVERSE IfcRelFillsElement::RelatedBuildingElement + IfcTemplatedEntityList< IfcRelFillsElement >::ptr FillsVoids() const; // INVERSE IfcRelFillsElement::RelatedBuildingElement IfcTemplatedEntityList< IfcRelConnectsElements >::ptr ConnectedTo() const; // INVERSE IfcRelConnectsElements::RelatingElement IfcTemplatedEntityList< IfcRelInterferesElements >::ptr IsInterferedByElements() const; // INVERSE IfcRelInterferesElements::RelatedElement IfcTemplatedEntityList< IfcRelInterferesElements >::ptr InterferesElements() const; // INVERSE IfcRelInterferesElements::RelatingElement @@ -31302,8 +28150,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); @@ -31417,13 +28264,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, boost::optional< IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum > v10_PredefinedType); @@ -31456,13 +28297,7 @@ public: /// Predefined types to define the particular type of the transport element. There may be property set definitions available for each predefined type. 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 9: return IfcUtil::Argument_ENUMERATION; } return IfcElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcElementAssemblyTypeEnum; } 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(); IfcElementAssemblyType (IfcAbstractEntity* e); IfcElementAssemblyType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum v10_PredefinedType); @@ -31547,13 +28382,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); @@ -31570,13 +28399,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); @@ -31617,13 +28440,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); @@ -31656,13 +28473,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); @@ -31698,13 +28509,7 @@ class IfcEngineType : public IfcEnergyConversionDeviceType { public: IfcEngineTypeEnum::IfcEngineTypeEnum PredefinedType() const; void setPredefinedType(IfcEngineTypeEnum::IfcEngineTypeEnum 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::IfcEngineTypeEnum; } 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(); IfcEngineType (IfcAbstractEntity* e); IfcEngineType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcEngineTypeEnum::IfcEngineTypeEnum v10_PredefinedType); @@ -31741,13 +28546,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); @@ -31784,13 +28583,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); @@ -31899,13 +28692,7 @@ public: /// The date and/or time at which an event occurs. IfcEventTime* EventOccurenceTime() const; void setEventOccurenceTime(IfcEventTime* v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 7: return IfcUtil::Argument_ENUMERATION; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_STRING; case 10: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcEventTypeEnum; case 8: return Type::IfcEventTriggerTypeEnum; case 9: return Type::IfcLabel; case 10: return Type::IfcEventTime; } return IfcProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "PredefinedType"; case 8: return "EventTriggerType"; case 9: return "UserDefinedEventTriggerType"; case 10: return "EventOccurenceTime"; } 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(); IfcEvent (IfcAbstractEntity* e); IfcEvent (std::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_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< IfcEventTypeEnum::IfcEventTypeEnum > v8_PredefinedType, boost::optional< IfcEventTriggerTypeEnum::IfcEventTriggerTypeEnum > v9_EventTriggerType, boost::optional< std::string > v10_UserDefinedEventTriggerType, IfcEventTime* v11_EventOccurenceTime); @@ -31918,13 +28705,7 @@ public: /// IFC2x4. class IfcExternalSpatialStructureElement : public IfcSpatialElement { public: - virtual unsigned int getArgumentCount() const { return 8; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcSpatialElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcSpatialElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcSpatialElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternalSpatialStructureElement (IfcAbstractEntity* e); IfcExternalSpatialStructureElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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); @@ -31956,13 +28737,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); @@ -31997,13 +28772,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 IfcFacetedBrep::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcClosedShell; } return IfcFacetedBrep::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Voids"; } return IfcFacetedBrep::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -32024,13 +28793,7 @@ public: /// Subtype of fastener IfcFastenerTypeEnum::IfcFastenerTypeEnum PredefinedType() const; void setPredefinedType(IfcFastenerTypeEnum::IfcFastenerTypeEnum 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 IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFastenerTypeEnum; } return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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, boost::optional< IfcFastenerTypeEnum::IfcFastenerTypeEnum > v9_PredefinedType); @@ -32064,13 +28827,7 @@ public: /// Subtype of fastener IfcFastenerTypeEnum::IfcFastenerTypeEnum PredefinedType() const; void setPredefinedType(IfcFastenerTypeEnum::IfcFastenerTypeEnum 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 IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcFastenerTypeEnum; } return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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, IfcFastenerTypeEnum::IfcFastenerTypeEnum v10_PredefinedType); @@ -32172,13 +28929,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); @@ -32241,14 +28992,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); @@ -32306,14 +29051,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); @@ -32345,13 +29084,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); @@ -32384,13 +29117,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); @@ -32433,13 +29160,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); @@ -32470,13 +29191,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); @@ -32516,13 +29231,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); @@ -32537,13 +29246,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); @@ -32558,13 +29261,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); @@ -32581,13 +29278,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); @@ -32607,13 +29298,7 @@ public: /// Subtype of footing. IfcFootingTypeEnum::IfcFootingTypeEnum PredefinedType() const; void setPredefinedType(IfcFootingTypeEnum::IfcFootingTypeEnum 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::IfcFootingTypeEnum; } 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(); IfcFootingType (IfcAbstractEntity* e); IfcFootingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcFootingTypeEnum::IfcFootingTypeEnum v10_PredefinedType); @@ -32725,13 +29410,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); @@ -32774,13 +29453,7 @@ public: bool hasPredefinedType() const; IfcFurnitureTypeEnum::IfcFurnitureTypeEnum PredefinedType() const; void setPredefinedType(IfcFurnitureTypeEnum::IfcFurnitureTypeEnum 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 IfcFurnishingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFurnitureTypeEnum; } return IfcFurnishingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFurnishingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFurniture (IfcAbstractEntity* e); IfcFurniture (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFurnitureTypeEnum::IfcFurnitureTypeEnum > v9_PredefinedType); @@ -32933,13 +29606,7 @@ public: /// Predefined generic types for a geographic element that are specified in an enumeration. There might be property sets defined specifically for each predefined type. IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum PredefinedType() const; void setPredefinedType(IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum 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 IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcGeographicElementTypeEnum; } return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: 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(); IfcGeographicElement (IfcAbstractEntity* e); IfcGeographicElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcGeographicElementTypeEnum::IfcGeographicElementTypeEnum > v9_PredefinedType); @@ -33058,14 +29725,8 @@ public: bool hasPredefinedType() const; IfcGridTypeEnum::IfcGridTypeEnum PredefinedType() const; void setPredefinedType(IfcGridTypeEnum::IfcGridTypeEnum 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_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 10: return IfcUtil::Argument_ENUMERATION; } 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; case 10: return Type::IfcGridTypeEnum; } 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"; case 10: return "PredefinedType"; } 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, boost::optional< IfcGridTypeEnum::IfcGridTypeEnum > v11_PredefinedType); @@ -33103,14 +29764,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); @@ -33150,13 +29805,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); @@ -33193,13 +29842,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); @@ -33242,13 +29885,7 @@ class IfcInterceptorType : public IfcFlowTreatmentDeviceType { public: IfcInterceptorTypeEnum::IfcInterceptorTypeEnum PredefinedType() const; void setPredefinedType(IfcInterceptorTypeEnum::IfcInterceptorTypeEnum 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::IfcInterceptorTypeEnum; } 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(); IfcInterceptorType (IfcAbstractEntity* e); IfcInterceptorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcInterceptorTypeEnum::IfcInterceptorTypeEnum v10_PredefinedType); @@ -33301,13 +29938,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_STRING; 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::IfcDate; 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 "PredefinedType"; 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, boost::optional< IfcInventoryTypeEnum::IfcInventoryTypeEnum > v6_PredefinedType, IfcActorSelect* v7_Jurisdiction, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_ResponsiblePersons, boost::optional< std::string > v9_LastUpdateDate, IfcCostValue* v10_CurrentValue, IfcCostValue* v11_OriginalValue); @@ -33345,13 +29976,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); @@ -33389,13 +30014,7 @@ public: /// IFC2x4 New attribute IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcLaborResourceTypeEnum; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "PredefinedType"; } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcLaborResourceTypeEnum::IfcLaborResourceTypeEnum > v11_PredefinedType); @@ -33435,13 +30054,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); @@ -33483,13 +30096,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); @@ -33539,13 +30146,7 @@ public: /// Subtype of mechanical fastener IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum PredefinedType() const; void setPredefinedType(IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - 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_ENUMERATION; } return IfcElementComponent::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::IfcMechanicalFastenerTypeEnum; } return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "NominalDiameter"; case 9: return "NominalLength"; case 10: return "PredefinedType"; } 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(); 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, boost::optional< IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum > v11_PredefinedType); @@ -33601,13 +30202,7 @@ public: /// The nominal length describing the longitudinal dimensions of the fastener type. double NominalLength() const; void setNominalLength(double v); - virtual unsigned int getArgumentCount() const { return 12; } - 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; } return IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcMechanicalFastenerTypeEnum; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; } return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "NominalDiameter"; case 11: return "NominalLength"; } 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(); 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, IfcMechanicalFastenerTypeEnum::IfcMechanicalFastenerTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_NominalLength); @@ -33643,13 +30238,7 @@ class IfcMedicalDeviceType : public IfcFlowTerminalType { public: IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum 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::IfcMedicalDeviceTypeEnum; } 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(); IfcMedicalDeviceType (IfcAbstractEntity* e); IfcMedicalDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum v10_PredefinedType); @@ -33761,13 +30350,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); @@ -33805,13 +30388,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); @@ -33833,13 +30410,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, boost::optional< IfcOccupantTypeEnum::IfcOccupantTypeEnum > v7_PredefinedType); @@ -34056,14 +30627,8 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum PredefinedType() const; void setPredefinedType(IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum 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 IfcFeatureElementSubtraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcOpeningElementTypeEnum; } return IfcFeatureElementSubtraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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, boost::optional< IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum > v9_PredefinedType); @@ -34164,13 +30729,7 @@ public: /// Figure 37 — Opening standard representation class IfcOpeningStandardCase : public IfcOpeningElement { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcOpeningElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcOpeningElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcOpeningElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOpeningStandardCase (IfcAbstractEntity* e); IfcOpeningStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcOpeningElementTypeEnum::IfcOpeningElementTypeEnum > v9_PredefinedType); @@ -34210,13 +30769,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); @@ -34239,13 +30792,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum PredefinedType() const; void setPredefinedType(IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum 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_ENUMERATION; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcLabel; case 7: return Type::IfcPerformanceHistoryTypeEnum; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "LifeCyclePhase"; case 7: 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(); 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, boost::optional< std::string > v6_Identification, std::string v7_LifeCyclePhase, boost::optional< IfcPerformanceHistoryTypeEnum::IfcPerformanceHistoryTypeEnum > v8_PredefinedType); @@ -34305,13 +30852,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 IfcPreDefinedPropertySet::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 IfcPreDefinedPropertySet::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 IfcPreDefinedPropertySet::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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); @@ -34377,13 +30918,7 @@ public: /// IFC2x4 CHANGE The attribute has been added. std::string LongDescription() const; void setLongDescription(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_ENUMERATION; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcPermitTypeEnum; case 7: return Type::IfcLabel; case 8: return Type::IfcText; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "PredefinedType"; case 7: return "Status"; case 8: return "LongDescription"; } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcPermitTypeEnum::IfcPermitTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription); @@ -34401,13 +30936,7 @@ public: /// Subtype of pile. IfcPileTypeEnum::IfcPileTypeEnum PredefinedType() const; void setPredefinedType(IfcPileTypeEnum::IfcPileTypeEnum 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::IfcPileTypeEnum; } 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(); IfcPileType (IfcAbstractEntity* e); IfcPileType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcPileTypeEnum::IfcPileTypeEnum v10_PredefinedType); @@ -34447,13 +30976,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); @@ -34497,13 +31020,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); @@ -34591,13 +31108,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); @@ -34622,13 +31133,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); @@ -34689,16 +31194,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); @@ -34816,13 +31315,7 @@ public: /// the type required may be set. IfcProcedureTypeEnum::IfcProcedureTypeEnum PredefinedType() const; void setPredefinedType(IfcProcedureTypeEnum::IfcProcedureTypeEnum 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 IfcProcess::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcProcedureTypeEnum; } return IfcProcess::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "PredefinedType"; } 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, boost::optional< std::string > v6_Identification, boost::optional< std::string > v7_LongDescription, boost::optional< IfcProcedureTypeEnum::IfcProcedureTypeEnum > v8_PredefinedType); @@ -34898,13 +31391,7 @@ public: /// A detailed description of the project order describing the work to be completed. std::string LongDescription() const; void setLongDescription(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_ENUMERATION; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcProjectOrderTypeEnum; case 7: return Type::IfcLabel; case 8: return Type::IfcText; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "PredefinedType"; case 7: return "Status"; case 8: return "LongDescription"; } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription); @@ -35026,13 +31513,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum PredefinedType() const; void setPredefinedType(IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum 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 IfcFeatureElementAddition::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcProjectionElementTypeEnum; } return IfcFeatureElementAddition::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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, boost::optional< IfcProjectionElementTypeEnum::IfcProjectionElementTypeEnum > v9_PredefinedType); @@ -35078,13 +31559,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); @@ -35123,13 +31598,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); @@ -35160,13 +31629,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); @@ -35197,13 +31660,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); @@ -35247,13 +31704,7 @@ public: /// Identifies the predefined types of a ramp element from which the type required may be set. IfcRampTypeEnum::IfcRampTypeEnum PredefinedType() const; void setPredefinedType(IfcRampTypeEnum::IfcRampTypeEnum 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::IfcRampTypeEnum; } 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(); IfcRampType (IfcAbstractEntity* e); IfcRampType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRampTypeEnum::IfcRampTypeEnum v10_PredefinedType); @@ -35277,13 +31728,7 @@ public: /// The weights associated with the control points in the rational case. std::vector< std::vector< double > > WeightsData() const; void setWeightsData(std::vector< std::vector< double > > v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 12: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcBSplineSurfaceWithKnots::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 12: return Type::UNDEFINED; } return IfcBSplineSurfaceWithKnots::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 12: return "WeightsData"; } return IfcBSplineSurfaceWithKnots::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRationalBSplineSurfaceWithKnots (IfcAbstractEntity* e); IfcRationalBSplineSurfaceWithKnots (int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec, std::vector< std::vector< double > > v13_WeightsData); @@ -35303,13 +31748,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 IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcLabel; } return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "SteelGrade"; } 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(); 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); @@ -35320,13 +31759,7 @@ public: /// HISTORY New entity in IFC Release 2x4 class IfcReinforcingElementType : 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(); IfcReinforcingElementType (IfcAbstractEntity* e); IfcReinforcingElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType); @@ -35395,13 +31828,7 @@ public: /// The predefined type is always MESH. IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum PredefinedType() const; void setPredefinedType(IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v); - virtual unsigned int getArgumentCount() const { return 18; } - 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; case 17: 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::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; case 17: return Type::IfcReinforcingMeshTypeEnum; } 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"; case 17: return "PredefinedType"; } 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, boost::optional< double > v12_LongitudinalBarNominalDiameter, boost::optional< double > v13_TransverseBarNominalDiameter, boost::optional< double > v14_LongitudinalBarCrossSectionArea, boost::optional< double > v15_TransverseBarCrossSectionArea, boost::optional< double > v16_LongitudinalBarSpacing, boost::optional< double > v17_TransverseBarSpacing, boost::optional< IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum > v18_PredefinedType); @@ -35471,13 +31898,7 @@ public: bool hasBendingParameters() const; IfcEntityList::ptr BendingParameters() const; void setBendingParameters(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 20; } - 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; case 17: return IfcUtil::Argument_DOUBLE; case 18: return IfcUtil::Argument_STRING; case 19: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcReinforcingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcReinforcingMeshTypeEnum; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcPositiveLengthMeasure; case 12: return Type::IfcPositiveLengthMeasure; case 13: return Type::IfcPositiveLengthMeasure; case 14: return Type::IfcAreaMeasure; case 15: return Type::IfcAreaMeasure; case 16: return Type::IfcPositiveLengthMeasure; case 17: return Type::IfcPositiveLengthMeasure; case 18: return Type::IfcLabel; case 19: return Type::IfcBendingParameterSelect; } return IfcReinforcingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "MeshLength"; case 11: return "MeshWidth"; case 12: return "LongitudinalBarNominalDiameter"; case 13: return "TransverseBarNominalDiameter"; case 14: return "LongitudinalBarCrossSectionArea"; case 15: return "TransverseBarCrossSectionArea"; case 16: return "LongitudinalBarSpacing"; case 17: return "TransverseBarSpacing"; case 18: return "BendingShapeCode"; case 19: return "BendingParameters"; } return IfcReinforcingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcingMeshType (IfcAbstractEntity* e); IfcReinforcingMeshType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcReinforcingMeshTypeEnum::IfcReinforcingMeshTypeEnum v10_PredefinedType, boost::optional< double > v11_MeshLength, boost::optional< double > v12_MeshWidth, boost::optional< double > v13_LongitudinalBarNominalDiameter, boost::optional< double > v14_TransverseBarNominalDiameter, boost::optional< double > v15_LongitudinalBarCrossSectionArea, boost::optional< double > v16_TransverseBarCrossSectionArea, boost::optional< double > v17_LongitudinalBarSpacing, boost::optional< double > v18_TransverseBarSpacing, boost::optional< std::string > v19_BendingShapeCode, boost::optional< IfcEntityList::ptr > v20_BendingParameters); @@ -35517,13 +31938,7 @@ public: /// IFC2x4 CHANGE  The attribute has been demoted from the supertype IfcRelDecomposes and defines the non-ordered set of parts within the aggregation. 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 IfcRelDecomposes::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 4: return Type::IfcObjectDefinition; case 5: return Type::IfcObjectDefinition; } return IfcRelDecomposes::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 4: return "RelatingObject"; case 5: return "RelatedObjects"; } 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); @@ -35566,13 +31981,7 @@ public: /// Identifies the predefined types of a roof element from which the type required may be set. IfcRoofTypeEnum::IfcRoofTypeEnum PredefinedType() const; void setPredefinedType(IfcRoofTypeEnum::IfcRoofTypeEnum 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::IfcRoofTypeEnum; } 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(); IfcRoofType (IfcAbstractEntity* e); IfcRoofType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcRoofTypeEnum::IfcRoofTypeEnum v10_PredefinedType); @@ -35620,13 +32029,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); @@ -35658,13 +32061,7 @@ public: /// Identifies the predefined types of a shading device element from which the type required may be set. IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum 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::IfcShadingDeviceTypeEnum; } 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(); IfcShadingDeviceType (IfcAbstractEntity* e); IfcShadingDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum v10_PredefinedType); @@ -35889,13 +32286,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, boost::optional< 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); @@ -35983,13 +32374,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); @@ -36025,13 +32410,7 @@ class IfcSolarDeviceType : public IfcEnergyConversionDeviceType { public: IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum 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::IfcSolarDeviceTypeEnum; } 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(); IfcSolarDeviceType (IfcAbstractEntity* e); IfcSolarDeviceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum v10_PredefinedType); @@ -36303,15 +32682,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::IfcSpaceTypeEnum; case 10: return Type::IfcLengthMeasure; } return IfcSpatialStructureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; 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::RelatingSpace + IfcTemplatedEntityList< IfcRelCoversSpaces >::ptr HasCoverings() const; // INVERSE IfcRelCoversSpaces::RelatingSpace 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, boost::optional< IfcElementCompositionEnum::IfcElementCompositionEnum > v9_CompositionType, boost::optional< IfcSpaceTypeEnum::IfcSpaceTypeEnum > v10_PredefinedType, boost::optional< double > v11_ElevationWithFlooring); @@ -36352,13 +32725,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 IfcFlowTerminalType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSpaceHeaterTypeEnum; } 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(); 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); @@ -36454,13 +32821,7 @@ public: bool hasLongName() const; std::string LongName() const; void setLongName(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_ENUMERATION; case 10: return IfcUtil::Argument_STRING; } return IfcSpatialStructureElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcSpaceTypeEnum; case 10: return Type::IfcLabel; } return IfcSpatialStructureElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "LongName"; } 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, boost::optional< std::string > v11_LongName); @@ -36497,13 +32858,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); @@ -36534,13 +32889,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); @@ -36584,13 +32933,7 @@ public: /// Identifies the predefined types of a stair element from which the type required may be set. IfcStairTypeEnum::IfcStairTypeEnum PredefinedType() const; void setPredefinedType(IfcStairTypeEnum::IfcStairTypeEnum 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::IfcStairTypeEnum; } 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(); IfcStairType (IfcAbstractEntity* e); IfcStairType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcStairTypeEnum::IfcStairTypeEnum v10_PredefinedType); @@ -36622,13 +32965,7 @@ public: /// Indicates if this action may cause a stability problem. If it is 'FALSE', no further investigations regarding stability problems are necessary. bool DestabilizingLoad() const; void setDestabilizingLoad(bool v); - virtual unsigned int getArgumentCount() const { return 10; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_BOOL; } return IfcStructuralActivity::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::UNDEFINED; } return IfcStructuralActivity::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "DestabilizingLoad"; } 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, boost::optional< bool > v10_DestabilizingLoad); @@ -36644,14 +32981,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); @@ -36723,13 +33054,7 @@ public: /// Type of action according to its distribution of load values. IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum PredefinedType() const; void setPredefinedType(IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; case 11: return IfcUtil::Argument_ENUMERATION; } return IfcStructuralAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcProjectedOrTrueLengthEnum; case 11: return Type::IfcStructuralCurveActivityTypeEnum; } return IfcStructuralAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "ProjectedOrTrue"; case 11: return "PredefinedType"; } 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(); IfcStructuralCurveAction (IfcAbstractEntity* e); IfcStructuralCurveAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v12_PredefinedType); @@ -36759,13 +33084,7 @@ public: /// NOTE  It is desirable and usually possible that many instances of IfcStructuralCurveConnection and IfcStructuralCurveMember share a common instance of IfcDirection as their Axis attribute. IfcDirection* Axis() const; void setAxis(IfcDirection* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcStructuralConnection::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDirection; } return IfcStructuralConnection::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "Axis"; } 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, IfcDirection* v9_Axis); @@ -36818,13 +33137,7 @@ public: /// NOTE  It is desirable and usually possible that many instances of IfcStructuralCurveConnection and IfcStructuralCurveMember share a common instance of IfcDirection as their Axis attribute. IfcDirection* Axis() const; void setAxis(IfcDirection* 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_ENTITY_INSTANCE; } return IfcStructuralMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcStructuralCurveMemberTypeEnum; case 8: return Type::IfcDirection; } return IfcStructuralMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "PredefinedType"; case 8: return "Axis"; } 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, IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v8_PredefinedType, IfcDirection* v9_Axis); @@ -36852,13 +33165,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 9; } - 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, IfcStructuralCurveMemberTypeEnum::IfcStructuralCurveMemberTypeEnum v8_PredefinedType, IfcDirection* v9_Axis); @@ -36919,13 +33226,7 @@ public: /// Type of reaction according to its distribution of load values. IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum PredefinedType() const; void setPredefinedType(IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum 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 IfcStructuralReaction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcStructuralCurveActivityTypeEnum; } return IfcStructuralReaction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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(); IfcStructuralCurveReaction (IfcAbstractEntity* e); IfcStructuralCurveReaction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v10_PredefinedType); @@ -36940,13 +33241,7 @@ public: /// NOTE  Like its supertype IfcStructuralCurveAction, this action type may also act on curved edges. class IfcStructuralLinearAction : public IfcStructuralCurveAction { public: - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralCurveAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralCurveAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralCurveAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralCurveActivityTypeEnum::IfcStructuralCurveActivityTypeEnum v12_PredefinedType); @@ -37006,15 +33301,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); @@ -37067,13 +33356,7 @@ public: /// IfcStructuralLoadSingleDisplacement. class IfcStructuralPointAction : public IfcStructuralAction { public: - virtual unsigned int getArgumentCount() const { return 10; } - 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, boost::optional< bool > v10_DestabilizingLoad); @@ -37099,13 +33382,7 @@ public: /// Defines a coordinate system used for the description of the support condition properties in SELF\IfcStructuralConnection.SupportCondition, specified relative to the global coordinate system (global to the structural analysis model) established by SELF.\IfcProduct.ObjectPlacement. If left unspecified, the placement IfcAxis2Placement3D((x,y,z), ?, ?) is implied with x,y,z being the coordinates of the reference point of this IfcStructuralPointConnection and the default axes directions being in parallel with the global axes. IfcAxis2Placement3D* ConditionCoordinateSystem() const; void setConditionCoordinateSystem(IfcAxis2Placement3D* v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } return IfcStructuralConnection::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAxis2Placement3D; } return IfcStructuralConnection::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "ConditionCoordinateSystem"; } 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, IfcAxis2Placement3D* v9_ConditionCoordinateSystem); @@ -37156,13 +33433,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); @@ -37185,14 +33456,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); @@ -37260,13 +33525,7 @@ public: /// Type of action according to its distribution of load values. IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum PredefinedType() const; void setPredefinedType(IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v); - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; case 11: return IfcUtil::Argument_ENUMERATION; } return IfcStructuralAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcProjectedOrTrueLengthEnum; case 11: return Type::IfcStructuralSurfaceActivityTypeEnum; } return IfcStructuralAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "ProjectedOrTrue"; case 11: return "PredefinedType"; } 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(); IfcStructuralSurfaceAction (IfcAbstractEntity* e); IfcStructuralSurfaceAction (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v12_PredefinedType); @@ -37286,13 +33545,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); @@ -37330,13 +33583,7 @@ public: /// IFC2x4 New attribute IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcSubContractResourceTypeEnum; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "PredefinedType"; } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcSubContractResourceTypeEnum::IfcSubContractResourceTypeEnum > v11_PredefinedType); @@ -37381,13 +33628,7 @@ public: /// Indicates the kind of surface feature. IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum PredefinedType() const; void setPredefinedType(IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum 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 IfcFeatureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSurfaceFeatureTypeEnum; } return IfcFeatureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFeatureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSurfaceFeature (IfcAbstractEntity* e); IfcSurfaceFeature (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSurfaceFeatureTypeEnum::IfcSurfaceFeatureTypeEnum > v9_PredefinedType); @@ -37438,13 +33679,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); @@ -37469,14 +33704,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); @@ -37512,13 +33741,7 @@ public: bool hasPredefinedType() const; IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum PredefinedType() const; void setPredefinedType(IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum 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 IfcFurnishingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSystemFurnitureElementTypeEnum; } return IfcFurnishingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFurnishingElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSystemFurnitureElement (IfcAbstractEntity* e); IfcSystemFurnitureElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSystemFurnitureElementTypeEnum::IfcSystemFurnitureElementTypeEnum > v9_PredefinedType); @@ -37561,13 +33784,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); @@ -37608,13 +33825,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, boost::optional< IfcTendonTypeEnum::IfcTendonTypeEnum > v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< 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); @@ -37627,13 +33838,7 @@ public: bool hasPredefinedType() const; IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum PredefinedType() const; void setPredefinedType(IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum 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 IfcReinforcingElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTendonAnchorTypeEnum; } return IfcReinforcingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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, boost::optional< IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum > v10_PredefinedType); @@ -37644,13 +33849,7 @@ class IfcTendonAnchorType : public IfcReinforcingElementType { public: IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum PredefinedType() const; void setPredefinedType(IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum 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 IfcReinforcingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcTendonAnchorTypeEnum; } return IfcReinforcingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } return IfcReinforcingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTendonAnchorType (IfcAbstractEntity* e); IfcTendonAnchorType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTendonAnchorTypeEnum::IfcTendonAnchorTypeEnum v10_PredefinedType); @@ -37673,13 +33872,7 @@ public: bool hasSheethDiameter() const; double SheethDiameter() const; void setSheethDiameter(double v); - virtual unsigned int getArgumentCount() const { return 13; } - 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; } return IfcReinforcingElementType::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::IfcPositiveLengthMeasure; } return IfcReinforcingElementType::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 "SheethDiameter"; } return IfcReinforcingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTendonType (IfcAbstractEntity* e); IfcTendonType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcTendonTypeEnum::IfcTendonTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_CrossSectionArea, boost::optional< double > v13_SheethDiameter); @@ -37717,13 +33910,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); @@ -37854,13 +34041,7 @@ public: /// IFC2x4 CHANGE  The attribute has been changed to be optional. IfcTransportElementTypeEnum::IfcTransportElementTypeEnum PredefinedType() const; void setPredefinedType(IfcTransportElementTypeEnum::IfcTransportElementTypeEnum 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 IfcElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcTransportElementTypeEnum; } return IfcElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: 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(); 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_PredefinedType); @@ -37961,13 +34142,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); @@ -38007,13 +34182,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); @@ -38052,13 +34221,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); @@ -38107,13 +34270,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); @@ -38159,13 +34316,7 @@ public: bool hasPredefinedType() const; IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum PredefinedType() const; void setPredefinedType(IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum 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 IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcVibrationIsolatorTypeEnum; } return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcVibrationIsolator (IfcAbstractEntity* e); IfcVibrationIsolator (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum > v9_PredefinedType); @@ -38198,13 +34349,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 IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcVibrationIsolatorTypeEnum; } return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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(); 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); @@ -38298,13 +34443,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); @@ -38349,13 +34488,7 @@ public: /// Qualifies the feature regarding its shape and configuration relative to the voided element. IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum PredefinedType() const; void setPredefinedType(IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum 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 IfcFeatureElementSubtraction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcVoidingFeatureTypeEnum; } return IfcFeatureElementSubtraction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcVoidingFeature (IfcAbstractEntity* e); IfcVoidingFeature (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcVoidingFeatureTypeEnum::IfcVoidingFeatureTypeEnum > v9_PredefinedType); @@ -38450,13 +34583,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); @@ -38503,13 +34630,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); @@ -38652,13 +34773,7 @@ public: bool hasUserDefinedPartitioningType() const; std::string UserDefinedPartitioningType() const; void setUserDefinedPartitioningType(std::string v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 9: return IfcUtil::Argument_ENUMERATION; case 10: return IfcUtil::Argument_ENUMERATION; case 11: return IfcUtil::Argument_BOOL; case 12: return IfcUtil::Argument_STRING; } return IfcBuildingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcWindowTypeEnum; case 10: return Type::IfcWindowTypePartitioningEnum; case 11: return Type::UNDEFINED; case 12: return Type::IfcLabel; } return IfcBuildingElementType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; case 10: return "PartitioningType"; case 11: return "ParameterTakesPrecedence"; case 12: return "UserDefinedPartitioningType"; } 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(); IfcWindowType (IfcAbstractEntity* e); IfcWindowType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcWindowTypeEnum::IfcWindowTypeEnum v10_PredefinedType, IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum v11_PartitioningType, boost::optional< bool > v12_ParameterTakesPrecedence, boost::optional< std::string > v13_UserDefinedPartitioningType); @@ -38701,13 +34816,7 @@ public: /// Added in IFC 2x4 IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum PredefinedType() const; void setPredefinedType(IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum v); - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENUMERATION; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcWorkTime; case 7: return Type::IfcWorkTime; case 8: return Type::IfcWorkCalendarTypeEnum; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "WorkingTimes"; case 7: return "ExceptionTimes"; case 8: 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(); IfcWorkCalendar (IfcAbstractEntity* e); IfcWorkCalendar (std::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_Identification, boost::optional< IfcTemplatedEntityList< IfcWorkTime >::ptr > v7_WorkingTimes, boost::optional< IfcTemplatedEntityList< IfcWorkTime >::ptr > v8_ExceptionTimes, boost::optional< IfcWorkCalendarTypeEnum::IfcWorkCalendarTypeEnum > v9_PredefinedType); @@ -38790,13 +34899,7 @@ public: /// The finish time of the schedule. std::string FinishTime() const; void setFinishTime(std::string v); - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_STRING; case 9: return IfcUtil::Argument_STRING; case 10: return IfcUtil::Argument_STRING; case 11: return IfcUtil::Argument_STRING; case 12: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcDateTime; case 7: return Type::IfcPerson; case 8: return Type::IfcLabel; case 9: return Type::IfcDuration; case 10: return Type::IfcDuration; case 11: return Type::IfcDateTime; case 12: return Type::IfcDateTime; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {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"; } 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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime); @@ -38835,13 +34938,7 @@ public: /// the type required may be set. IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum PredefinedType() const; void setPredefinedType(IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 13: return IfcUtil::Argument_ENUMERATION; } return IfcWorkControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 13: return Type::IfcWorkPlanTypeEnum; } return IfcWorkControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 13: return "PredefinedType"; } 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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime, boost::optional< IfcWorkPlanTypeEnum::IfcWorkPlanTypeEnum > v14_PredefinedType); @@ -38895,13 +34992,7 @@ public: /// the type required may be set. IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum PredefinedType() const; void setPredefinedType(IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum v); - virtual unsigned int getArgumentCount() const { return 14; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 13: return IfcUtil::Argument_ENUMERATION; } return IfcWorkControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 13: return Type::IfcWorkScheduleTypeEnum; } return IfcWorkControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 13: return "PredefinedType"; } 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, boost::optional< std::string > v6_Identification, std::string v7_CreationDate, boost::optional< IfcTemplatedEntityList< IfcPerson >::ptr > v8_Creators, boost::optional< std::string > v9_Purpose, boost::optional< std::string > v10_Duration, boost::optional< std::string > v11_TotalFloat, std::string v12_StartTime, boost::optional< std::string > v13_FinishTime, boost::optional< IfcWorkScheduleTypeEnum::IfcWorkScheduleTypeEnum > v14_PredefinedType); @@ -39003,13 +35094,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. std::string LongName() const; void setLongName(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 IfcSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLabel; } return IfcSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "LongName"; } 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(); 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, boost::optional< std::string > v6_LongName); @@ -39080,13 +35165,7 @@ public: /// IFC2x4 CHANGE The attribute has been added. std::string LongDescription() const; void setLongDescription(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_ENUMERATION; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_STRING; } return IfcControl::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 6: return Type::IfcActionRequestTypeEnum; case 7: return Type::IfcLabel; case 8: return Type::IfcText; } return IfcControl::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 6: return "PredefinedType"; case 7: return "Status"; case 8: return "LongDescription"; } 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, boost::optional< std::string > v6_Identification, boost::optional< IfcActionRequestTypeEnum::IfcActionRequestTypeEnum > v7_PredefinedType, boost::optional< std::string > v8_Status, boost::optional< std::string > v9_LongDescription); @@ -39123,13 +35202,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); @@ -39165,13 +35238,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); @@ -39208,13 +35275,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); @@ -39296,13 +35357,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_STRING; 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::IfcDate; case 13: return Type::IfcCostValue; } return IfcGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "Identification"; 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, boost::optional< std::string > v6_Identification, IfcCostValue* v7_OriginalValue, IfcCostValue* v8_CurrentValue, IfcCostValue* v9_TotalReplacementCost, IfcActorSelect* v10_Owner, IfcActorSelect* v11_User, IfcPerson* v12_ResponsiblePerson, boost::optional< std::string > v13_IncorporationDate, IfcCostValue* v14_DepreciatedValue); @@ -39355,13 +35410,7 @@ public: /// Identifies the predefined types of audio-visual appliance from which the type required may be set. IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum PredefinedType() const; void setPredefinedType(IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum 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::IfcAudioVisualApplianceTypeEnum; } 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(); IfcAudioVisualApplianceType (IfcAbstractEntity* e); IfcAudioVisualApplianceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum v10_PredefinedType); @@ -39433,13 +35482,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); @@ -39473,13 +35516,7 @@ public: /// The description of the knot type. This is for information only. IfcKnotType::IfcKnotType KnotSpec() const; void setKnotSpec(IfcKnotType::IfcKnotType 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_INT; case 6: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 7: return IfcUtil::Argument_ENUMERATION; } return IfcBSplineCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::UNDEFINED; case 6: return Type::IfcParameterValue; case 7: return Type::IfcKnotType; } return IfcBSplineCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "KnotMultiplicities"; case 6: return "Knots"; case 7: return "KnotSpec"; } 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(); IfcBSplineCurveWithKnots (IfcAbstractEntity* e); IfcBSplineCurveWithKnots (int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec); @@ -39588,13 +35625,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); @@ -39634,13 +35665,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); @@ -39655,13 +35680,7 @@ public: /// HISTORYÿ New entity in IFC2x4. class IfcBoundaryCurve : public IfcCompositeCurveOnSurface { public: - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcCompositeCurveOnSurface::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcCompositeCurveOnSurface::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcCompositeCurveOnSurface::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoundaryCurve (IfcAbstractEntity* e); IfcBoundaryCurve (IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect); @@ -40032,14 +36051,8 @@ 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); } - IfcTemplatedEntityList< IfcRelCoversBldgElements >::ptr HasCoverings() const; // INVERSE IfcRelCoversBldgElements::RelatingBuildingElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelCoversBldgElements >::ptr HasCoverings() const; // INVERSE IfcRelCoversBldgElements::RelatingBuildingElement + 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); @@ -40069,13 +36082,7 @@ public: /// Subtype of building element part IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum PredefinedType() const; void setPredefinedType(IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum 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 IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcBuildingElementPartTypeEnum; } return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); 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, boost::optional< IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum > v9_PredefinedType); @@ -40090,13 +36097,7 @@ public: /// Subtype of building element part IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum PredefinedType() const; void setPredefinedType(IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum 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 IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcBuildingElementPartTypeEnum; } return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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(); IfcBuildingElementPartType (IfcAbstractEntity* e); IfcBuildingElementPartType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBuildingElementPartTypeEnum::IfcBuildingElementPartTypeEnum v10_PredefinedType); @@ -40298,13 +36299,7 @@ public: bool hasPredefinedType() const; IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum PredefinedType() const; void setPredefinedType(IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum 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::IfcBuildingElementProxyTypeEnum; } 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(); 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< IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum > v9_PredefinedType); @@ -40349,13 +36344,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); @@ -40404,13 +36393,7 @@ public: /// Predefined types of distribution systems. IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum PredefinedType() const; void setPredefinedType(IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum v); - virtual unsigned int getArgumentCount() const { return 6; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 5: return IfcUtil::Argument_ENUMERATION; } return IfcSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcBuildingSystemTypeEnum; } return IfcSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "PredefinedType"; } 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(); IfcBuildingSystem (IfcAbstractEntity* e); IfcBuildingSystem (std::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< IfcBuildingSystemTypeEnum::IfcBuildingSystemTypeEnum > v6_PredefinedType); @@ -40447,13 +36430,7 @@ class IfcBurnerType : public IfcEnergyConversionDeviceType { public: IfcBurnerTypeEnum::IfcBurnerTypeEnum PredefinedType() const; void setPredefinedType(IfcBurnerTypeEnum::IfcBurnerTypeEnum 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::IfcBurnerTypeEnum; } 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(); IfcBurnerType (IfcAbstractEntity* e); IfcBurnerType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcBurnerTypeEnum::IfcBurnerTypeEnum v10_PredefinedType); @@ -40490,13 +36467,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); @@ -40539,13 +36510,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); @@ -40584,13 +36549,7 @@ public: /// Identifies the predefined types of cable fitting from which the type required may be set. IfcCableFittingTypeEnum::IfcCableFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcCableFittingTypeEnum::IfcCableFittingTypeEnum 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::IfcCableFittingTypeEnum; } 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(); IfcCableFittingType (IfcAbstractEntity* e); IfcCableFittingType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCableFittingTypeEnum::IfcCableFittingTypeEnum v10_PredefinedType); @@ -40642,13 +36601,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); @@ -40691,13 +36644,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); @@ -40752,13 +36699,7 @@ public: /// NOTE The PredefinedType shall only be used, if no type object IfcChimneyType is assigned, providing its own IfcChimneyType.PredefinedType. IfcChimneyTypeEnum::IfcChimneyTypeEnum PredefinedType() const; void setPredefinedType(IfcChimneyTypeEnum::IfcChimneyTypeEnum 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::IfcChimneyTypeEnum; } 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(); IfcChimney (IfcAbstractEntity* e); IfcChimney (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcChimneyTypeEnum::IfcChimneyTypeEnum > v9_PredefinedType); @@ -40796,13 +36737,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); @@ -40811,13 +36746,7 @@ public: class IfcCivilElement : 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(); IfcCivilElement (IfcAbstractEntity* e); IfcCivilElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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); @@ -40855,13 +36784,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); @@ -41148,13 +37071,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcColumnTypeEnum::IfcColumnTypeEnum PredefinedType() const; void setPredefinedType(IfcColumnTypeEnum::IfcColumnTypeEnum 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::IfcColumnTypeEnum; } 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(); 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, boost::optional< IfcColumnTypeEnum::IfcColumnTypeEnum > v9_PredefinedType); @@ -41407,13 +37324,7 @@ public: /// Extrusion:ÿnot applicable class IfcColumnStandardCase : public IfcColumn { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcColumn::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcColumn::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcColumn::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcColumnStandardCase (IfcAbstractEntity* e); IfcColumnStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcColumnTypeEnum::IfcColumnTypeEnum > v9_PredefinedType); @@ -41456,13 +37367,7 @@ public: /// Identifies the predefined types of communications appliance from which the type required may be set. IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum PredefinedType() const; void setPredefinedType(IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum 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::IfcCommunicationsApplianceTypeEnum; } 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(); IfcCommunicationsApplianceType (IfcAbstractEntity* e); IfcCommunicationsApplianceType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum v10_PredefinedType); @@ -41500,13 +37405,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); @@ -41544,13 +37443,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); @@ -41586,13 +37479,7 @@ public: /// IFC2x4 New attribute IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcConstructionEquipmentResourceTypeEnum; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "PredefinedType"; } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionEquipmentResourceTypeEnum::IfcConstructionEquipmentResourceTypeEnum > v11_PredefinedType); @@ -41632,13 +37519,7 @@ public: /// IFC2x4 New attribute IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcConstructionMaterialResourceTypeEnum; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "PredefinedType"; } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionMaterialResourceTypeEnum::IfcConstructionMaterialResourceTypeEnum > v11_PredefinedType); @@ -41667,13 +37548,7 @@ public: /// IFC2x4 New attribute IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum PredefinedType() const; void setPredefinedType(IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_ENUMERATION; } return IfcConstructionResource::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcConstructionProductResourceTypeEnum; } return IfcConstructionResource::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "PredefinedType"; } 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_Identification, boost::optional< std::string > v7_LongDescription, IfcResourceTime* v8_Usage, boost::optional< IfcTemplatedEntityList< IfcAppliedValue >::ptr > v9_BaseCosts, IfcPhysicalQuantity* v10_BaseQuantity, boost::optional< IfcConstructionProductResourceTypeEnum::IfcConstructionProductResourceTypeEnum > v11_PredefinedType); @@ -41713,13 +37588,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); @@ -41763,13 +37632,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); @@ -42006,15 +37869,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 CoversElements() 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); @@ -42168,13 +38025,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum PredefinedType() const; void setPredefinedType(IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum 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::IfcCurtainWallTypeEnum; } 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(); 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, boost::optional< IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum > v9_PredefinedType); @@ -42219,13 +38070,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); @@ -42411,13 +38256,7 @@ public: /// Subtype of discrete accessory IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum PredefinedType() const; void setPredefinedType(IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum 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 IfcElementComponent::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDiscreteAccessoryTypeEnum; } return IfcElementComponent::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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, boost::optional< IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum > v9_PredefinedType); @@ -42616,13 +38455,7 @@ public: /// Subtype of discrete accessory IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum PredefinedType() const; void setPredefinedType(IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum 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 IfcElementComponentType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcDiscreteAccessoryTypeEnum; } return IfcElementComponentType::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 9: return "PredefinedType"; } 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, IfcDiscreteAccessoryTypeEnum::IfcDiscreteAccessoryTypeEnum v10_PredefinedType); @@ -42670,13 +38503,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); @@ -42738,13 +38565,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); @@ -42914,14 +38735,8 @@ 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); } - IfcTemplatedEntityList< IfcRelConnectsPortToElement >::ptr HasPorts() const; // INVERSE IfcRelConnectsPortToElement::RelatedElement - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelConnectsPortToElement >::ptr HasPorts() const; // INVERSE IfcRelConnectsPortToElement::RelatedElement + 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); @@ -42997,14 +38812,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); @@ -43108,13 +38917,7 @@ public: bool hasSystemType() const; IfcDistributionSystemEnum::IfcDistributionSystemEnum SystemType() const; void setSystemType(IfcDistributionSystemEnum::IfcDistributionSystemEnum 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_ENUMERATION; case 9: return IfcUtil::Argument_ENUMERATION; } return IfcPort::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 7: return Type::IfcFlowDirectionEnum; case 8: return Type::IfcDistributionPortTypeEnum; case 9: return Type::IfcDistributionSystemEnum; } return IfcPort::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 7: return "FlowDirection"; case 8: return "PredefinedType"; case 9: return "SystemType"; } 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, boost::optional< IfcDistributionPortTypeEnum::IfcDistributionPortTypeEnum > v9_PredefinedType, boost::optional< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v10_SystemType); @@ -43174,13 +38977,7 @@ public: /// Predefined types of distribution systems. IfcDistributionSystemEnum::IfcDistributionSystemEnum PredefinedType() const; void setPredefinedType(IfcDistributionSystemEnum::IfcDistributionSystemEnum 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_ENUMERATION; } return IfcSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 5: return Type::IfcLabel; case 6: return Type::IfcDistributionSystemEnum; } return IfcSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 5: return "LongName"; case 6: return "PredefinedType"; } 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(); IfcDistributionSystem (IfcAbstractEntity* e); IfcDistributionSystem (std::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< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v7_PredefinedType); @@ -43579,13 +39376,7 @@ public: bool hasUserDefinedOperationType() const; std::string UserDefinedOperationType() const; void setUserDefinedOperationType(std::string v); - virtual unsigned int getArgumentCount() const { return 13; } - 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_ENUMERATION; case 11: return IfcUtil::Argument_ENUMERATION; case 12: return IfcUtil::Argument_STRING; } return IfcBuildingElement::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::IfcDoorTypeEnum; case 11: return Type::IfcDoorTypeOperationEnum; case 12: return Type::IfcLabel; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "OverallHeight"; case 9: return "OverallWidth"; case 10: return "PredefinedType"; case 11: return "OperationType"; case 12: return "UserDefinedOperationType"; } 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, boost::optional< IfcDoorTypeEnum::IfcDoorTypeEnum > v11_PredefinedType, boost::optional< IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum > v12_OperationType, boost::optional< std::string > v13_UserDefinedOperationType); @@ -43697,13 +39488,7 @@ public: /// Figure 98 — Door profile class IfcDoorStandardCase : public IfcDoor { public: - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDoor::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDoor::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDoor::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDoorStandardCase (IfcAbstractEntity* e); IfcDoorStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcDoorTypeEnum::IfcDoorTypeEnum > v11_PredefinedType, boost::optional< IfcDoorTypeOperationEnum::IfcDoorTypeOperationEnum > v12_OperationType, boost::optional< std::string > v13_UserDefinedOperationType); @@ -43743,13 +39528,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); @@ -43789,13 +39568,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); @@ -43832,13 +39605,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); @@ -43878,13 +39645,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); @@ -43922,13 +39683,7 @@ public: /// Identifies the predefined types of electric distribution type from which the type required may be set. IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum 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::IfcElectricDistributionBoardTypeEnum; } 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(); IfcElectricDistributionBoardType (IfcAbstractEntity* e); IfcElectricDistributionBoardType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum v10_PredefinedType); @@ -43966,13 +39721,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); @@ -44015,13 +39764,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); @@ -44059,13 +39802,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); @@ -44103,13 +39840,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); @@ -44126,13 +39857,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); @@ -44185,13 +39910,7 @@ public: bool hasPredefinedType() const; IfcEngineTypeEnum::IfcEngineTypeEnum PredefinedType() const; void setPredefinedType(IfcEngineTypeEnum::IfcEngineTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcEngineTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEngine (IfcAbstractEntity* e); IfcEngine (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEngineTypeEnum::IfcEngineTypeEnum > v9_PredefinedType); @@ -44247,13 +39966,7 @@ public: bool hasPredefinedType() const; IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum PredefinedType() const; void setPredefinedType(IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcEvaporativeCoolerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEvaporativeCooler (IfcAbstractEntity* e); IfcEvaporativeCooler (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum > v9_PredefinedType); @@ -44329,13 +40042,7 @@ public: bool hasPredefinedType() const; IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum PredefinedType() const; void setPredefinedType(IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcEvaporatorTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcEvaporator (IfcAbstractEntity* e); IfcEvaporator (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum > v9_PredefinedType); @@ -44363,14 +40070,8 @@ public: /// Predefined generic types for an external spatial element that are specified in an enumeration. There might be property sets defined specifically for each predefined type. IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum PredefinedType() const; void setPredefinedType(IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum 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 IfcExternalSpatialStructureElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcExternalSpatialElementTypeEnum; } return IfcExternalSpatialStructureElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcExternalSpatialStructureElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - IfcTemplatedEntityList< IfcRelSpaceBoundary >::ptr BoundedBy() const; // INVERSE IfcRelSpaceBoundary::RelatingSpace - bool is(Type::Enum v) const; - Type::Enum type() const; + IfcTemplatedEntityList< IfcRelSpaceBoundary >::ptr BoundedBy() const; // INVERSE IfcRelSpaceBoundary::RelatingSpace + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcExternalSpatialElement (IfcAbstractEntity* e); IfcExternalSpatialElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcExternalSpatialElementTypeEnum::IfcExternalSpatialElementTypeEnum > v9_PredefinedType); @@ -44409,13 +40110,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); @@ -44455,13 +40150,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); @@ -44505,13 +40194,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); @@ -44528,13 +40211,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); @@ -44547,13 +40224,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); @@ -44594,13 +40265,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); @@ -44692,13 +40357,7 @@ public: bool hasPredefinedType() const; IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum PredefinedType() const; void setPredefinedType(IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFlowMeterTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcFlowMeter (IfcAbstractEntity* e); IfcFlowMeter (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum > v9_PredefinedType); @@ -44711,13 +40370,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); @@ -44748,13 +40401,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); @@ -44772,13 +40419,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); @@ -44797,13 +40438,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); @@ -44816,13 +40451,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); @@ -44859,13 +40488,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, boost::optional< IfcFootingTypeEnum::IfcFootingTypeEnum > v9_PredefinedType); @@ -44927,13 +40550,7 @@ public: bool hasPredefinedType() const; IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum PredefinedType() const; void setPredefinedType(IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcHeatExchangerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcHeatExchanger (IfcAbstractEntity* e); IfcHeatExchanger (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum > v9_PredefinedType); @@ -44988,13 +40605,7 @@ public: bool hasPredefinedType() const; IfcHumidifierTypeEnum::IfcHumidifierTypeEnum PredefinedType() const; void setPredefinedType(IfcHumidifierTypeEnum::IfcHumidifierTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcHumidifierTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcHumidifier (IfcAbstractEntity* e); IfcHumidifier (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcHumidifierTypeEnum::IfcHumidifierTypeEnum > v9_PredefinedType); @@ -45063,13 +40674,7 @@ public: bool hasPredefinedType() const; IfcInterceptorTypeEnum::IfcInterceptorTypeEnum PredefinedType() const; void setPredefinedType(IfcInterceptorTypeEnum::IfcInterceptorTypeEnum 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 IfcFlowTreatmentDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcInterceptorTypeEnum; } return IfcFlowTreatmentDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTreatmentDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcInterceptor (IfcAbstractEntity* e); IfcInterceptor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcInterceptorTypeEnum::IfcInterceptorTypeEnum > v9_PredefinedType); @@ -45147,13 +40752,7 @@ public: bool hasPredefinedType() const; IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum PredefinedType() const; void setPredefinedType(IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum 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 IfcFlowFitting::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcJunctionBoxTypeEnum; } return IfcFlowFitting::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowFitting::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcJunctionBox (IfcAbstractEntity* e); IfcJunctionBox (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum > v9_PredefinedType); @@ -45212,13 +40811,7 @@ public: bool hasPredefinedType() const; IfcLampTypeEnum::IfcLampTypeEnum PredefinedType() const; void setPredefinedType(IfcLampTypeEnum::IfcLampTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcLampTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLamp (IfcAbstractEntity* e); IfcLamp (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcLampTypeEnum::IfcLampTypeEnum > v9_PredefinedType); @@ -45296,13 +40889,7 @@ public: bool hasPredefinedType() const; IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum PredefinedType() const; void setPredefinedType(IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcLightFixtureTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcLightFixture (IfcAbstractEntity* e); IfcLightFixture (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum > v9_PredefinedType); @@ -45358,13 +40945,7 @@ public: bool hasPredefinedType() const; IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcMedicalDeviceTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMedicalDevice (IfcAbstractEntity* e); IfcMedicalDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMedicalDeviceTypeEnum::IfcMedicalDeviceTypeEnum > v9_PredefinedType); @@ -45630,13 +41211,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcMemberTypeEnum::IfcMemberTypeEnum PredefinedType() const; void setPredefinedType(IfcMemberTypeEnum::IfcMemberTypeEnum 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::IfcMemberTypeEnum; } 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(); 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, boost::optional< IfcMemberTypeEnum::IfcMemberTypeEnum > v9_PredefinedType); @@ -45883,13 +41458,7 @@ public: /// Extrusion:ÿnot applicable class IfcMemberStandardCase : public IfcMember { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcMember::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcMember::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcMember::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMemberStandardCase (IfcAbstractEntity* e); IfcMemberStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMemberTypeEnum::IfcMemberTypeEnum > v9_PredefinedType); @@ -45942,13 +41511,7 @@ public: bool hasPredefinedType() const; IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum PredefinedType() const; void setPredefinedType(IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcMotorConnectionTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcMotorConnection (IfcAbstractEntity* e); IfcMotorConnection (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum > v9_PredefinedType); @@ -45961,13 +41524,7 @@ public: /// HISTORYÿ New entity in IFC2x4. class IfcOuterBoundaryCurve : public IfcBoundaryCurve { public: - virtual unsigned int getArgumentCount() const { return 2; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBoundaryCurve::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBoundaryCurve::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBoundaryCurve::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOuterBoundaryCurve (IfcAbstractEntity* e); IfcOuterBoundaryCurve (IfcTemplatedEntityList< IfcCompositeCurveSegment >::ptr v1_Segments, bool v2_SelfIntersect); @@ -46045,13 +41602,7 @@ public: bool hasPredefinedType() const; IfcOutletTypeEnum::IfcOutletTypeEnum PredefinedType() const; void setPredefinedType(IfcOutletTypeEnum::IfcOutletTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcOutletTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcOutlet (IfcAbstractEntity* e); IfcOutlet (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcOutletTypeEnum::IfcOutletTypeEnum > v9_PredefinedType); @@ -46091,13 +41642,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, boost::optional< IfcPileTypeEnum::IfcPileTypeEnum > v9_PredefinedType, boost::optional< IfcPileConstructionEnum::IfcPileConstructionEnum > v10_ConstructionType); @@ -46194,13 +41739,7 @@ public: bool hasPredefinedType() const; IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum 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 IfcFlowFitting::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPipeFittingTypeEnum; } return IfcFlowFitting::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowFitting::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPipeFitting (IfcAbstractEntity* e); IfcPipeFitting (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum > v9_PredefinedType); @@ -46272,13 +41811,7 @@ public: bool hasPredefinedType() const; IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum PredefinedType() const; void setPredefinedType(IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum 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 IfcFlowSegment::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPipeSegmentTypeEnum; } return IfcFlowSegment::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowSegment::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPipeSegment (IfcAbstractEntity* e); IfcPipeSegment (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum > v9_PredefinedType); @@ -46522,13 +42055,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcPlateTypeEnum::IfcPlateTypeEnum PredefinedType() const; void setPredefinedType(IfcPlateTypeEnum::IfcPlateTypeEnum 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::IfcPlateTypeEnum; } 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(); 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, boost::optional< IfcPlateTypeEnum::IfcPlateTypeEnum > v9_PredefinedType); @@ -46689,13 +42216,7 @@ public: /// Figure 110 — Plate body clipping class IfcPlateStandardCase : public IfcPlate { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcPlate::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcPlate::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcPlate::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPlateStandardCase (IfcAbstractEntity* e); IfcPlateStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPlateTypeEnum::IfcPlateTypeEnum > v9_PredefinedType); @@ -46783,13 +42304,7 @@ public: bool hasPredefinedType() const; IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcProtectiveDeviceTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcProtectiveDevice (IfcAbstractEntity* e); IfcProtectiveDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum > v9_PredefinedType); @@ -46840,13 +42355,7 @@ public: /// Identifies the predefined types of protective device tripping unit types from which the type required may be set. IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum PredefinedType() const; void setPredefinedType(IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum 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::IfcProtectiveDeviceTrippingUnitTypeEnum; } 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(); IfcProtectiveDeviceTrippingUnitType (IfcAbstractEntity* e); IfcProtectiveDeviceTrippingUnitType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum v10_PredefinedType); @@ -46907,13 +42416,7 @@ public: bool hasPredefinedType() const; IfcPumpTypeEnum::IfcPumpTypeEnum PredefinedType() const; void setPredefinedType(IfcPumpTypeEnum::IfcPumpTypeEnum 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 IfcFlowMovingDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcPumpTypeEnum; } return IfcFlowMovingDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowMovingDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcPump (IfcAbstractEntity* e); IfcPump (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcPumpTypeEnum::IfcPumpTypeEnum > v9_PredefinedType); @@ -47060,13 +42563,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); @@ -47216,13 +42713,7 @@ public: /// IFC2x4 CHANGE The attribute has been renamed from ShapeType and changed to be OPTIONAL with upward compatibility for file based exchange. IfcRampTypeEnum::IfcRampTypeEnum PredefinedType() const; void setPredefinedType(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 "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(); 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, boost::optional< IfcRampTypeEnum::IfcRampTypeEnum > v9_PredefinedType); @@ -47426,13 +42917,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcRampFlightTypeEnum::IfcRampFlightTypeEnum PredefinedType() const; void setPredefinedType(IfcRampFlightTypeEnum::IfcRampFlightTypeEnum 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::IfcRampFlightTypeEnum; } 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(); 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, boost::optional< IfcRampFlightTypeEnum::IfcRampFlightTypeEnum > v9_PredefinedType); @@ -47479,13 +42964,7 @@ public: /// The supplied values of the weights. std::vector< double > /*[2:?]*/ WeightsData() const; void setWeightsData(std::vector< double > /*[2:?]*/ 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_DOUBLE; } return IfcBSplineCurveWithKnots::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::UNDEFINED; } return IfcBSplineCurveWithKnots::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "WeightsData"; } return IfcBSplineCurveWithKnots::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcRationalBSplineCurveWithKnots (IfcAbstractEntity* e); IfcRationalBSplineCurveWithKnots (int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec, std::vector< double > /*[2:?]*/ v9_WeightsData); @@ -47542,13 +43021,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::IfcReinforcingBarTypeEnum; 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 "PredefinedType"; 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, boost::optional< double > v10_NominalDiameter, boost::optional< double > v11_CrossSectionArea, boost::optional< double > v12_BarLength, boost::optional< IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum > v13_PredefinedType, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface); @@ -47603,13 +43076,7 @@ public: bool hasBendingParameters() const; IfcEntityList::ptr BendingParameters() const; void setBendingParameters(IfcEntityList::ptr v); - virtual unsigned int getArgumentCount() const { return 16; } - 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_ENUMERATION; case 14: return IfcUtil::Argument_STRING; case 15: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } return IfcReinforcingElementType::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 9: return Type::IfcReinforcingBarTypeEnum; case 10: return Type::IfcPositiveLengthMeasure; case 11: return Type::IfcAreaMeasure; case 12: return Type::IfcPositiveLengthMeasure; case 13: return Type::IfcReinforcingBarSurfaceEnum; case 14: return Type::IfcLabel; case 15: return Type::IfcBendingParameterSelect; } return IfcReinforcingElementType::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 "BarLength"; case 13: return "BarSurface"; case 14: return "BendingShapeCode"; case 15: return "BendingParameters"; } return IfcReinforcingElementType::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcReinforcingBarType (IfcAbstractEntity* e); IfcReinforcingBarType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcReinforcingBarTypeEnum::IfcReinforcingBarTypeEnum v10_PredefinedType, boost::optional< double > v11_NominalDiameter, boost::optional< double > v12_CrossSectionArea, boost::optional< double > v13_BarLength, boost::optional< IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum > v14_BarSurface, boost::optional< std::string > v15_BendingShapeCode, boost::optional< IfcEntityList::ptr > v16_BendingParameters); @@ -47769,13 +43236,7 @@ public: /// IFC2x4 CHANGE The attribute has been renamed from ShapeType and changed to be OPTIONAL with upward compatibility for file based exchange. IfcRoofTypeEnum::IfcRoofTypeEnum PredefinedType() const; void setPredefinedType(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 "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(); 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, boost::optional< IfcRoofTypeEnum::IfcRoofTypeEnum > v9_PredefinedType); @@ -47913,13 +43374,7 @@ public: bool hasPredefinedType() const; IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSanitaryTerminalTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSanitaryTerminal (IfcAbstractEntity* e); IfcSanitaryTerminal (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum > v9_PredefinedType); @@ -47978,13 +43433,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); @@ -48012,13 +43461,7 @@ public: /// NOTE The PredefinedType shall only be used, if no type object IfcShadingDeviceType is assigned, providing its own IfcShadingDeviceType.PredefinedType. IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum 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::IfcShadingDeviceTypeEnum; } 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(); IfcShadingDevice (IfcAbstractEntity* e); IfcShadingDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcShadingDeviceTypeEnum::IfcShadingDeviceTypeEnum > v9_PredefinedType); @@ -48294,13 +43737,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); @@ -48391,13 +43828,7 @@ public: /// decomposition. class IfcSlabElementedCase : public IfcSlab { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcSlab::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcSlab::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcSlab::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSlabElementedCase (IfcAbstractEntity* e); IfcSlabElementedCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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); @@ -48564,13 +43995,7 @@ public: /// Figure 126 — Slab body clipping class IfcSlabStandardCase : public IfcSlab { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcSlab::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcSlab::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcSlab::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSlabStandardCase (IfcAbstractEntity* e); IfcSlabStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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); @@ -48629,13 +44054,7 @@ public: bool hasPredefinedType() const; IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSolarDeviceTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSolarDevice (IfcAbstractEntity* e); IfcSolarDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSolarDeviceTypeEnum::IfcSolarDeviceTypeEnum > v9_PredefinedType); @@ -48709,13 +44128,7 @@ public: bool hasPredefinedType() const; IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum PredefinedType() const; void setPredefinedType(IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSpaceHeaterTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSpaceHeater (IfcAbstractEntity* e); IfcSpaceHeater (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum > v9_PredefinedType); @@ -48777,13 +44190,7 @@ public: bool hasPredefinedType() const; IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcStackTerminalTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStackTerminal (IfcAbstractEntity* e); IfcStackTerminal (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum > v9_PredefinedType); @@ -48963,13 +44370,7 @@ public: /// IFC2x4 CHANGE The attribute has been renamed from ShapeType and changed to be OPTIONAL with upward compatibility for file based exchange. IfcStairTypeEnum::IfcStairTypeEnum PredefinedType() const; void setPredefinedType(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 "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(); 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, boost::optional< IfcStairTypeEnum::IfcStairTypeEnum > v9_PredefinedType); @@ -49180,13 +44581,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcStairFlightTypeEnum::IfcStairFlightTypeEnum PredefinedType() const; void setPredefinedType(IfcStairFlightTypeEnum::IfcStairFlightTypeEnum v); - virtual unsigned int getArgumentCount() const { return 13; } - 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; case 12: return IfcUtil::Argument_ENUMERATION; } 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; case 12: return Type::IfcStairFlightTypeEnum; } 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"; case 12: 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(); 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, boost::optional< IfcStairFlightTypeEnum::IfcStairFlightTypeEnum > v13_PredefinedType); @@ -49253,13 +44648,7 @@ public: /// NOTE  Per informal proposition, this attribute is not optional as soon as at least one IfcStructuralItem is grouped into the instance of IfcStructuralAnalysisModel. IfcObjectPlacement* SharedPlacement() const; void setSharedPlacement(IfcObjectPlacement* 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_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 9: return IfcUtil::Argument_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; case 9: return Type::IfcObjectPlacement; } 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"; case 9: return "SharedPlacement"; } 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, IfcObjectPlacement* v10_SharedPlacement); @@ -49279,13 +44668,7 @@ public: /// The overall coefficient in the inherited attribute Coefficient shall not be applied to SelfWeightCoefficients of the same instance of IfcStructuralLoadCase. It only applies to actions and load groups which are grouped below the load case, not to the load case's computed self weight. std::vector< double > /*[3:3]*/ SelfWeightCoefficients() const; void setSelfWeightCoefficients(std::vector< double > /*[3:3]*/ v); - virtual unsigned int getArgumentCount() const { return 11; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 10: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } return IfcStructuralLoadGroup::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 10: return Type::IfcRatioMeasure; } return IfcStructuralLoadGroup::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 10: return "SelfWeightCoefficients"; } return IfcStructuralLoadGroup::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcStructuralLoadCase (IfcAbstractEntity* e); IfcStructuralLoadCase (std::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, boost::optional< std::vector< double > /*[3:3]*/ > v11_SelfWeightCoefficients); @@ -49300,13 +44683,7 @@ public: /// NOTE  Like its supertype IfcStructuralSurfaceAction, this action type may also act on curved faces. class IfcStructuralPlanarAction : public IfcStructuralSurfaceAction { public: - virtual unsigned int getArgumentCount() const { return 12; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcStructuralSurfaceAction::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcStructuralSurfaceAction::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcStructuralSurfaceAction::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { 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, boost::optional< bool > v10_DestabilizingLoad, boost::optional< IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum > v11_ProjectedOrTrue, IfcStructuralSurfaceActivityTypeEnum::IfcStructuralSurfaceActivityTypeEnum v12_PredefinedType); @@ -49406,13 +44783,7 @@ public: bool hasPredefinedType() const; IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSwitchingDeviceTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcSwitchingDevice (IfcAbstractEntity* e); IfcSwitchingDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum > v9_PredefinedType); @@ -49484,13 +44855,7 @@ public: bool hasPredefinedType() const; IfcTankTypeEnum::IfcTankTypeEnum PredefinedType() const; void setPredefinedType(IfcTankTypeEnum::IfcTankTypeEnum 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 IfcFlowStorageDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcTankTypeEnum; } return IfcFlowStorageDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowStorageDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTank (IfcAbstractEntity* e); IfcTank (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTankTypeEnum::IfcTankTypeEnum > v9_PredefinedType); @@ -49544,13 +44909,7 @@ public: bool hasPredefinedType() const; IfcTransformerTypeEnum::IfcTransformerTypeEnum PredefinedType() const; void setPredefinedType(IfcTransformerTypeEnum::IfcTransformerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcTransformerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTransformer (IfcAbstractEntity* e); IfcTransformer (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTransformerTypeEnum::IfcTransformerTypeEnum > v9_PredefinedType); @@ -49609,13 +44968,7 @@ public: bool hasPredefinedType() const; IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum PredefinedType() const; void setPredefinedType(IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcTubeBundleTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcTubeBundle (IfcAbstractEntity* e); IfcTubeBundle (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum > v9_PredefinedType); @@ -49652,13 +45005,7 @@ public: /// Identifies the predefined types of unitary control element from which the type required may be set. IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum PredefinedType() const; void setPredefinedType(IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum 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::IfcUnitaryControlElementTypeEnum; } 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(); IfcUnitaryControlElementType (IfcAbstractEntity* e); IfcUnitaryControlElementType (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, boost::optional< std::string > v3_Name, boost::optional< std::string > v4_Description, boost::optional< std::string > v5_ApplicableOccurrence, boost::optional< IfcTemplatedEntityList< IfcPropertySetDefinition >::ptr > v6_HasPropertySets, boost::optional< IfcTemplatedEntityList< IfcRepresentationMap >::ptr > v7_RepresentationMaps, boost::optional< std::string > v8_Tag, boost::optional< std::string > v9_ElementType, IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum v10_PredefinedType); @@ -49742,13 +45089,7 @@ public: bool hasPredefinedType() const; IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum PredefinedType() const; void setPredefinedType(IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcUnitaryEquipmentTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcUnitaryEquipment (IfcAbstractEntity* e); IfcUnitaryEquipment (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum > v9_PredefinedType); @@ -49946,13 +45287,7 @@ public: bool hasPredefinedType() const; IfcValveTypeEnum::IfcValveTypeEnum PredefinedType() const; void setPredefinedType(IfcValveTypeEnum::IfcValveTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcValveTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcValve (IfcAbstractEntity* e); IfcValve (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcValveTypeEnum::IfcValveTypeEnum > v9_PredefinedType); @@ -50210,13 +45545,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcWallTypeEnum::IfcWallTypeEnum PredefinedType() const; void setPredefinedType(IfcWallTypeEnum::IfcWallTypeEnum 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::IfcWallTypeEnum; } 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(); 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, boost::optional< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType); @@ -50322,13 +45651,7 @@ public: /// decomposition. class IfcWallElementedCase : public IfcWall { public: - virtual unsigned int getArgumentCount() const { return 9; } - 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(); IfcWallElementedCase (IfcAbstractEntity* e); IfcWallElementedCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType); @@ -50538,13 +45861,7 @@ public: /// Figure 140 — Wall body clipping curved class IfcWallStandardCase : public IfcWall { public: - virtual unsigned int getArgumentCount() const { return 9; } - 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, boost::optional< IfcWallTypeEnum::IfcWallTypeEnum > v9_PredefinedType); @@ -50660,13 +45977,7 @@ public: bool hasPredefinedType() const; IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcWasteTerminalTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWasteTerminal (IfcAbstractEntity* e); IfcWasteTerminal (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum > v9_PredefinedType); @@ -51067,13 +46378,7 @@ public: bool hasUserDefinedPartitioningType() const; std::string UserDefinedPartitioningType() const; void setUserDefinedPartitioningType(std::string v); - virtual unsigned int getArgumentCount() const { return 13; } - 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_ENUMERATION; case 11: return IfcUtil::Argument_ENUMERATION; case 12: return IfcUtil::Argument_STRING; } return IfcBuildingElement::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::IfcWindowTypeEnum; case 11: return Type::IfcWindowTypePartitioningEnum; case 12: return Type::IfcLabel; } return IfcBuildingElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "OverallHeight"; case 9: return "OverallWidth"; case 10: return "PredefinedType"; case 11: return "PartitioningType"; case 12: return "UserDefinedPartitioningType"; } 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, boost::optional< IfcWindowTypeEnum::IfcWindowTypeEnum > v11_PredefinedType, boost::optional< IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum > v12_PartitioningType, boost::optional< std::string > v13_UserDefinedPartitioningType); @@ -51195,13 +46500,7 @@ public: /// Figure 145 — Window profile class IfcWindowStandardCase : public IfcWindow { public: - virtual unsigned int getArgumentCount() const { return 13; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcWindow::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcWindow::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcWindow::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcWindowStandardCase (IfcAbstractEntity* e); IfcWindowStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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, boost::optional< IfcWindowTypeEnum::IfcWindowTypeEnum > v11_PredefinedType, boost::optional< IfcWindowTypePartitioningEnum::IfcWindowTypePartitioningEnum > v12_PartitioningType, boost::optional< std::string > v13_UserDefinedPartitioningType); @@ -51243,13 +46542,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); @@ -51318,13 +46611,7 @@ public: bool hasPredefinedType() const; IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAirTerminalTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAirTerminal (IfcAbstractEntity* e); IfcAirTerminal (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum > v9_PredefinedType); @@ -51378,13 +46665,7 @@ public: bool hasPredefinedType() const; IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum PredefinedType() const; void setPredefinedType(IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAirTerminalBoxTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcAirTerminalBox (IfcAbstractEntity* e); IfcAirTerminalBox (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum > v9_PredefinedType); @@ -51441,13 +46722,7 @@ public: bool hasPredefinedType() const; IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum PredefinedType() const; void setPredefinedType(IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAirToAirHeatRecoveryTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAirToAirHeatRecovery (IfcAbstractEntity* e); IfcAirToAirHeatRecovery (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum > v9_PredefinedType); @@ -51484,13 +46759,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); @@ -51680,13 +46949,7 @@ public: bool hasPredefinedType() const; IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum PredefinedType() const; void setPredefinedType(IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAudioVisualApplianceTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAudioVisualAppliance (IfcAbstractEntity* e); IfcAudioVisualAppliance (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAudioVisualApplianceTypeEnum::IfcAudioVisualApplianceTypeEnum > v9_PredefinedType); @@ -51939,13 +47202,7 @@ public: /// IFC2x4 CHANGE The attribute has been added at the end of the entity definition. IfcBeamTypeEnum::IfcBeamTypeEnum PredefinedType() const; void setPredefinedType(IfcBeamTypeEnum::IfcBeamTypeEnum 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::IfcBeamTypeEnum; } 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(); 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, boost::optional< IfcBeamTypeEnum::IfcBeamTypeEnum > v9_PredefinedType); @@ -52204,13 +47461,7 @@ public: /// Extrusion: not applicable class IfcBeamStandardCase : public IfcBeam { public: - virtual unsigned int getArgumentCount() const { return 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcBeam::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcBeam::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcBeam::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBeamStandardCase (IfcAbstractEntity* e); IfcBeamStandardCase (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBeamTypeEnum::IfcBeamTypeEnum > v9_PredefinedType); @@ -52291,13 +47542,7 @@ public: bool hasPredefinedType() const; IfcBoilerTypeEnum::IfcBoilerTypeEnum PredefinedType() const; void setPredefinedType(IfcBoilerTypeEnum::IfcBoilerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcBoilerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBoiler (IfcAbstractEntity* e); IfcBoiler (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBoilerTypeEnum::IfcBoilerTypeEnum > v9_PredefinedType); @@ -52350,13 +47595,7 @@ public: bool hasPredefinedType() const; IfcBurnerTypeEnum::IfcBurnerTypeEnum PredefinedType() const; void setPredefinedType(IfcBurnerTypeEnum::IfcBurnerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcBurnerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcBurner (IfcAbstractEntity* e); IfcBurner (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcBurnerTypeEnum::IfcBurnerTypeEnum > v9_PredefinedType); @@ -52430,13 +47669,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 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcFlowFitting::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCableCarrierFittingTypeEnum; } return IfcFlowFitting::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowFitting::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableCarrierFitting (IfcAbstractEntity* e); IfcCableCarrierFitting (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum > v9_PredefinedType); @@ -52508,13 +47741,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 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcFlowSegment::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCableCarrierSegmentTypeEnum; } return IfcFlowSegment::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowSegment::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableCarrierSegment (IfcAbstractEntity* e); IfcCableCarrierSegment (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum > v9_PredefinedType); @@ -52601,13 +47828,7 @@ public: /// Identifies the predefined types of cable fitting from which the type required may be set. IfcCableFittingTypeEnum::IfcCableFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcCableFittingTypeEnum::IfcCableFittingTypeEnum 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 IfcFlowFitting::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCableFittingTypeEnum; } return IfcFlowFitting::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowFitting::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableFitting (IfcAbstractEntity* e); IfcCableFitting (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableFittingTypeEnum::IfcCableFittingTypeEnum > v9_PredefinedType); @@ -52707,13 +47928,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 9; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 8: return IfcUtil::Argument_ENUMERATION; } return IfcFlowSegment::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCableSegmentTypeEnum; } return IfcFlowSegment::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowSegment::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCableSegment (IfcAbstractEntity* e); IfcCableSegment (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum > v9_PredefinedType); @@ -52794,13 +48009,7 @@ public: bool hasPredefinedType() const; IfcChillerTypeEnum::IfcChillerTypeEnum PredefinedType() const; void setPredefinedType(IfcChillerTypeEnum::IfcChillerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcChillerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcChiller (IfcAbstractEntity* e); IfcChiller (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcChillerTypeEnum::IfcChillerTypeEnum > v9_PredefinedType); @@ -52878,13 +48087,7 @@ public: bool hasPredefinedType() const; IfcCoilTypeEnum::IfcCoilTypeEnum PredefinedType() const; void setPredefinedType(IfcCoilTypeEnum::IfcCoilTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCoilTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoil (IfcAbstractEntity* e); IfcCoil (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCoilTypeEnum::IfcCoilTypeEnum > v9_PredefinedType); @@ -52998,13 +48201,7 @@ public: bool hasPredefinedType() const; IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum PredefinedType() const; void setPredefinedType(IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCommunicationsApplianceTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCommunicationsAppliance (IfcAbstractEntity* e); IfcCommunicationsAppliance (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCommunicationsApplianceTypeEnum::IfcCommunicationsApplianceTypeEnum > v9_PredefinedType); @@ -53062,13 +48259,7 @@ public: bool hasPredefinedType() const; IfcCompressorTypeEnum::IfcCompressorTypeEnum PredefinedType() const; void setPredefinedType(IfcCompressorTypeEnum::IfcCompressorTypeEnum 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 IfcFlowMovingDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCompressorTypeEnum; } return IfcFlowMovingDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowMovingDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCompressor (IfcAbstractEntity* e); IfcCompressor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCompressorTypeEnum::IfcCompressorTypeEnum > v9_PredefinedType); @@ -53146,13 +48337,7 @@ public: bool hasPredefinedType() const; IfcCondenserTypeEnum::IfcCondenserTypeEnum PredefinedType() const; void setPredefinedType(IfcCondenserTypeEnum::IfcCondenserTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCondenserTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCondenser (IfcAbstractEntity* e); IfcCondenser (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCondenserTypeEnum::IfcCondenserTypeEnum > v9_PredefinedType); @@ -53199,13 +48384,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); @@ -53266,13 +48445,7 @@ public: bool hasPredefinedType() const; IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum PredefinedType() const; void setPredefinedType(IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCooledBeamTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCooledBeam (IfcAbstractEntity* e); IfcCooledBeam (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum > v9_PredefinedType); @@ -53341,13 +48514,7 @@ public: bool hasPredefinedType() const; IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum PredefinedType() const; void setPredefinedType(IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcCoolingTowerTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcCoolingTower (IfcAbstractEntity* e); IfcCoolingTower (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum > v9_PredefinedType); @@ -53430,13 +48597,7 @@ public: bool hasPredefinedType() const; IfcDamperTypeEnum::IfcDamperTypeEnum PredefinedType() const; void setPredefinedType(IfcDamperTypeEnum::IfcDamperTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDamperTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcDamper (IfcAbstractEntity* e); IfcDamper (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDamperTypeEnum::IfcDamperTypeEnum > v9_PredefinedType); @@ -53479,13 +48640,7 @@ public: bool hasPredefinedType() const; IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum PredefinedType() const; void setPredefinedType(IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum 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 IfcDistributionFlowElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDistributionChamberElementTypeEnum; } return IfcDistributionFlowElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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, boost::optional< IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum > v9_PredefinedType); @@ -53494,13 +48649,7 @@ public: class IfcDistributionCircuit : public IfcDistributionSystem { public: - virtual unsigned int getArgumentCount() const { return 7; } - virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { return IfcDistributionSystem::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { return IfcDistributionSystem::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { return IfcDistributionSystem::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDistributionCircuit (IfcAbstractEntity* e); IfcDistributionCircuit (std::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< IfcDistributionSystemEnum::IfcDistributionSystemEnum > v7_PredefinedType); @@ -53586,14 +48735,8 @@ public: /// If materials are defined, geometry of each representation (most typically the 'Body' representation) may be organized into shape aspects where styles may be derived by correlating IfcShapeAspect.Name to a corresponding material (IfcMaterialConstituent.Name). class IfcDistributionControlElement : 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 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); @@ -53680,13 +48823,7 @@ public: bool hasPredefinedType() const; IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum PredefinedType() const; void setPredefinedType(IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum 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 IfcFlowFitting::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDuctFittingTypeEnum; } return IfcFlowFitting::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowFitting::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDuctFitting (IfcAbstractEntity* e); IfcDuctFitting (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum > v9_PredefinedType); @@ -53747,13 +48884,7 @@ public: bool hasPredefinedType() const; IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum PredefinedType() const; void setPredefinedType(IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum 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 IfcFlowSegment::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDuctSegmentTypeEnum; } return IfcFlowSegment::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowSegment::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDuctSegment (IfcAbstractEntity* e); IfcDuctSegment (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum > v9_PredefinedType); @@ -53807,13 +48938,7 @@ public: bool hasPredefinedType() const; IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum PredefinedType() const; void setPredefinedType(IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum 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 IfcFlowTreatmentDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcDuctSilencerTypeEnum; } return IfcFlowTreatmentDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTreatmentDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcDuctSilencer (IfcAbstractEntity* e); IfcDuctSilencer (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum > v9_PredefinedType); @@ -53923,13 +49048,7 @@ public: bool hasPredefinedType() const; IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricApplianceTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricAppliance (IfcAbstractEntity* e); IfcElectricAppliance (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum > v9_PredefinedType); @@ -53998,13 +49117,7 @@ public: bool hasPredefinedType() const; IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricDistributionBoardTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcElectricDistributionBoard (IfcAbstractEntity* e); IfcElectricDistributionBoard (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricDistributionBoardTypeEnum::IfcElectricDistributionBoardTypeEnum > v9_PredefinedType); @@ -54057,13 +49170,7 @@ public: bool hasPredefinedType() const; IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum 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 IfcFlowStorageDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricFlowStorageDeviceTypeEnum; } return IfcFlowStorageDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowStorageDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricFlowStorageDevice (IfcAbstractEntity* e); IfcElectricFlowStorageDevice (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum > v9_PredefinedType); @@ -54122,13 +49229,7 @@ public: bool hasPredefinedType() const; IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricGeneratorTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricGenerator (IfcAbstractEntity* e); IfcElectricGenerator (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum > v9_PredefinedType); @@ -54181,13 +49282,7 @@ public: bool hasPredefinedType() const; IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum 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 IfcEnergyConversionDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricMotorTypeEnum; } return IfcEnergyConversionDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcEnergyConversionDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcElectricMotor (IfcAbstractEntity* e); IfcElectricMotor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum > v9_PredefinedType); @@ -54240,13 +49335,7 @@ public: bool hasPredefinedType() const; IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum PredefinedType() const; void setPredefinedType(IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum 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 IfcFlowController::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcElectricTimeControlTypeEnum; } return IfcFlowController::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } 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(); IfcElectricTimeControl (IfcAbstractEntity* e); IfcElectricTimeControl (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum > v9_PredefinedType); @@ -54312,13 +49401,7 @@ public: bool hasPredefinedType() const; IfcFanTypeEnum::IfcFanTypeEnum PredefinedType() const; void setPredefinedType(IfcFanTypeEnum::IfcFanTypeEnum 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 IfcFlowMovingDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFanTypeEnum; } return IfcFlowMovingDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowMovingDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFan (IfcAbstractEntity* e); IfcFan (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFanTypeEnum::IfcFanTypeEnum > v9_PredefinedType); @@ -54417,13 +49500,7 @@ public: bool hasPredefinedType() const; IfcFilterTypeEnum::IfcFilterTypeEnum PredefinedType() const; void setPredefinedType(IfcFilterTypeEnum::IfcFilterTypeEnum 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 IfcFlowTreatmentDevice::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFilterTypeEnum; } return IfcFlowTreatmentDevice::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTreatmentDevice::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFilter (IfcAbstractEntity* e); IfcFilter (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFilterTypeEnum::IfcFilterTypeEnum > v9_PredefinedType); @@ -54501,13 +49578,7 @@ public: bool hasPredefinedType() const; IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum PredefinedType() const; void setPredefinedType(IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum 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 IfcFlowTerminal::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFireSuppressionTerminalTypeEnum; } return IfcFlowTerminal::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcFlowTerminal::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFireSuppressionTerminal (IfcAbstractEntity* e); IfcFireSuppressionTerminal (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum > v9_PredefinedType); @@ -54571,13 +49642,7 @@ public: bool hasPredefinedType() const; IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum PredefinedType() const; void setPredefinedType(IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcFlowInstrumentTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcFlowInstrument (IfcAbstractEntity* e); IfcFlowInstrument (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum > v9_PredefinedType); @@ -54641,13 +49706,7 @@ public: bool hasPredefinedType() const; IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum PredefinedType() const; void setPredefinedType(IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcProtectiveDeviceTrippingUnitTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcProtectiveDeviceTrippingUnit (IfcAbstractEntity* e); IfcProtectiveDeviceTrippingUnit (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcProtectiveDeviceTrippingUnitTypeEnum::IfcProtectiveDeviceTrippingUnitTypeEnum > v9_PredefinedType); @@ -54793,13 +49852,7 @@ public: bool hasPredefinedType() const; IfcSensorTypeEnum::IfcSensorTypeEnum PredefinedType() const; void setPredefinedType(IfcSensorTypeEnum::IfcSensorTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcSensorTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcSensor (IfcAbstractEntity* e); IfcSensor (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcSensorTypeEnum::IfcSensorTypeEnum > v9_PredefinedType); @@ -54866,13 +49919,7 @@ public: bool hasPredefinedType() const; IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum PredefinedType() const; void setPredefinedType(IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcUnitaryControlElementTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcUnitaryControlElement (IfcAbstractEntity* e); IfcUnitaryControlElement (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcUnitaryControlElementTypeEnum::IfcUnitaryControlElementTypeEnum > v9_PredefinedType); @@ -54946,13 +49993,7 @@ public: bool hasPredefinedType() const; IfcActuatorTypeEnum::IfcActuatorTypeEnum PredefinedType() const; void setPredefinedType(IfcActuatorTypeEnum::IfcActuatorTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcActuatorTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcActuator (IfcAbstractEntity* e); IfcActuator (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcActuatorTypeEnum::IfcActuatorTypeEnum > v9_PredefinedType); @@ -55006,13 +50047,7 @@ public: bool hasPredefinedType() const; IfcAlarmTypeEnum::IfcAlarmTypeEnum PredefinedType() const; void setPredefinedType(IfcAlarmTypeEnum::IfcAlarmTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcAlarmTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcAlarm (IfcAbstractEntity* e); IfcAlarm (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcAlarmTypeEnum::IfcAlarmTypeEnum > v9_PredefinedType); @@ -55130,13 +50165,7 @@ public: bool hasPredefinedType() const; IfcControllerTypeEnum::IfcControllerTypeEnum PredefinedType() const; void setPredefinedType(IfcControllerTypeEnum::IfcControllerTypeEnum 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 IfcDistributionControlElement::getArgumentType(i); } - virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 8: return Type::IfcControllerTypeEnum; } return IfcDistributionControlElement::getArgumentEntity(i); } - virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 8: return "PredefinedType"; } return IfcDistributionControlElement::getArgumentName(i); } - virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); } - bool is(Type::Enum v) const; - Type::Enum type() const; + virtual const IfcParse::entity& declaration() const; static Type::Enum Class(); IfcController (IfcAbstractEntity* e); IfcController (std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerHistory, 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< IfcControllerTypeEnum::IfcControllerTypeEnum > v9_PredefinedType); diff --git a/src/ifcparse/IfcFile.h b/src/ifcparse/IfcFile.h index 517e91defa..1b77265c13 100644 --- a/src/ifcparse/IfcFile.h +++ b/src/ifcparse/IfcFile.h @@ -23,6 +23,7 @@ #include #include +#include "../ifcparse/Hdf5Settings.h" #include "../ifcparse/IfcParse.h" #include "../ifcparse/IfcSpfHeader.h" @@ -36,7 +37,6 @@ public: typedef std::map entity_by_id_t; typedef std::map entity_by_guid_t; typedef std::map entities_by_ref_t; - typedef std::map offset_by_id_t; typedef entity_by_id_t::const_iterator const_iterator; private: typedef std::map entity_entity_map_t; @@ -49,7 +49,6 @@ private: entities_by_type_t bytype; entities_by_ref_t byref; entity_by_guid_t byguid; - offset_by_id_t offsets; entity_entity_map_t entity_file_map; @@ -136,7 +135,7 @@ public: const schema_definition* schema() const { return schema_; } - void write_hdf5(const std::string&, bool compress) const; + void write_hdf5(const std::string&, const Hdf5Settings&); }; } diff --git a/src/ifcparse/IfcHdf5File.cpp b/src/ifcparse/IfcHdf5File.cpp index bda48f44c2..a2f9316462 100644 --- a/src/ifcparse/IfcHdf5File.cpp +++ b/src/ifcparse/IfcHdf5File.cpp @@ -6,14 +6,37 @@ #pragma message("warning: HDF5 compression support is recommended") #endif -static bool OVERRIDE = true; - class UnmetDependencyException : public std::exception {}; +void visit(void* buffer, H5::DataType* dt) { + if (dt->getClass() == H5T_COMPOUND) { + H5::CompType* ct = (H5::CompType*) dt; + for (int i = 0; i < ct->getNmembers(); ++i) { + std::cerr << ct->getMemberName(i) << " "; + size_t offs = ct->getMemberOffset(i); + H5::DataType dt2 = ct->getMemberDataType(i); + visit((uint8_t*)buffer+offs, &dt2); + dt2.close(); + } + } else if (dt->getClass() == H5T_VLEN) { + hvl_t* ht = (hvl_t*) buffer; + H5::VarLenType* vt = (H5::VarLenType*) dt; + H5::DataType dt2 = vt->getSuper(); + for (int i = 0; i < ht->len; ++i) { + std::cerr << i << " "; + visit((uint8_t*)ht->p + i * vt->getSize(), &dt2); + } + dt2.close(); + } else if (dt->getClass() == H5T_STRING) { + char* c = *(char**)buffer; + std::cerr << "'" << c << "'" << " "; + } +} + H5::DataType* IfcParse::IfcHdf5File::map_type(const IfcParse::parameter_type* pt) { H5::DataType* h5_dt; if (pt->as_aggregation_type()) { - h5_dt = new H5::VarLenType(map_type(pt->as_aggregation_type()->type_of_element())); + h5_dt = new H5::VarLenType(map_type(pt->as_aggregation_type()->type_of_element())); } else if (pt->as_named_type()) { if (pt->as_named_type()->declared_type()->as_entity()) { h5_dt = new H5::DataType(); @@ -80,9 +103,13 @@ H5::DataType* IfcParse::IfcHdf5File::commit(H5::DataType* dt, const std::string& H5::CompType* IfcParse::IfcHdf5File::map_entity(const IfcParse::entity* e) { std::vector attributes = e->all_attributes(); + std::vector inverse_attributes; + if (settings_.instantiate_inverse()) { + inverse_attributes = e->all_inverse_attributes(); + } std::vector< IfcParse::IfcHdf5File::compound_member > h5_attributes; - h5_attributes.reserve(attributes.size() + 2); + h5_attributes.reserve(attributes.size() + inverse_attributes.size() + 2); h5_attributes.push_back(std::make_pair(std::string("set_unset_bitmap"), &H5::PredType::NATIVE_INT16)); h5_attributes.push_back(std::make_pair(std::string("Entity-Instance-Identifier"), &H5::PredType::NATIVE_INT32)); @@ -105,6 +132,16 @@ H5::CompType* IfcParse::IfcHdf5File::map_entity(const IfcParse::entity* e) { h5_attributes.push_back(std::make_pair(name, type)); } + if (settings_.instantiate_inverse()) { + for (auto it = inverse_attributes.begin(); it != inverse_attributes.end(); ++it) { + const std::string& name = (*it)->name(); + H5::DataType* ir_copy = new H5::DataType(); + ir_copy->copy(*instance_reference); + const H5::DataType* type = new H5::VarLenType(ir_copy); + h5_attributes.push_back(std::make_pair(name, type)); + } + } + return create_compound(h5_attributes); } @@ -152,10 +189,13 @@ void IfcParse::IfcHdf5File::init_default_types() { default_cpp_type_names[IfcUtil::Argument_STRING] = "string"; default_cpp_type_names[IfcUtil::Argument_INT] = "integer"; - if (OVERRIDE) { - hsize_t dims = 3; + if (settings_.fix_global_id()) { overridden_types["GlobalId"] = new H5::StrType(H5::PredType::C_S1, 22); + } + if (settings_.fix_cartesian_point()) { + hsize_t dims = 3; overridden_types["Coordinates"] = new H5::ArrayType(*default_types[simple_type::real_type], 1, &dims); + overridden_types["DirectionRatios"] = new H5::ArrayType(*default_types[simple_type::real_type], 1, &dims); } } @@ -183,6 +223,8 @@ std::string IfcParse::IfcHdf5File::flatten_aggregate_name(const IfcParse::parame } H5::DataType* IfcParse::IfcHdf5File::map_select(const IfcParse::select_type* pt) { + if (settings_.instantiate_select()) return 0; + std::set leafs; visit_select(pt, leafs); @@ -361,8 +403,11 @@ void IfcParse::IfcHdf5File::write_aggregate(void*& ptr, const IfcEntityList::ptr void* aggr_ptr = aggr_data; for (IfcEntityList::it it = ts->begin(); it != ts->end(); ++it) { auto ref = make_instance_reference(*it); - write_number_of_size(aggr_ptr, instance_reference->getMemberDataType(0).getSize(), ref.first); - write_number_of_size(aggr_ptr, instance_reference->getMemberDataType(1).getSize(), ref.second); + // write_number_of_size(aggr_ptr, instance_reference->getMemberDataType(0).getSize(), ref.first); + // write_number_of_size(aggr_ptr, instance_reference->getMemberDataType(1).getSize(), ref.second); + // Hard-coded for efficiency + write_number_of_size(aggr_ptr, 2, ref.first); + write_number_of_size(aggr_ptr, 4, ref.second); } write_vlen_t(ptr, n_elements, aggr_data); } @@ -436,8 +481,10 @@ void IfcParse::IfcHdf5File::write_select(void*& ptr, IfcUtil::IfcBaseClass* inst size_t offset = datatype->getMemberOffset(member_index); auto ref = make_instance_reference(instance); void* ptr_member = (uint8_t*) ptr + offset; - write_number_of_size(ptr_member, instance_reference->getMemberDataType(0).getSize(), ref.first); - write_number_of_size(ptr_member, instance_reference->getMemberDataType(1).getSize(), ref.second); + // write_number_of_size(ptr_member, instance_reference->getMemberDataType(0).getSize(), ref.first); + // write_number_of_size(ptr_member, instance_reference->getMemberDataType(1).getSize(), ref.second); + write_number_of_size(ptr_member, 2, ref.first); + write_number_of_size(ptr_member, 4, ref.second); } else { Argument& wrapped_data = *instance->data().getArgument(0); IfcUtil::ArgumentType ty = wrapped_data.type(); @@ -447,7 +494,9 @@ void IfcParse::IfcHdf5File::write_select(void*& ptr, IfcUtil::IfcBaseClass* inst std::string member_name = default_cpp_type_names.find(ty)->second + "-value"; member_index = datatype->getMemberIndex(member_name); size_t offset = datatype->getMemberOffset(member_index); - size_t member_size = datatype->getMemberDataType(member_index).getSize(); + H5::DataType memberdt = datatype->getMemberDataType(member_index); + size_t member_size = memberdt.getSize(); + memberdt.close(); void* ptr_member = (uint8_t*) ptr + offset; switch(wrapped_data.type()) { case IfcUtil::Argument_BOOL: { @@ -489,16 +538,50 @@ void IfcParse::IfcHdf5File::write_select(void*& ptr, IfcUtil::IfcBaseClass* inst advance(ptr, datatype->getSize()); } -void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { +void IfcParse::IfcHdf5File::write_population(IfcFile& f) { std::set tys; - this->file->close(); + // Wth was this? + // this->file->close(); + std::set types_with_instiated_selected; + for (auto it = f.begin(); it != f.end(); ++it) { IfcSchema::Type::Enum ty = it->second->declaration().type(); tys.insert(ty); // This already is sorted on entity instance name sorted_entities[ty].push_back(it->second); + + if (settings_.instantiate_select()) { + bool has=false; + for (unsigned i = 0; i < it->second->data().getArgumentCount(); ++i) { + Argument* attr = it->second->data().getArgument(i); + if (attr->type() == IfcUtil::Argument_ENTITY_INSTANCE) { + IfcUtil::IfcBaseClass* inst = *attr; + if (!inst->declaration().as_entity()) { + IfcSchema::Type::Enum ty2 = inst->declaration().type(); + tys.insert(ty2); + sorted_entities[ty2].push_back(inst); + has = true; + } + } else if (attr->type() == IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE) { + IfcEntityList::ptr insts = *attr; + for (auto it = insts->begin(); it != insts->end(); ++it) { + if (!(*it)->declaration().as_entity()) { + IfcSchema::Type::Enum ty2 = (*it)->declaration().type(); + tys.insert(ty2); + sorted_entities[ty2].push_back(*it); + has = true; + } + } + } + } + if (has) { + types_with_instiated_selected.insert(ty); + } else { + static_cast(&it->second->data())->Unload(); + } + } } dataset_names.assign(tys.begin(), tys.end()); @@ -506,7 +589,15 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { for (auto it = dataset_names.begin(); it != dataset_names.end(); ++it) { + // std::cout << "begin inner loop" << std::endl; + // std::cin.get(); + + // if (*it != IfcSchema::Type::IfcUnitAssignment) continue; + + std::cerr << IfcSchema::Type::ToString(*it) << std::endl; + const std::vector& es = sorted_entities.find(*it)->second; + size_t datatype_size = declared_types[*it]->getSize(); hsize_t dims = es.size(); // don't chunk too small // hsize_t chunk = (std::min)(std::max(es.size() / 64, (size_t)8), es.size()); @@ -515,8 +606,8 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { const H5::DSetCreatPropList* plist; // H5O_MESG_MAX_SIZE = 65536 - const bool compact = es.size() * declared_types[*it]->getSize() < (1 << 15); - if (compress && !compact) { + const bool compact = es.size() * datatype_size < (1 << 15); + if (settings_.compress() && !compact) { H5::DSetCreatPropList* plist_ = new H5::DSetCreatPropList; plist_->setChunk(1, &chunk); // D'oh. Order is significant, according to h5ex_d_shuffle.c @@ -532,22 +623,59 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { plist = &H5::DSetCreatPropList::DEFAULT; } - H5::DataSet ds = population_group.createDataSet(IfcSchema::Type::ToString(*it) + "_instances", *declared_types[*it], H5::DataSpace(1, &dims), *plist); + H5::DataSpace space(1, &dims); + H5::DataSet ds = population_group.createDataSet(IfcSchema::Type::ToString(*it) + "_instances", *declared_types[*it], space, *plist); - void* data = allocator.allocate(declared_types[*it]->getSize() * static_cast(dims)); + size_t dataset_size = declared_types[*it]->getSize() * static_cast(dims); + void* data = allocator.allocate(dataset_size); + + std::cerr << dataset_size << std::endl; void* ptr = data; const H5::CompType* dt = (H5::CompType*) declared_types[*it]; int ind = 0; for (auto jt = es.begin(); jt != es.end(); ++jt, ++ind) { + void* start = ptr; + int member_idx = 0; H5::DataType member_type; IfcAbstractEntity& dat = (*jt)->data(); const declaration& decl = (*jt)->declaration(); + + if (!decl.as_entity()) { + if (!settings_.instantiate_select()) throw; + // This is a type + auto q = dt->getClass(); + auto s = dt->getSize(); + const Argument& attr_value = *dat.getArgument(0); + if (*dt == *default_types[simple_type::real_type]) { + double d = attr_value; + write_number_of_size(ptr, s, d); + } else if (*dt == *default_types[simple_type::string_type]) { + std::string s = attr_value; + write(ptr, s); + } else if (*dt == *default_types[simple_type::integer_type]) { + int i = attr_value; + write_number_of_size(ptr, s, i); + } else if (*dt == *default_types[simple_type::boolean_type] || + *dt == *default_types[simple_type::logical_type]) + { + bool b = attr_value; + write_number_of_size(ptr, s, static_cast(b ? 1 : 0)); + } else { + throw; + } + continue; + } + std::vector attributes = decl.as_entity()->all_attributes(); + std::vector inverse_attributes; + if (settings_.instantiate_inverse()) { + inverse_attributes = decl.as_entity()->all_inverse_attributes(); + } const std::vector& attributes_derived_in_subtype = decl.as_entity()->derived(); std::vector::const_iterator is_derived = attributes_derived_in_subtype.begin(); @@ -557,11 +685,15 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { size_t set_unset_size = member_type.getSize(); // skip for now write later advance(ptr, set_unset_size); - + member_type.close(); + member_type = dt->getMemberDataType(member_idx++); write_number_of_size(ptr, member_type.getSize(), static_cast(dat.id())); - - for (unsigned i = 0; i < dat.getArgumentCount(); ++i, ++is_derived) { + member_type.close(); + + // ----v----- In some IFC files there are extra superfluous attributes in the instantiation. For example FJK haus. + const size_t attr_count = (std::min)(attributes.size(), (size_t) dat.getArgumentCount()); + for (unsigned i = 0; i < attr_count; ++i, ++is_derived) { if (*is_derived) { continue; } @@ -569,6 +701,7 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { const IfcParse::entity::attribute* schema_attr = attributes[i]; const std::string& attribute_name = schema_attr->name(); Argument& attr_value = *dat.getArgument(i); + member_type = dt->getMemberDataType(member_idx++); if (attr_value.isNull()) { @@ -581,11 +714,11 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { } } else { set_unset_mask |= 1 << i; - if (OVERRIDE && attribute_name == "GlobalId") { + if (settings_.fix_global_id() && attribute_name == "GlobalId") { std::string s = attr_value; memcpy(static_cast(ptr), s.c_str(), s.size()); advance(ptr, s.length()); - } else if (OVERRIDE && attribute_name == "Coordinates") { + } else if (settings_.fix_cartesian_point() && (attribute_name == "Coordinates" || attribute_name == "DirectionRatios")) { std::vector ds = attr_value; for (auto it = ds.begin(); it != ds.end(); ++it) { write_number_of_size(ptr, default_types[simple_type::real_type]->getSize(), *it); @@ -596,8 +729,10 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { } else if (member_type == *instance_reference) { IfcUtil::IfcBaseClass* v = attr_value; auto ref = make_instance_reference(v); - write_number_of_size(ptr, instance_reference->getMemberDataType(0).getSize(), ref.first); - write_number_of_size(ptr, instance_reference->getMemberDataType(1).getSize(), ref.second); + // write_number_of_size(ptr, instance_reference->getMemberDataType(0).getSize(), ref.first); + // write_number_of_size(ptr, instance_reference->getMemberDataType(1).getSize(), ref.second); + write_number_of_size(ptr, 2, ref.first); + write_number_of_size(ptr, 4, ref.second); } else if (member_type == *default_types[simple_type::real_type]) { double d = attr_value; write_number_of_size(ptr, member_type.getSize(), d); @@ -637,6 +772,7 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { void* buffer_ptr; // void* buffer = buffer_ptr = new uint8_t[size_in_bytes * num_elements]; void* buffer = buffer_ptr = allocator.allocate(size_in_bytes * num_elements); + memset(buffer, 0, size_in_bytes * num_elements); for (auto it = es->begin(); it != es->end(); ++it) { write_select(buffer_ptr, *it, static_cast(datatype)); } @@ -681,18 +817,63 @@ void IfcParse::IfcHdf5File::write_population(const IfcFile& f, bool compress) { write_select(ptr, attr_value, static_cast(&member_type)); } } + + member_type.close(); + } + + for (auto it = inverse_attributes.begin(); it != inverse_attributes.end(); ++it) { + member_type = dt->getMemberDataType(member_idx++); + + auto q = member_type.getClass(); + if (member_type.getClass() != H5T_VLEN) { + std::cerr << dt->getMemberName(member_idx - 1) << " "; + std::cerr << "Inverse attribute must be vlen" << std::endl; + } + const IfcParse::entity* entity_ref = (*it)->entity_reference(); + const IfcParse::entity::attribute* attribute_ref = (*it)->attribute_reference(); + IfcEntityList::ptr instances = f.getInverse(dat.id(), entity_ref->type(), entity_ref->attribute_index(attribute_ref)); + if (instances->size() == 0) { + memset(ptr, 0, member_type.getSize()); + advance(ptr, member_type.getSize()); + } else { + write_aggregate(ptr, instances); + } + + member_type.close(); } write_number_of_size(set_unset_ptr, set_unset_size, set_unset_mask); + const size_t written_length = (uint8_t*) ptr - (uint8_t*) start; + + if (written_length != datatype_size) { + std::cerr << "Written " << written_length << " bytes, but expected " << datatype_size << std::endl; + } } - ds.write(data, *declared_types[*it]); - ds.close(); + /* for (size_t i = 0; i < dataset_size; ++i) { + std::cout << std::hex << (int)((uint8_t*)data)[i] << " "; + } */ - allocator.free(); + // visit(data, declared_types[*it]); + ds.write(data, *declared_types[*it]); + H5Dvlen_reclaim(declared_types[*it]->getId(), space.getId(), H5P_DEFAULT, data); + + ds.close(); + space.close(); + + if (plist != &H5::DSetCreatPropList::DEFAULT) { + // ->close() doesn't work due to const, hack hack hack + H5Pclose(plist->getId()); + } + + // allocator.free(); + delete[] data; for (auto it = es.begin(); it != es.end(); ++it) { - static_cast(&(**it).data())->Unload(); + if (types_with_instiated_selected.find((**it).declaration().type()) == types_with_instiated_selected.end()) { + // Instances possibly refering to embedded simple type instantiations are not freed + static_cast(&(**it).data())->Unload(); + } } } diff --git a/src/ifcparse/IfcHdf5File.h b/src/ifcparse/IfcHdf5File.h index e5ba0ca2c7..ede25fa299 100644 --- a/src/ifcparse/IfcHdf5File.h +++ b/src/ifcparse/IfcHdf5File.h @@ -22,11 +22,12 @@ #include "H5Cpp.h" +#include "../ifcparse/Hdf5Settings.h" #include "../ifcparse/IfcUtil.h" #include "../ifcparse/IfcFile.h" namespace IfcParse { - + class IfcHdf5File { private: class allocator_t { @@ -50,6 +51,7 @@ namespace IfcParse { }; allocator_t allocator; + Hdf5Settings settings_; std::string name_; schema_definition schema_; @@ -84,7 +86,7 @@ namespace IfcParse { void write_select(void*& ptr, IfcUtil::IfcBaseClass* instance, const H5::CompType* datatype) const; void write_schema(const schema_definition& schema); - void write_population(const IfcFile& f, bool compress); + void write_population(IfcFile& f); template const H5::DataType* get_datatype() const { @@ -109,12 +111,13 @@ namespace IfcParse { public: typedef std::pair compound_member; - IfcHdf5File(const IfcFile* f, const std::string& name, bool compress) + IfcHdf5File(IfcFile* f, const std::string& name, const Hdf5Settings& settings) : name_(name) , schema_(*f->schema()) + , settings_(settings) { write_schema(*f->schema()); - write_population(*f, compress); + write_population(*f); }; }; diff --git a/src/ifcparse/IfcParse.cpp b/src/ifcparse/IfcParse.cpp index 78a57510d9..ebbb7e6bdb 100644 --- a/src/ifcparse/IfcParse.cpp +++ b/src/ifcparse/IfcParse.cpp @@ -920,6 +920,73 @@ bool IfcFile::Init(void* data, int len) { return IfcFile::Init(new IfcSpfStream(data,len)); } +class RegisterInstancesToFile { +private: + IfcFile::entity_by_id_t& byid_; + IfcFile::entity_by_guid_t& byguid_; + IfcFile::entities_by_type_t& bytype_; + IfcFile::entities_by_ref_t& byref_; + + bool populate_guid_mapping_; +public: + RegisterInstancesToFile( + IfcFile::entity_by_id_t& byid, + IfcFile::entity_by_guid_t& byguid, + IfcFile::entities_by_type_t& bytype, + IfcFile::entities_by_ref_t& byref + ) + : byid_(byid) + , byguid_(byguid) + , bytype_(bytype) + , byref_(byref) + , populate_guid_mapping_(true) + {} + + const bool& populate_guid_mapping() const { return populate_guid_mapping_; } + bool& populate_guid_mapping() { return populate_guid_mapping_; } + + void operator()(IfcUtil::IfcBaseClass* instance) { + if (populate_guid_mapping_ && instance->declaration().is(IfcSchema::Type::IfcRoot)) { + IfcSchema::IfcRoot* ifc_root = (IfcSchema::IfcRoot*) instance; + try { + const std::string guid = ifc_root->GlobalId(); + if (byguid_.insert(std::make_pair(guid, ifc_root)).second == false) { + std::stringstream ss; + ss << "Duplicate instance with guid '" << guid << "' not stored"; + Logger::Message(Logger::LOG_WARNING,ss.str()); + } + } catch (const IfcException& ex) { + Logger::Message(Logger::LOG_ERROR,ex.what()); + } + } + + const IfcParse::entity* entity = instance->declaration().as_entity(); + while(entity) { + IfcEntityList::ptr& instances_by_type = bytype_[entity->type()]; + if (!instances_by_type) { + instances_by_type.reset(new IfcEntityList); + } + instances_by_type->push(instance); + entity = entity->supertype(); + } + + unsigned int id = instance->data().id(); + if (byid_.insert(std::make_pair(id, instance)).second == false) { + std::stringstream ss; + ss << "Duplicate instance with id '" << id << "' not stored"; + Logger::Message(Logger::LOG_WARNING,ss.str()); + } + } + + void operator()(IfcUtil::IfcBaseClass* instance, unsigned int refering_inst_name) { + IfcEntityList::ptr& instances_by_ref = byref_[refering_inst_name]; + if (!instances_by_ref) { + instances_by_ref.reset(new IfcEntityList); + } + instances_by_ref->push(instance); + } +}; + bool IfcFile::Init(IfcParse::IfcSpfStream* s) { // Initialize a "C" locale for locale-independent // number parsing. See comment above on line 41. @@ -942,92 +1009,12 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* s) { Logger::Message(Logger::LOG_ERROR, std::string("File schema encountered different from expected '") + IfcSchema::Identifier + "'"); } - Token token = TokenPtr(); - Token previous = TokenPtr(); - - unsigned int currentId = 0; - lastId = 0; - int x = 0; - Entity* e; - IfcUtil::IfcBaseClass* entity = 0; - Logger::Status("Scanning file..."); - while ( ! stream->eof ) { - if ( currentId ) { - try { - e = new Entity(currentId,this); - if (this->create_latebound_entities()) { - entity = new IfcLateBoundEntity(e); - } else { - entity = IfcSchema::SchemaEntity(e); - } - } catch (const IfcException& ex) { - currentId = 0; - Logger::Message(Logger::LOG_ERROR,ex.what()); - continue; - } - // Update the status after every 1000 instances parsed - if ( !((++x)%1000) ) { - std::stringstream ss; ss << "\r#" << currentId; - Logger::Status(ss.str(), false); - } - if ( entity->declaration().is(IfcSchema::Type::IfcRoot) ) { - IfcSchema::IfcRoot* ifc_root = (IfcSchema::IfcRoot*) entity; - try { - const std::string guid = ifc_root->GlobalId(); - if ( byguid.find(guid) != byguid.end() ) { - std::stringstream ss; - ss << "Overwriting entity with guid " << guid; - Logger::Message(Logger::LOG_WARNING,ss.str()); - } - byguid[guid] = ifc_root; - } catch (const IfcException& ex) { - Logger::Message(Logger::LOG_ERROR,ex.what()); - } - } - - IfcSchema::Type::Enum ty = entity->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); - ty = IfcSchema::Type::Parent(ty); - } while ( ty > -1 ); - - if ( byid.find(currentId) != byid.end() ) { - std::stringstream ss; - ss << "Overwriting entity with id " << currentId; - Logger::Message(Logger::LOG_WARNING,ss.str()); - } - byid[currentId] = entity; - - MaxId = (std::max)(MaxId,currentId); - currentId = 0; - } else { - try { token = tokens->Next(); } - catch (... ) { token = TokenPtr(); } - } - - if ( ! (token.second || token.first) ) break; - - if ( (previous.second || previous.first) && TokenFunc::isIdentifier(previous) ) { - int id = TokenFunc::asInt(previous); - if ( TokenFunc::isOperator(token,'=') ) { - currentId = id; - } else if (entity) { - IfcEntityList::ptr instances_by_ref = entitiesByReference(id); - if (!instances_by_ref) { - instances_by_ref = IfcEntityList::ptr(new IfcEntityList()); - byref[id] = instances_by_ref; - } - instances_by_ref->push(entity); - } - } - previous = token; - } - Logger::Status("\rDone scanning file "); + RegisterInstancesToFile populate(byid, byguid, bytype, byref); + populate.populate_guid_mapping() = false; + InstanceStreamer streamer(this, *stream, *tokens, populate, populate); + streamer.stream(); + MaxId = streamer.max_inst_name_encountered(); + return true; } @@ -1543,6 +1530,6 @@ std::pair IfcFile::getUnit(IfcSchema::IfcUnitE return return_value; } -void IfcFile::write_hdf5(const std::string& name, bool compress) const { - IfcHdf5File(this, name, compress); +void IfcFile::write_hdf5(const std::string& name, const Hdf5Settings& settings) { + IfcHdf5File(this, name, settings); } \ No newline at end of file diff --git a/src/ifcparse/IfcParse.h b/src/ifcparse/IfcParse.h index ff96a3aa75..7769b60e6b 100644 --- a/src/ifcparse/IfcParse.h +++ b/src/ifcparse/IfcParse.h @@ -263,6 +263,100 @@ namespace IfcParse { IfcWrite::IfcWritableEntity* isWritable(); }; + template + class InstanceStreamer { + private: + IfcFile* file_; + IfcSpfStream& stream_; + IfcSpfLexer& lexer_; + Fn1& fn1_; + Fn2& fn2_; + + unsigned int current_inst_name_, + last_inst_name_, + num_insts_encountered_, + max_inst_name_encountered_; + + public: + InstanceStreamer(IfcFile* file, IfcSpfStream& stream, IfcSpfLexer& lexer, Fn1& fn1, Fn2& fn2) + : file_(file) + , stream_(stream) + , lexer_(lexer) + , fn1_(fn1) + , fn2_(fn2) + , current_inst_name_(0) + , last_inst_name_(0) + , num_insts_encountered_(0) + , max_inst_name_encountered_(0) + {} + + unsigned int current_inst_name() { return current_inst_name_; } + unsigned int last_inst_name() { return last_inst_name_; } + unsigned int num_insts_encountered() { return num_insts_encountered_; } + unsigned int max_inst_name_encountered() { return max_inst_name_encountered_; } + + void stream() { + Logger::Status("Scanning file..."); + + Token token = TokenPtr(); + Token previous = TokenPtr(); + + Entity* inst_data; + IfcUtil::IfcBaseClass* entity_instance = 0; + while (!stream_.eof) { + if (current_inst_name_ != 0) { + try { + inst_data = new Entity(current_inst_name_, file_); + if (file_->create_latebound_entities()) { + entity_instance = new IfcLateBoundEntity(inst_data); + } else { + entity_instance = IfcSchema::SchemaEntity(inst_data); + } + } catch (const IfcException& ex) { + current_inst_name_ = 0; + Logger::Message(Logger::LOG_ERROR, ex.what()); + continue; + } + + // Update the status after every 1000 instances parsed + if (((++num_insts_encountered_) % 1000) == 0) { + std::stringstream ss; ss << "\r#" << current_inst_name_; + Logger::Status(ss.str(), false); + } + + fn1_(entity_instance); + + max_inst_name_encountered_ = (std::max)(max_inst_name_encountered_, current_inst_name_); + + current_inst_name_ = 0; + } else { + try { + token = lexer_.Next(); + } catch (...) { + token = TokenPtr(); + } + } + + if (!(token.second || token.first)) { + break; + } + + if ((previous.second || previous.first) && TokenFunc::isIdentifier(previous)) { + int id = TokenFunc::asInt(previous); + if (TokenFunc::isOperator(token, '=')) { + current_inst_name_ = id; + } else if (entity_instance) { + fn2_(entity_instance, id); + } + } + + previous = token; + } + + Logger::Status("\rDone scanning file "); + } + }; + } std::ostream& operator<< (std::ostream& os, const IfcParse::IfcFile& f); diff --git a/src/ifcparse/IfcSchema.h b/src/ifcparse/IfcSchema.h index 5e2cab6f94..504ce8366f 100644 --- a/src/ifcparse/IfcSchema.h +++ b/src/ifcparse/IfcSchema.h @@ -201,13 +201,53 @@ namespace IfcParse { bool optional() const { return optional_; } }; + class inverse_attribute { + public: + typedef enum { bag_type, set_type, unspecified_type } aggregate_type; + protected: + std::string name_; + aggregate_type type_of_aggregation_; + int bound1_, bound2_; + parameter_type* type_of_element_; + const entity* entity_reference_; + const attribute* attribute_reference_; + public: + inverse_attribute(const std::string& name, aggregate_type type_of_aggregation, int bound1, int bound2, const entity* entity_reference, const attribute* attribute_reference) + : name_(name) + , type_of_aggregation_(type_of_aggregation) + , bound1_(bound1) + , bound2_(bound2) + , entity_reference_(entity_reference) + , attribute_reference_(attribute_reference) + {} + + const std::string& name() const { return name_; } + aggregate_type type_of_aggregation() const { type_of_aggregation_; } + int bound1() const { return bound1_; } + int bound2() const { return bound2_; } + const entity* entity_reference() const { return entity_reference_; } + const attribute* attribute_reference() const { return attribute_reference_; } + }; + protected: const entity* supertype_; /* NB: IFC explicitly allows only single inheritance */ std::vector subtypes_; std::vector attributes_; std::vector derived_; - + + std::vector inverse_attributes_; + + class attribute_by_name_cmp : public std::unary_function { + private: + std::string name_; + public: + attribute_by_name_cmp(const std::string name) + : name_(name) {} + bool operator()(const attribute* attr) { + return attr->name() == name_; + } + }; public: entity(const std::string& name, entity* supertype) : declaration(name) @@ -237,6 +277,10 @@ namespace IfcParse { derived_ = derived; } + void set_inverse_attributes(const std::vector& inverse_attributes) { + inverse_attributes_ = inverse_attributes; + } + const std::vector& subtypes() const { return subtypes_; } const std::vector& attributes() const { return attributes_; } const std::vector& derived() const { return derived_; } @@ -244,17 +288,59 @@ namespace IfcParse { 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(supertype_attrs.begin(), supertype_attrs.end(), std::back_inserter(attrs)); } - // std::copy(attributes_.begin(), attributes_.end(), it); std::copy(attributes_.begin(), attributes_.end(), std::back_inserter(attrs)); return attrs; } + const std::vector all_inverse_attributes() const { + std::vector attrs; + if (supertype_) { + const std::vector supertype_inv_attrs = supertype_->all_inverse_attributes(); + std::copy(supertype_inv_attrs.begin(), supertype_inv_attrs.end(), std::back_inserter(attrs)); + } + std::copy(inverse_attributes_.begin(), inverse_attributes_.end(), std::back_inserter(attrs)); + return attrs; + } + + ptrdiff_t attribute_index(const attribute* attr) const { + const entity* current = this; + ptrdiff_t index = -1; + do { + if (index > -1) { + index += current->attributes().size(); + } else { + auto it = std::find(current->attributes().begin(), current->attributes().end(), attr); + if (it != current->attributes().end()) { + index = std::distance(current->attributes().begin(), it); + } + } + } while (current = current->supertype_); + return index; + } + + ptrdiff_t attribute_index(const std::string& attr_name) const { + const entity* current = this; + ptrdiff_t index = -1; + attribute_by_name_cmp cmp(attr_name); + do { + if (index > -1) { + index += current->attributes().size(); + } else { + auto it = std::find_if(current->attributes().begin(), current->attributes().end(), cmp); + if (it != current->attributes().end()) { + index = std::distance(current->attributes().begin(), it); + } + } + } while (current = current->supertype_); + return index; + } + + const entity* supertype() const { return supertype_; } + virtual const entity* as_entity() const { return this; } };