From 5a475bfa6665ad5fa1ebfc21cc6ba90b3c224b7f Mon Sep 17 00:00:00 2001 From: Thomas Krijnen Date: Thu, 28 Jul 2011 14:32:44 +0000 Subject: [PATCH] IfcExpressParser: Initial commit of python script to convert the IFC2X3_TC1.exp ISO-10303-11 Express file into C++ code for the IfcParse library --- src/ifcexpressparser/IfcExpressParser.py | 455 ++ src/ifcparse/Ifc2x3.cpp | 5687 +++++++++++----------- src/ifcparse/Ifc2x3.h | 53 +- src/ifcparse/Ifc2x3enum.h | 9 +- 4 files changed, 3327 insertions(+), 2877 deletions(-) create mode 100644 src/ifcexpressparser/IfcExpressParser.py diff --git a/src/ifcexpressparser/IfcExpressParser.py b/src/ifcexpressparser/IfcExpressParser.py new file mode 100644 index 0000000000..deff3ca06b --- /dev/null +++ b/src/ifcexpressparser/IfcExpressParser.py @@ -0,0 +1,455 @@ +header = """ +/******************************************************************************** + * * + * This file is part of IfcOpenShell. * + * * + * IfcOpenShell is free software: you can redistribute it and/or modify * + * it under the terms of the Lesser GNU General Public License as published by * + * the Free Software Foundation, either version 3.0 of the License, or * + * (at your option) any later version. * + * * + * IfcOpenShell is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * Lesser GNU General Public License for more details. * + * * + * You should have received a copy of the Lesser GNU General Public License * + * along with this program. If not, see . * + * * + ********************************************************************************/ + """.strip() + +############################################################################### +# # +# This file can be used to generate C++ code from Express schema files. The # +# generated code works alongside the IfcOpenShell IfcParse library. This # +# script has only been tested on IFC2X3_TC1.exp and will most probably not # +# work on any other schemas. # +# # +# Note this script uses funcparserlib, which is available at: # +# http://code.google.com/p/funcparserlib/ # +# The script only works with revision e1df5066addd because it uses the some() # +# parser and is incompatible with other changes as well. # +# # +############################################################################### + +import os, sys +filename = sys.argv[1] + +# +# A class to split the Express schema files into seperate tokens +# +class Tokenizer(object): + comment = ['(*','*)'] + termchars = ',;()=[]:' + def __init__(self, fn): + if hasattr(fn,'read'): object.__setattr__(self,'f',fn) + else: object.__setattr__(self,'f',open(fn,'rb')) + def __getattr__(self, name): + return getattr(self.f, name) + def __setattr__(self, name, value): + setattr(self.f, name, value) + def __iter__(self): return self + def next(self): + def get(): + buffer = '' + in_comment = False + in_string = False + offset = self.tell() + while True: + c = self.read(2) + if len(c) < 2: raise StopIteration + if c in Tokenizer.comment: + in_comment = c == Tokenizer.comment[0] + continue + if in_string and c == "''": + buffer += "'" + continue + self.seek(-1,1) + if not in_string and c[0].isspace(): + if ( len(buffer) ): return buffer + else: + offset = self.tell() + continue + if not in_comment: + if len(buffer) and (c[0] in Tokenizer.termchars or buffer[-1] in Tokenizer.termchars): + self.seek(-1,1) + return buffer + buffer += c[0] + return get() + +# +# Some global variables to keep track of variable names +# +express_to_cpp = { + 'BOOLEAN':'bool', + 'LOGICAL':'bool', + 'INTEGER':'int', + 'REAL':'float', + 'NUMBER':'float', + 'STRING':'std::string' +} +schema_version = '' +enumerations = set() +selections = set() +entity_names = set() +simple_types = set() +selectable_simple_types = set() +argument_count = {} +parent_relations = {} + +# +# Since inherited arguments of Express entities are placed in sequence before the non-inherited once, we need to keep track of how many inherited arguments exist +# +def argument_start(c): + if c not in parent_relations: return 0 + i = 0 + while True: + c = parent_relations[c] + i += argument_count[c] if c in argument_count else 0 + if not (c in parent_relations): break + return i + +# +# Several classes to generate code from Express types and entities +# +class ArrayType: + def __init__(self,l): + self.type = express_to_cpp.get(l[3],l[3]) + self.upper = l[2] + self.lower = l[1] + def __str__(self): + if self.type in entity_names: + return "SHARED_PTR< IfcTemplatedEntityList<%s> >"%self.type + elif self.type in selections: + return "SHARED_PTR< IfcTemplatedEntityList >" + else: + return "std::vector<%(type)s> /*[%(lower)s:%(upper)s]*/"%self.__dict__ +class ScalarType: + def __init__(self,l): self.type = express_to_cpp.get(l,l) + def __str__(self): return self.type +class EnumType: + def __init__(self,l): + self.v = ['IFC_NULL' if x == 'NULL' else x for x in l] + self.maxlen = max([len(v) for v in self.v]) + def __str__(self): + if generator_mode == 'HEADER': + return "enum {%s}"%", ".join(self.v) + elif generator_mode == 'SOURCE_TO': + return '{ "%s" }'%'","'.join(self.v) + elif generator_mode == 'SOURCE_FROM': + return "".join([' if(s=="%s"%s) return %s::%s;\n'%(v.upper()," "*(self.maxlen-len(v)),"%(name)s",v) for v in self.v]) + + def __len__(self): return len(self.v) +class SelectType: + def __init__(self,l): + for x in l: + if x in simple_types: selectable_simple_types.add(x) + def __str__(self): return "SHARED_PTR" +class BinaryType: + def __init__(self,l): self.l = int(l) + def __str__(self): return "char[%s]"%self.l +class InverseType: + def __init__(self,l): + self.name, self.type, self.reference = l +class Typedef: + def __init__(self,l): + self.name,self.type=l[1:3] + if isinstance(self.type,EnumType): + enumerations.add(self.name) + self.len = len(self.type) + elif isinstance(self.type,SelectType): selections.add(self.name) + simple_types.add(self.name) + def __str__(self): + global generator_mode + if generator_mode == 'HEADER' and isinstance(self.type,EnumType): + return "namespace %(name)s {typedef %(type)s %(name)s;\nstd::string ToString(%(name)s v);\n%(name)s FromString(const std::string& s);}"%self.__dict__ + elif generator_mode == 'HEADER': + return "typedef %s %s;"%(self.type,self.name) + elif generator_mode == 'SOURCE' and isinstance(self.type,EnumType): + generator_mode = 'SOURCE_TO' + s = "std::string %(name)s::ToString(%(name)s v) {\n if ( v < 0 || v >= %(len)d ) throw;\n const char* names[] = %(type)s;\n return names[v];\n}\n"%self.__dict__ + generator_mode = 'SOURCE_FROM' + s += ("%(name)s::%(name)s %(name)s::FromString(const std::string& s) {\n%(type)s throw;\n}"%self.__dict__)%self.__dict__ + generator_mode = 'SOURCE' + return s +class Argument(object): + def __init__(self,l): + self.name, self.optional, self.type = l +class ArgumentList: + def __init__(self,l): + self.l = [Argument(a) for a in l] + self.argstart = 0 + def __len__(self): return len(self.l) + def __str__(self): + s = "" + argv = self.argstart + for a in self.l: + class_name = indent = "" + return_type = str(a.type) + if generator_mode == 'SOURCE': + class_name = "%(class_name)s::" + if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)): + function_body = " { throw; /* Not implemented argument 7 */ }" + elif isinstance(a.type,ArrayType) and str(a.type.type) in entity_names: + function_body = " { RETURN_AS_LIST(%s,%d) }"%(a.type.type,argv) + elif isinstance(a.type,ArrayType) and str(a.type.type) in selections: + function_body = " { RETURN_AS_LIST(IfcAbstractSelect,%d) }"%(argv) + elif return_type in entity_names: + function_body = " { return reinterpret_pointer_cast(*entity->getArgument(%d)); }"%(return_type,argv) + elif return_type in enumerations: + function_body = " { return %s::FromString(*entity->getArgument(%d)); }"%(return_type,argv) + else: + function_body = " { return *entity->getArgument(%d); }"%argv + function_body2 = " { return !entity->getArgument(%d)->isNull(); }"%argv + else: + indent = " " + function_body = function_body2 = ";" + if a.optional: s += "\n%sbool %shas%s()%s"%(indent,class_name,a.name,function_body2) + if ( str(a.type) in enumerations ): + return_type = "%(type)s::%(type)s"%a.__dict__ + elif ( str(a.type) in entity_names ): + return_type = "SHARED_PTR<%(type)s>"%a.__dict__ + s += "\n%s%s %s%s()%s"%(indent,return_type,class_name,a.name,function_body) + argv += 1 + return s +class InverseList: + def __init__(self,l): + self.l = l + def __str__(self): + if self.l is None: return "" + s = "" + for i in self.l: + if generator_mode == 'HEADER': + s += "\n SHARED_PTR< IfcTemplatedEntityList<%s> > %s(); // INVERSE %s::%s"%(i.type.type,i.name,i.type.type,i.reference) + elif generator_mode == 'SOURCE': + s += "\n%s::list %s::%s() { RETURN_INVERSE(%s) }"%(i.type.type,"%(class_name)s",i.name,i.type.type) + return s +class Classdef: + def __init__(self,l): + self.class_name, self.parent_class, self.arguments, self.inverse = l + entity_names.add(self.class_name) + parent_relations[self.class_name] = self.parent_class + argument_count[self.class_name] = len(self.arguments) + def __str__(self): + if generator_mode == 'HEADER': + return "class %s : public %s {\npublic:%s%s%s\n};" % (self.class_name, + "IfcBaseClass" if self.parent_class is None else self.parent_class, + self.arguments, + self.inverse, + ("\n bool is(Type::Enum v);"+ + "\n Type::Enum type();"+ + "\n static Type::Enum Class();"+ + "\n %(class_name)s (IfcAbstractEntityPtr e = IfcAbstractEntityPtr());"+ + "\n typedef SHARED_PTR<%(class_name)s> ptr;"+ + "\n typedef SHARED_PTR< IfcTemplatedEntityList<%(class_name)s> > list;"+ + "\n typedef IfcTemplatedEntityList<%(class_name)s>::it it;")%self.__dict__ + ) + elif generator_mode == 'SOURCE': + self.arguments.argstart = argument_start(self.class_name) + return (("\n// %(class_name)s"+str(self.arguments)+str(self.inverse)+ + ("\nbool %(class_name)s::is(Type::Enum v) { return v == Type::%(class_name)s; }" if self.parent_class is None else + "\nbool %(class_name)s::is(Type::Enum v) { return v == Type::%(class_name)s || %(parent_class)s::is(v); }")+ + "\nType::Enum %(class_name)s::type() { return Type::%(class_name)s; }"+ + "\nType::Enum %(class_name)s::Class() { return Type::%(class_name)s; }"+ + "\n%(class_name)s::%(class_name)s(IfcAbstractEntityPtr e) { if (!is(Type::%(class_name)s)) throw; entity = e; }")%self.__dict__)%self.__dict__ + + +from funcparserlib.parser import a, skip, many, maybe, some + +# +# Lambda functions to map combinator output to classes +# +array_type = lambda t: ArrayType(t) +scalar_type = lambda t: ScalarType(t) +enum_type = lambda t: EnumType(t) +select_type = lambda t: SelectType(t) +binary_type = lambda t: BinaryType(t) +inverse_type = lambda t: InverseType(t) +format_type = lambda t: Typedef(t) +argument_list = lambda t: ArgumentList(t) +inverse_list = lambda t: InverseList(t) +format_options = lambda t: [t[0]]+t[1] + +# +# The actual grammar definition +# +s = some(lambda t: not t in ['UNIQUE','WHERE','END_ENTITY','END_TYPE','INVERSE','DERIVE']) +x = lambda s:skip(a(s)) +list_or_array = a('ARRAY') | a('LIST') | a('SET') +binary = x('BINARY')+x('(') + s + x(')') >> binary_type +array = list_or_array + x('[') + s + x(':') + s + x(']') + x('OF') + skip(maybe(a('UNIQUE'))) + (binary|s) >> array_type +options = x('(') + s + many(x(',')+s) + x(')') >> format_options +enum = x('ENUMERATION') + x('OF') + options >> enum_type +select = x('SELECT') + options >> select_type +single = s + skip(maybe(x('(')+s+x(')')) + maybe(a('FIXED'))) >> scalar_type +type_type = array | enum | select | single +type_start = a('TYPE') + s + x('=') + type_type + x(';') +type_end = a('END_TYPE') + x(';') + +to_end = many(some(lambda t: t != ';')) +clause = s + x(':') + to_end + x(';') +where = a('WHERE') + many(clause) + +type = type_start + maybe(where) + type_end >> format_type + +subtype = x('SUBTYPE') + x('OF') + x('(') + s + x(')') +supertype = maybe(x('ABSTRACT')) + x('SUPERTYPE') + x('OF') + x('(') + x('ONEOF') + options + x(')') +entity_start = x('ENTITY') + s + skip(maybe(supertype)) + maybe(subtype) + x(';') +entity_end = x('END_ENTITY') + x(';') +key_value = s + x(':') + maybe(a('OPTIONAL')) + (array|binary|single) + x(';') +arguments = many(key_value) >> argument_list +unique_value = s + x(':') + s + many(a(',')+s) + a(';') +unique = skip(a('UNIQUE') + many(unique_value)) +inverse_def = s + x(':') + (array|single) + x('FOR') + s + x(';') >> inverse_type +inverse = maybe(x('INVERSE') + many( inverse_def )) >> inverse_list +derive = skip(a('DERIVE') + many(clause)) + +entity = entity_start + arguments + skip(maybe(unique)) + skip(maybe(derive)) + inverse + skip(maybe(where)) + entity_end >> Classdef + +schema = skip(a('SCHEMA')) + s + x(';') + +express = schema + many(type) + many(entity) +schema_version,types,entities = express.parse(list(Tokenizer(filename))) +schema_version = schema_version.capitalize() + +# +# Writing of the three generated files starts here +# +h_file = open("%s.h"%schema_version,'w') +enumh_file = open("%senum.h"%schema_version,'w') +cpp_file = open("%s.cpp"%schema_version,'w') + +header += """ + +/******************************************************************************** + * * + * This file has been generated from %s. Do not make modifications * + * but instead modify the python script that has been used to generate this. * + * * + ********************************************************************************/ + """%filename + +generator_mode = 'HEADER' + +print >>h_file, header +print >>enumh_file, header +print >>cpp_file, header +print >>h_file, """#ifndef %(schema_upper)s_H +#define %(schema_upper)s_H + +#include +#include + +#include "../ifcparse/IfcUtil.h" +#include "../ifcparse/%(schema)senum.h" + +using namespace IfcUtil; + +#define RETURN_INVERSE(T) \\ + IfcEntities e = entity->getInverse(T::Class()); \\ + SHARED_PTR< IfcTemplatedEntityList > l ( new IfcTemplatedEntityList() ); \\ + for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \\ + l->push(reinterpret_pointer_cast(*it)); \\ + } \\ + return l; + +#define RETURN_AS_SINGLE(T,a) \\ + return reinterpret_pointer_cast(*entity->getArgument(a)); + +#define RETURN_AS_LIST(T,a) \\ + IfcEntities e = *entity->getArgument(a); \\ + SHARED_PTR< IfcTemplatedEntityList > l ( new IfcTemplatedEntityList() ); \\ + for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \\ + l->push(reinterpret_pointer_cast(*it)); \\ + } \\ + return l; + +namespace %(schema)s { +"""%{'schema_upper':schema_version.upper(),'schema':schema_version} + +simple_enumerations = sorted(selectable_simple_types) +entity_enumerations = sorted(entity_names) +all_enumerations = simple_enumerations + entity_enumerations + +print >>enumh_file, """#ifndef IFC2X3ENUM_H +#define IFC2X3ENUM_H + +namespace Ifc2x3 { + +namespace Type { + typedef enum { + %(enum)s + } Enum; + Enum FromString(const std::string& s); + std::string ToString(Enum v); +} + +} + +#endif +"""%{'schema_upper':schema_version.upper(),'schema':schema_version,'enum':", ".join(all_enumerations + ["ALL"])} + +defined_types = set(express_to_cpp.values()) +deferred_types = [] + +for t in [T for T in types if not (isinstance(T.type,EnumType) or isinstance(T.type,SelectType))]: + if isinstance(t.type,ScalarType) and str(t.type) not in defined_types: + deferred_types.append(t) + else: + print >>h_file, t +for t in [T for T in types if isinstance(T.type,SelectType)]: + print >>h_file, t +for t in deferred_types: + print >>h_file, t +for t in [T for T in types if isinstance(T.type,EnumType)]: + print >>h_file, t + +print >>h_file, "// Forward definitions" +print >>h_file, "class %s;\n"%"; class ".join([e.class_name for e in entities]) + +defined_classes = set() +while True: + classes = [c for c in entities if c.class_name not in defined_classes] + if not len(classes): break + for c in classes: + if c.parent_class is None or c.parent_class in defined_classes: + defined_classes.add(c.class_name) + print >>h_file, c + +print >>h_file, "IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = IfcAbstractEntityPtr());" + +print >>h_file, "}\n\n#endif" + +generator_mode = 'SOURCE' + +print >>cpp_file, """#include "%(schema)s.h" + +using namespace %(schema)s; + +IfcSchemaEntity %(schema)s::SchemaEntity(IfcAbstractEntityPtr e) {"""%{'schema':schema_version} + +for e in simple_enumerations: + print >>cpp_file, " if ( e->is(Type::%s) ) return IfcSchemaEntity(new IfcEntitySelect(e));"%e +for e in entity_enumerations: + print >>cpp_file, " if ( e->is(Type::%s) ) return IfcSchemaEntity(new %s(e));"%(e,e) +print >>cpp_file, " throw; " +print >>cpp_file, "}" +print >>cpp_file +print >>cpp_file, "std::string Type::ToString(Enum v) {" +print >>cpp_file, " if (v < 0 || v >= %d) throw;"%len(all_enumerations) +print >>cpp_file, ' const char* names[] = { "%s" };'%'","'.join(all_enumerations) +print >>cpp_file, ' return names[v];' +print >>cpp_file, "}" +print >>cpp_file +print >>cpp_file, "Type::Enum Type::FromString(const std::string& s){" +elseif = "if" +maxlen = max([len(e) for e in all_enumerations]) +for e in all_enumerations: + print >>cpp_file, ' %s(s=="%s"%s) { return %s; }'%(elseif,e.upper()," "*(maxlen-len(e)),e) +print >>cpp_file, " throw;" +print >>cpp_file, "}" + +for t in [T for T in types if isinstance(T.type,EnumType)]: + print >>cpp_file, t +for e in entities: print >>cpp_file, e, \ No newline at end of file diff --git a/src/ifcparse/Ifc2x3.cpp b/src/ifcparse/Ifc2x3.cpp index 6066981b65..b387662cf7 100644 --- a/src/ifcparse/Ifc2x3.cpp +++ b/src/ifcparse/Ifc2x3.cpp @@ -23,118 +23,117 @@ * but instead modify the python script that has been used to generate this. * * * ********************************************************************************/ - + #include "Ifc2x3.h" using namespace Ifc2x3; IfcSchemaEntity Ifc2x3::SchemaEntity(IfcAbstractEntityPtr e) { - if ( e->is(Type::IfcSoundPowerMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcRotationalFrequencyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSpecificHeatCapacityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcElectricConductanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcElectricChargeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPositiveLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAbsorbedDoseMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAccelerationMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAmountOfSubstanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); if ( e->is(Type::IfcAngularVelocityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcNullStyle) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcIonConcentrationMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcModulusOfLinearSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcAreaMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcBoolean) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcColour) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcComplexNumber) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCompoundPlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcContextDependentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCountMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcCurvatureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDateTimeSelect) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDerivedMeasureValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDescriptiveMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDoseEquivalentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcDynamicViscosityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricCapacitanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricChargeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricConductanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricCurrentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricResistanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcElectricVoltageMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcEnergyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcFrequencyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); if ( e->is(Type::IfcHeatFluxDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); if ( e->is(Type::IfcHeatingValueMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPositiveRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMolecularWeightMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLuminousFluxMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcNormalisedRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLabel) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcTimeStamp) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcNumericMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcRotationalMassMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLinearForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcKinematicViscosityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMassDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcIntegerCountRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcRadioActivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcReal) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLinearMomentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcElectricCurrentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcThermalTransmittanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcModulusOfElasticityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcInductanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcWarpingMomentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcDynamicViscosityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcAreaMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLogical) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcAmountOfSubstanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcContextDependentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcThermalConductivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcEnergyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcRotationalStiffnessMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcDerivedMeasureValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPowerMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcThermalExpansionCoefficientMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcTorqueMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMassPerLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcCountMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcCurveStyleFontSelect) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcVolumetricFlowRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcModulusOfSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMassFlowRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMonetaryMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcTemperatureGradientMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcColour) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcVolumeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSectionalAreaIntegralMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcVaporPermeabilityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLinearVelocityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcModulusOfRotationalSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPlanarForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcInteger) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSimpleValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMeasureValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcWarpingConstantMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcElectricCapacitanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSoundPressureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSpecularRoughness) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcIlluminanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcText) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcTimeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcAccelerationMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLuminousIntensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPressureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcElectricVoltageMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcThermodynamicTemperatureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMagneticFluxMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSolidAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcFrequencyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPHMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcThermalAdmittanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSpecularExponent) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcDateTimeSelect) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLinearStiffnessMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcCompoundPlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcCurvatureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcAbsorbedDoseMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcParameterValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcDescriptiveMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMomentOfInertiaMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcDoseEquivalentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcComplexNumber) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcLuminousIntensityDistributionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcIsothermalMoistureCapacityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcElectricResistanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcThermalResistanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcShearModulusMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); if ( e->is(Type::IfcIdentifier) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcBoolean) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcSectionModulusMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMassMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcMoistureDiffusivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); - if ( e->is(Type::IfcPositivePlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIlluminanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcInductanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcInteger) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIntegerCountRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIonConcentrationMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcIsothermalMoistureCapacityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcKinematicViscosityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLabel) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearMomentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearStiffnessMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLinearVelocityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLogical) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLuminousFluxMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLuminousIntensityDistributionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcLuminousIntensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); if ( e->is(Type::IfcMagneticFluxDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMagneticFluxMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassDensityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassFlowRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMassPerLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMeasureValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfElasticityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfLinearSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfRotationalSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcModulusOfSubgradeReactionMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMoistureDiffusivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMolecularWeightMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMomentOfInertiaMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcMonetaryMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcNormalisedRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcNullStyle) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcNumericMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPHMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcParameterValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPlanarForceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPositiveLengthMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPositivePlaneAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPositiveRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPowerMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcPressureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRadioActivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRatioMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcReal) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRotationalFrequencyMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRotationalMassMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcRotationalStiffnessMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSectionModulusMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSectionalAreaIntegralMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcShearModulusMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSimpleValue) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSolidAngleMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSoundPowerMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSoundPressureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSpecificHeatCapacityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSpecularExponent) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcSpecularRoughness) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTemperatureGradientMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcText) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalAdmittanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalConductivityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalExpansionCoefficientMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalResistanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermalTransmittanceMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcThermodynamicTemperatureMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTimeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTimeStamp) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcTorqueMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcVaporPermeabilityMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcVolumeMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcVolumetricFlowRateMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcWarpingConstantMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); + if ( e->is(Type::IfcWarpingMomentMeasure) ) return IfcSchemaEntity(new IfcEntitySelect(e)); if ( e->is(Type::Ifc2DCompositeCurve) ) return IfcSchemaEntity(new Ifc2DCompositeCurve(e)); if ( e->is(Type::IfcActionRequest) ) return IfcSchemaEntity(new IfcActionRequest(e)); if ( e->is(Type::IfcActor) ) return IfcSchemaEntity(new IfcActor(e)); @@ -792,118 +791,117 @@ IfcSchemaEntity Ifc2x3::SchemaEntity(IfcAbstractEntityPtr e) { } std::string Type::ToString(Enum v) { - if (v < 0 || v >= 759) throw; - const char* names[] = { "IfcSoundPowerMeasure","IfcRotationalFrequencyMeasure","IfcSpecificHeatCapacityMeasure","IfcElectricConductanceMeasure","IfcElectricChargeMeasure","IfcPositiveLengthMeasure","IfcAngularVelocityMeasure","IfcNullStyle","IfcIonConcentrationMeasure","IfcModulusOfLinearSubgradeReactionMeasure","IfcHeatFluxDensityMeasure","IfcHeatingValueMeasure","IfcForceMeasure","IfcPositiveRatioMeasure","IfcMolecularWeightMeasure","IfcLuminousFluxMeasure","IfcNormalisedRatioMeasure","IfcLabel","IfcTimeStamp","IfcNumericMeasure","IfcRotationalMassMeasure","IfcLinearForceMeasure","IfcKinematicViscosityMeasure","IfcMassDensityMeasure","IfcIntegerCountRateMeasure","IfcRadioActivityMeasure","IfcReal","IfcLinearMomentMeasure","IfcElectricCurrentMeasure","IfcThermalTransmittanceMeasure","IfcModulusOfElasticityMeasure","IfcInductanceMeasure","IfcWarpingMomentMeasure","IfcDynamicViscosityMeasure","IfcAreaMeasure","IfcLogical","IfcAmountOfSubstanceMeasure","IfcContextDependentMeasure","IfcThermalConductivityMeasure","IfcEnergyMeasure","IfcRotationalStiffnessMeasure","IfcDerivedMeasureValue","IfcPowerMeasure","IfcThermalExpansionCoefficientMeasure","IfcTorqueMeasure","IfcMassPerLengthMeasure","IfcCountMeasure","IfcCurveStyleFontSelect","IfcVolumetricFlowRateMeasure","IfcModulusOfSubgradeReactionMeasure","IfcMassFlowRateMeasure","IfcMonetaryMeasure","IfcTemperatureGradientMeasure","IfcColour","IfcVolumeMeasure","IfcSectionalAreaIntegralMeasure","IfcVaporPermeabilityMeasure","IfcLinearVelocityMeasure","IfcLengthMeasure","IfcModulusOfRotationalSubgradeReactionMeasure","IfcPlanarForceMeasure","IfcInteger","IfcSimpleValue","IfcMeasureValue","IfcPlaneAngleMeasure","IfcWarpingConstantMeasure","IfcElectricCapacitanceMeasure","IfcSoundPressureMeasure","IfcSpecularRoughness","IfcIlluminanceMeasure","IfcText","IfcTimeMeasure","IfcAccelerationMeasure","IfcLuminousIntensityMeasure","IfcPressureMeasure","IfcElectricVoltageMeasure","IfcThermodynamicTemperatureMeasure","IfcMagneticFluxMeasure","IfcSolidAngleMeasure","IfcFrequencyMeasure","IfcPHMeasure","IfcThermalAdmittanceMeasure","IfcSpecularExponent","IfcDateTimeSelect","IfcLinearStiffnessMeasure","IfcCompoundPlaneAngleMeasure","IfcCurvatureMeasure","IfcAbsorbedDoseMeasure","IfcParameterValue","IfcDescriptiveMeasure","IfcMomentOfInertiaMeasure","IfcDoseEquivalentMeasure","IfcComplexNumber","IfcRatioMeasure","IfcLuminousIntensityDistributionMeasure","IfcIsothermalMoistureCapacityMeasure","IfcElectricResistanceMeasure","IfcThermalResistanceMeasure","IfcShearModulusMeasure","IfcIdentifier","IfcBoolean","IfcSectionModulusMeasure","IfcMassMeasure","IfcMoistureDiffusivityMeasure","IfcPositivePlaneAngleMeasure","IfcMagneticFluxDensityMeasure","Ifc2DCompositeCurve","IfcActionRequest","IfcActor","IfcActorRole","IfcActuatorType","IfcAddress","IfcAirTerminalBoxType","IfcAirTerminalType","IfcAirToAirHeatRecoveryType","IfcAlarmType","IfcAngularDimension","IfcAnnotation","IfcAnnotationCurveOccurrence","IfcAnnotationFillArea","IfcAnnotationFillAreaOccurrence","IfcAnnotationOccurrence","IfcAnnotationSurface","IfcAnnotationSurfaceOccurrence","IfcAnnotationSymbolOccurrence","IfcAnnotationTextOccurrence","IfcApplication","IfcAppliedValue","IfcAppliedValueRelationship","IfcApproval","IfcApprovalActorRelationship","IfcApprovalPropertyRelationship","IfcApprovalRelationship","IfcArbitraryClosedProfileDef","IfcArbitraryOpenProfileDef","IfcArbitraryProfileDefWithVoids","IfcAsset","IfcAsymmetricIShapeProfileDef","IfcAxis1Placement","IfcAxis2Placement2D","IfcAxis2Placement3D","IfcBSplineCurve","IfcBeam","IfcBeamType","IfcBezierCurve","IfcBlobTexture","IfcBlock","IfcBoilerType","IfcBooleanClippingResult","IfcBooleanResult","IfcBoundaryCondition","IfcBoundaryEdgeCondition","IfcBoundaryFaceCondition","IfcBoundaryNodeCondition","IfcBoundaryNodeConditionWarping","IfcBoundedCurve","IfcBoundedSurface","IfcBoundingBox","IfcBoxedHalfSpace","IfcBuilding","IfcBuildingElement","IfcBuildingElementComponent","IfcBuildingElementPart","IfcBuildingElementProxy","IfcBuildingElementProxyType","IfcBuildingElementType","IfcBuildingStorey","IfcCShapeProfileDef","IfcCableCarrierFittingType","IfcCableCarrierSegmentType","IfcCableSegmentType","IfcCalendarDate","IfcCartesianPoint","IfcCartesianTransformationOperator","IfcCartesianTransformationOperator2D","IfcCartesianTransformationOperator2DnonUniform","IfcCartesianTransformationOperator3D","IfcCartesianTransformationOperator3DnonUniform","IfcCenterLineProfileDef","IfcChamferEdgeFeature","IfcChillerType","IfcCircle","IfcCircleHollowProfileDef","IfcCircleProfileDef","IfcClassification","IfcClassificationItem","IfcClassificationItemRelationship","IfcClassificationNotation","IfcClassificationNotationFacet","IfcClassificationReference","IfcClosedShell","IfcCoilType","IfcColourRgb","IfcColourSpecification","IfcColumn","IfcColumnType","IfcComplexProperty","IfcCompositeCurve","IfcCompositeCurveSegment","IfcCompositeProfileDef","IfcCompressorType","IfcCondenserType","IfcCondition","IfcConditionCriterion","IfcConic","IfcConnectedFaceSet","IfcConnectionCurveGeometry","IfcConnectionGeometry","IfcConnectionPointEccentricity","IfcConnectionPointGeometry","IfcConnectionPortGeometry","IfcConnectionSurfaceGeometry","IfcConstraint","IfcConstraintAggregationRelationship","IfcConstraintClassificationRelationship","IfcConstraintRelationship","IfcConstructionEquipmentResource","IfcConstructionMaterialResource","IfcConstructionProductResource","IfcConstructionResource","IfcContextDependentUnit","IfcControl","IfcControllerType","IfcConversionBasedUnit","IfcCooledBeamType","IfcCoolingTowerType","IfcCoordinatedUniversalTimeOffset","IfcCostItem","IfcCostSchedule","IfcCostValue","IfcCovering","IfcCoveringType","IfcCraneRailAShapeProfileDef","IfcCraneRailFShapeProfileDef","IfcCrewResource","IfcCsgPrimitive3D","IfcCsgSolid","IfcCurrencyRelationship","IfcCurtainWall","IfcCurtainWallType","IfcCurve","IfcCurveBoundedPlane","IfcCurveStyle","IfcCurveStyleFont","IfcCurveStyleFontAndScaling","IfcCurveStyleFontPattern","IfcDamperType","IfcDateAndTime","IfcDefinedSymbol","IfcDerivedProfileDef","IfcDerivedUnit","IfcDerivedUnitElement","IfcDiameterDimension","IfcDimensionCalloutRelationship","IfcDimensionCurve","IfcDimensionCurveDirectedCallout","IfcDimensionCurveTerminator","IfcDimensionPair","IfcDimensionalExponents","IfcDirection","IfcDiscreteAccessory","IfcDiscreteAccessoryType","IfcDistributionChamberElement","IfcDistributionChamberElementType","IfcDistributionControlElement","IfcDistributionControlElementType","IfcDistributionElement","IfcDistributionElementType","IfcDistributionFlowElement","IfcDistributionFlowElementType","IfcDistributionPort","IfcDocumentElectronicFormat","IfcDocumentInformation","IfcDocumentInformationRelationship","IfcDocumentReference","IfcDoor","IfcDoorLiningProperties","IfcDoorPanelProperties","IfcDoorStyle","IfcDraughtingCallout","IfcDraughtingCalloutRelationship","IfcDraughtingPreDefinedColour","IfcDraughtingPreDefinedCurveFont","IfcDraughtingPreDefinedTextFont","IfcDuctFittingType","IfcDuctSegmentType","IfcDuctSilencerType","IfcEdge","IfcEdgeCurve","IfcEdgeFeature","IfcEdgeLoop","IfcElectricApplianceType","IfcElectricDistributionPoint","IfcElectricFlowStorageDeviceType","IfcElectricGeneratorType","IfcElectricHeaterType","IfcElectricMotorType","IfcElectricTimeControlType","IfcElectricalBaseProperties","IfcElectricalCircuit","IfcElectricalElement","IfcElement","IfcElementAssembly","IfcElementComponent","IfcElementComponentType","IfcElementQuantity","IfcElementType","IfcElementarySurface","IfcEllipse","IfcEllipseProfileDef","IfcEnergyConversionDevice","IfcEnergyConversionDeviceType","IfcEnergyProperties","IfcEnvironmentalImpactValue","IfcEquipmentElement","IfcEquipmentStandard","IfcEvaporativeCoolerType","IfcEvaporatorType","IfcExtendedMaterialProperties","IfcExternalReference","IfcExternallyDefinedHatchStyle","IfcExternallyDefinedSurfaceStyle","IfcExternallyDefinedSymbol","IfcExternallyDefinedTextFont","IfcExtrudedAreaSolid","IfcFace","IfcFaceBasedSurfaceModel","IfcFaceBound","IfcFaceOuterBound","IfcFaceSurface","IfcFacetedBrep","IfcFacetedBrepWithVoids","IfcFailureConnectionCondition","IfcFanType","IfcFastener","IfcFastenerType","IfcFeatureElement","IfcFeatureElementAddition","IfcFeatureElementSubtraction","IfcFillAreaStyle","IfcFillAreaStyleHatching","IfcFillAreaStyleTileSymbolWithStyle","IfcFillAreaStyleTiles","IfcFilterType","IfcFireSuppressionTerminalType","IfcFlowController","IfcFlowControllerType","IfcFlowFitting","IfcFlowFittingType","IfcFlowInstrumentType","IfcFlowMeterType","IfcFlowMovingDevice","IfcFlowMovingDeviceType","IfcFlowSegment","IfcFlowSegmentType","IfcFlowStorageDevice","IfcFlowStorageDeviceType","IfcFlowTerminal","IfcFlowTerminalType","IfcFlowTreatmentDevice","IfcFlowTreatmentDeviceType","IfcFluidFlowProperties","IfcFooting","IfcFuelProperties","IfcFurnishingElement","IfcFurnishingElementType","IfcFurnitureStandard","IfcFurnitureType","IfcGasTerminalType","IfcGeneralMaterialProperties","IfcGeneralProfileProperties","IfcGeometricCurveSet","IfcGeometricRepresentationContext","IfcGeometricRepresentationItem","IfcGeometricRepresentationSubContext","IfcGeometricSet","IfcGrid","IfcGridAxis","IfcGridPlacement","IfcGroup","IfcHalfSpaceSolid","IfcHeatExchangerType","IfcHumidifierType","IfcHygroscopicMaterialProperties","IfcIShapeProfileDef","IfcImageTexture","IfcInventory","IfcIrregularTimeSeries","IfcIrregularTimeSeriesValue","IfcJunctionBoxType","IfcLShapeProfileDef","IfcLaborResource","IfcLampType","IfcLibraryInformation","IfcLibraryReference","IfcLightDistributionData","IfcLightFixtureType","IfcLightIntensityDistribution","IfcLightSource","IfcLightSourceAmbient","IfcLightSourceDirectional","IfcLightSourceGoniometric","IfcLightSourcePositional","IfcLightSourceSpot","IfcLine","IfcLinearDimension","IfcLocalPlacement","IfcLocalTime","IfcLoop","IfcManifoldSolidBrep","IfcMappedItem","IfcMaterial","IfcMaterialClassificationRelationship","IfcMaterialDefinitionRepresentation","IfcMaterialLayer","IfcMaterialLayerSet","IfcMaterialLayerSetUsage","IfcMaterialList","IfcMaterialProperties","IfcMeasureWithUnit","IfcMechanicalConcreteMaterialProperties","IfcMechanicalFastener","IfcMechanicalFastenerType","IfcMechanicalMaterialProperties","IfcMechanicalSteelMaterialProperties","IfcMember","IfcMemberType","IfcMetric","IfcMonetaryUnit","IfcMotorConnectionType","IfcMove","IfcNamedUnit","IfcObject","IfcObjectDefinition","IfcObjectPlacement","IfcObjective","IfcOccupant","IfcOffsetCurve2D","IfcOffsetCurve3D","IfcOneDirectionRepeatFactor","IfcOpenShell","IfcOpeningElement","IfcOpticalMaterialProperties","IfcOrderAction","IfcOrganization","IfcOrganizationRelationship","IfcOrientedEdge","IfcOutletType","IfcOwnerHistory","IfcParameterizedProfileDef","IfcPath","IfcPerformanceHistory","IfcPermeableCoveringProperties","IfcPermit","IfcPerson","IfcPersonAndOrganization","IfcPhysicalComplexQuantity","IfcPhysicalQuantity","IfcPhysicalSimpleQuantity","IfcPile","IfcPipeFittingType","IfcPipeSegmentType","IfcPixelTexture","IfcPlacement","IfcPlanarBox","IfcPlanarExtent","IfcPlane","IfcPlate","IfcPlateType","IfcPoint","IfcPointOnCurve","IfcPointOnSurface","IfcPolyLoop","IfcPolygonalBoundedHalfSpace","IfcPolyline","IfcPort","IfcPostalAddress","IfcPreDefinedColour","IfcPreDefinedCurveFont","IfcPreDefinedDimensionSymbol","IfcPreDefinedItem","IfcPreDefinedPointMarkerSymbol","IfcPreDefinedSymbol","IfcPreDefinedTerminatorSymbol","IfcPreDefinedTextFont","IfcPresentationLayerAssignment","IfcPresentationLayerWithStyle","IfcPresentationStyle","IfcPresentationStyleAssignment","IfcProcedure","IfcProcess","IfcProduct","IfcProductDefinitionShape","IfcProductRepresentation","IfcProductsOfCombustionProperties","IfcProfileDef","IfcProfileProperties","IfcProject","IfcProjectOrder","IfcProjectOrderRecord","IfcProjectionCurve","IfcProjectionElement","IfcProperty","IfcPropertyBoundedValue","IfcPropertyConstraintRelationship","IfcPropertyDefinition","IfcPropertyDependencyRelationship","IfcPropertyEnumeratedValue","IfcPropertyEnumeration","IfcPropertyListValue","IfcPropertyReferenceValue","IfcPropertySet","IfcPropertySetDefinition","IfcPropertySingleValue","IfcPropertyTableValue","IfcProtectiveDeviceType","IfcProxy","IfcPumpType","IfcQuantityArea","IfcQuantityCount","IfcQuantityLength","IfcQuantityTime","IfcQuantityVolume","IfcQuantityWeight","IfcRadiusDimension","IfcRailing","IfcRailingType","IfcRamp","IfcRampFlight","IfcRampFlightType","IfcRationalBezierCurve","IfcRectangleHollowProfileDef","IfcRectangleProfileDef","IfcRectangularPyramid","IfcRectangularTrimmedSurface","IfcReferencesValueDocument","IfcRegularTimeSeries","IfcReinforcementBarProperties","IfcReinforcementDefinitionProperties","IfcReinforcingBar","IfcReinforcingElement","IfcReinforcingMesh","IfcRelAggregates","IfcRelAssigns","IfcRelAssignsTasks","IfcRelAssignsToActor","IfcRelAssignsToControl","IfcRelAssignsToGroup","IfcRelAssignsToProcess","IfcRelAssignsToProduct","IfcRelAssignsToProjectOrder","IfcRelAssignsToResource","IfcRelAssociates","IfcRelAssociatesAppliedValue","IfcRelAssociatesApproval","IfcRelAssociatesClassification","IfcRelAssociatesConstraint","IfcRelAssociatesDocument","IfcRelAssociatesLibrary","IfcRelAssociatesMaterial","IfcRelAssociatesProfileProperties","IfcRelConnects","IfcRelConnectsElements","IfcRelConnectsPathElements","IfcRelConnectsPortToElement","IfcRelConnectsPorts","IfcRelConnectsStructuralActivity","IfcRelConnectsStructuralElement","IfcRelConnectsStructuralMember","IfcRelConnectsWithEccentricity","IfcRelConnectsWithRealizingElements","IfcRelContainedInSpatialStructure","IfcRelCoversBldgElements","IfcRelCoversSpaces","IfcRelDecomposes","IfcRelDefines","IfcRelDefinesByProperties","IfcRelDefinesByType","IfcRelFillsElement","IfcRelFlowControlElements","IfcRelInteractionRequirements","IfcRelNests","IfcRelOccupiesSpaces","IfcRelOverridesProperties","IfcRelProjectsElement","IfcRelReferencedInSpatialStructure","IfcRelSchedulesCostItems","IfcRelSequence","IfcRelServicesBuildings","IfcRelSpaceBoundary","IfcRelVoidsElement","IfcRelationship","IfcRelaxation","IfcRepresentation","IfcRepresentationContext","IfcRepresentationItem","IfcRepresentationMap","IfcResource","IfcRevolvedAreaSolid","IfcRibPlateProfileProperties","IfcRightCircularCone","IfcRightCircularCylinder","IfcRoof","IfcRoot","IfcRoundedEdgeFeature","IfcRoundedRectangleProfileDef","IfcSIUnit","IfcSanitaryTerminalType","IfcScheduleTimeControl","IfcSectionProperties","IfcSectionReinforcementProperties","IfcSectionedSpine","IfcSensorType","IfcServiceLife","IfcServiceLifeFactor","IfcShapeAspect","IfcShapeModel","IfcShapeRepresentation","IfcShellBasedSurfaceModel","IfcSimpleProperty","IfcSite","IfcSlab","IfcSlabType","IfcSlippageConnectionCondition","IfcSolidModel","IfcSoundProperties","IfcSoundValue","IfcSpace","IfcSpaceHeaterType","IfcSpaceProgram","IfcSpaceThermalLoadProperties","IfcSpaceType","IfcSpatialStructureElement","IfcSpatialStructureElementType","IfcSphere","IfcStackTerminalType","IfcStair","IfcStairFlight","IfcStairFlightType","IfcStructuralAction","IfcStructuralActivity","IfcStructuralAnalysisModel","IfcStructuralConnection","IfcStructuralConnectionCondition","IfcStructuralCurveConnection","IfcStructuralCurveMember","IfcStructuralCurveMemberVarying","IfcStructuralItem","IfcStructuralLinearAction","IfcStructuralLinearActionVarying","IfcStructuralLoad","IfcStructuralLoadGroup","IfcStructuralLoadLinearForce","IfcStructuralLoadPlanarForce","IfcStructuralLoadSingleDisplacement","IfcStructuralLoadSingleDisplacementDistortion","IfcStructuralLoadSingleForce","IfcStructuralLoadSingleForceWarping","IfcStructuralLoadStatic","IfcStructuralLoadTemperature","IfcStructuralMember","IfcStructuralPlanarAction","IfcStructuralPlanarActionVarying","IfcStructuralPointAction","IfcStructuralPointConnection","IfcStructuralPointReaction","IfcStructuralProfileProperties","IfcStructuralReaction","IfcStructuralResultGroup","IfcStructuralSteelProfileProperties","IfcStructuralSurfaceConnection","IfcStructuralSurfaceMember","IfcStructuralSurfaceMemberVarying","IfcStructuredDimensionCallout","IfcStyleModel","IfcStyledItem","IfcStyledRepresentation","IfcSubContractResource","IfcSubedge","IfcSurface","IfcSurfaceCurveSweptAreaSolid","IfcSurfaceOfLinearExtrusion","IfcSurfaceOfRevolution","IfcSurfaceStyle","IfcSurfaceStyleLighting","IfcSurfaceStyleRefraction","IfcSurfaceStyleRendering","IfcSurfaceStyleShading","IfcSurfaceStyleWithTextures","IfcSurfaceTexture","IfcSweptAreaSolid","IfcSweptDiskSolid","IfcSweptSurface","IfcSwitchingDeviceType","IfcSymbolStyle","IfcSystem","IfcSystemFurnitureElementType","IfcTShapeProfileDef","IfcTable","IfcTableRow","IfcTankType","IfcTask","IfcTelecomAddress","IfcTendon","IfcTendonAnchor","IfcTerminatorSymbol","IfcTextLiteral","IfcTextLiteralWithExtent","IfcTextStyle","IfcTextStyleFontModel","IfcTextStyleForDefinedFont","IfcTextStyleTextModel","IfcTextStyleWithBoxCharacteristics","IfcTextureCoordinate","IfcTextureCoordinateGenerator","IfcTextureMap","IfcTextureVertex","IfcThermalMaterialProperties","IfcTimeSeries","IfcTimeSeriesReferenceRelationship","IfcTimeSeriesSchedule","IfcTimeSeriesValue","IfcTopologicalRepresentationItem","IfcTopologyRepresentation","IfcTransformerType","IfcTransportElement","IfcTransportElementType","IfcTrapeziumProfileDef","IfcTrimmedCurve","IfcTubeBundleType","IfcTwoDirectionRepeatFactor","IfcTypeObject","IfcTypeProduct","IfcUShapeProfileDef","IfcUnitAssignment","IfcUnitaryEquipmentType","IfcValveType","IfcVector","IfcVertex","IfcVertexBasedTextureMap","IfcVertexLoop","IfcVertexPoint","IfcVibrationIsolatorType","IfcVirtualElement","IfcVirtualGridIntersection","IfcWall","IfcWallStandardCase","IfcWallType","IfcWasteTerminalType","IfcWaterProperties","IfcWindow","IfcWindowLiningProperties","IfcWindowPanelProperties","IfcWindowStyle","IfcWorkControl","IfcWorkPlan","IfcWorkSchedule","IfcZShapeProfileDef","IfcZone" }; + if (v < 0 || v >= 758) throw; + const char* names[] = { "IfcAbsorbedDoseMeasure","IfcAccelerationMeasure","IfcAmountOfSubstanceMeasure","IfcAngularVelocityMeasure","IfcAreaMeasure","IfcBoolean","IfcColour","IfcComplexNumber","IfcCompoundPlaneAngleMeasure","IfcContextDependentMeasure","IfcCountMeasure","IfcCurvatureMeasure","IfcDateTimeSelect","IfcDerivedMeasureValue","IfcDescriptiveMeasure","IfcDoseEquivalentMeasure","IfcDynamicViscosityMeasure","IfcElectricCapacitanceMeasure","IfcElectricChargeMeasure","IfcElectricConductanceMeasure","IfcElectricCurrentMeasure","IfcElectricResistanceMeasure","IfcElectricVoltageMeasure","IfcEnergyMeasure","IfcForceMeasure","IfcFrequencyMeasure","IfcHeatFluxDensityMeasure","IfcHeatingValueMeasure","IfcIdentifier","IfcIlluminanceMeasure","IfcInductanceMeasure","IfcInteger","IfcIntegerCountRateMeasure","IfcIonConcentrationMeasure","IfcIsothermalMoistureCapacityMeasure","IfcKinematicViscosityMeasure","IfcLabel","IfcLengthMeasure","IfcLinearForceMeasure","IfcLinearMomentMeasure","IfcLinearStiffnessMeasure","IfcLinearVelocityMeasure","IfcLogical","IfcLuminousFluxMeasure","IfcLuminousIntensityDistributionMeasure","IfcLuminousIntensityMeasure","IfcMagneticFluxDensityMeasure","IfcMagneticFluxMeasure","IfcMassDensityMeasure","IfcMassFlowRateMeasure","IfcMassMeasure","IfcMassPerLengthMeasure","IfcMeasureValue","IfcModulusOfElasticityMeasure","IfcModulusOfLinearSubgradeReactionMeasure","IfcModulusOfRotationalSubgradeReactionMeasure","IfcModulusOfSubgradeReactionMeasure","IfcMoistureDiffusivityMeasure","IfcMolecularWeightMeasure","IfcMomentOfInertiaMeasure","IfcMonetaryMeasure","IfcNormalisedRatioMeasure","IfcNullStyle","IfcNumericMeasure","IfcPHMeasure","IfcParameterValue","IfcPlanarForceMeasure","IfcPlaneAngleMeasure","IfcPositiveLengthMeasure","IfcPositivePlaneAngleMeasure","IfcPositiveRatioMeasure","IfcPowerMeasure","IfcPressureMeasure","IfcRadioActivityMeasure","IfcRatioMeasure","IfcReal","IfcRotationalFrequencyMeasure","IfcRotationalMassMeasure","IfcRotationalStiffnessMeasure","IfcSectionModulusMeasure","IfcSectionalAreaIntegralMeasure","IfcShearModulusMeasure","IfcSimpleValue","IfcSolidAngleMeasure","IfcSoundPowerMeasure","IfcSoundPressureMeasure","IfcSpecificHeatCapacityMeasure","IfcSpecularExponent","IfcSpecularRoughness","IfcTemperatureGradientMeasure","IfcText","IfcThermalAdmittanceMeasure","IfcThermalConductivityMeasure","IfcThermalExpansionCoefficientMeasure","IfcThermalResistanceMeasure","IfcThermalTransmittanceMeasure","IfcThermodynamicTemperatureMeasure","IfcTimeMeasure","IfcTimeStamp","IfcTorqueMeasure","IfcVaporPermeabilityMeasure","IfcVolumeMeasure","IfcVolumetricFlowRateMeasure","IfcWarpingConstantMeasure","IfcWarpingMomentMeasure","Ifc2DCompositeCurve","IfcActionRequest","IfcActor","IfcActorRole","IfcActuatorType","IfcAddress","IfcAirTerminalBoxType","IfcAirTerminalType","IfcAirToAirHeatRecoveryType","IfcAlarmType","IfcAngularDimension","IfcAnnotation","IfcAnnotationCurveOccurrence","IfcAnnotationFillArea","IfcAnnotationFillAreaOccurrence","IfcAnnotationOccurrence","IfcAnnotationSurface","IfcAnnotationSurfaceOccurrence","IfcAnnotationSymbolOccurrence","IfcAnnotationTextOccurrence","IfcApplication","IfcAppliedValue","IfcAppliedValueRelationship","IfcApproval","IfcApprovalActorRelationship","IfcApprovalPropertyRelationship","IfcApprovalRelationship","IfcArbitraryClosedProfileDef","IfcArbitraryOpenProfileDef","IfcArbitraryProfileDefWithVoids","IfcAsset","IfcAsymmetricIShapeProfileDef","IfcAxis1Placement","IfcAxis2Placement2D","IfcAxis2Placement3D","IfcBSplineCurve","IfcBeam","IfcBeamType","IfcBezierCurve","IfcBlobTexture","IfcBlock","IfcBoilerType","IfcBooleanClippingResult","IfcBooleanResult","IfcBoundaryCondition","IfcBoundaryEdgeCondition","IfcBoundaryFaceCondition","IfcBoundaryNodeCondition","IfcBoundaryNodeConditionWarping","IfcBoundedCurve","IfcBoundedSurface","IfcBoundingBox","IfcBoxedHalfSpace","IfcBuilding","IfcBuildingElement","IfcBuildingElementComponent","IfcBuildingElementPart","IfcBuildingElementProxy","IfcBuildingElementProxyType","IfcBuildingElementType","IfcBuildingStorey","IfcCShapeProfileDef","IfcCableCarrierFittingType","IfcCableCarrierSegmentType","IfcCableSegmentType","IfcCalendarDate","IfcCartesianPoint","IfcCartesianTransformationOperator","IfcCartesianTransformationOperator2D","IfcCartesianTransformationOperator2DnonUniform","IfcCartesianTransformationOperator3D","IfcCartesianTransformationOperator3DnonUniform","IfcCenterLineProfileDef","IfcChamferEdgeFeature","IfcChillerType","IfcCircle","IfcCircleHollowProfileDef","IfcCircleProfileDef","IfcClassification","IfcClassificationItem","IfcClassificationItemRelationship","IfcClassificationNotation","IfcClassificationNotationFacet","IfcClassificationReference","IfcClosedShell","IfcCoilType","IfcColourRgb","IfcColourSpecification","IfcColumn","IfcColumnType","IfcComplexProperty","IfcCompositeCurve","IfcCompositeCurveSegment","IfcCompositeProfileDef","IfcCompressorType","IfcCondenserType","IfcCondition","IfcConditionCriterion","IfcConic","IfcConnectedFaceSet","IfcConnectionCurveGeometry","IfcConnectionGeometry","IfcConnectionPointEccentricity","IfcConnectionPointGeometry","IfcConnectionPortGeometry","IfcConnectionSurfaceGeometry","IfcConstraint","IfcConstraintAggregationRelationship","IfcConstraintClassificationRelationship","IfcConstraintRelationship","IfcConstructionEquipmentResource","IfcConstructionMaterialResource","IfcConstructionProductResource","IfcConstructionResource","IfcContextDependentUnit","IfcControl","IfcControllerType","IfcConversionBasedUnit","IfcCooledBeamType","IfcCoolingTowerType","IfcCoordinatedUniversalTimeOffset","IfcCostItem","IfcCostSchedule","IfcCostValue","IfcCovering","IfcCoveringType","IfcCraneRailAShapeProfileDef","IfcCraneRailFShapeProfileDef","IfcCrewResource","IfcCsgPrimitive3D","IfcCsgSolid","IfcCurrencyRelationship","IfcCurtainWall","IfcCurtainWallType","IfcCurve","IfcCurveBoundedPlane","IfcCurveStyle","IfcCurveStyleFont","IfcCurveStyleFontAndScaling","IfcCurveStyleFontPattern","IfcDamperType","IfcDateAndTime","IfcDefinedSymbol","IfcDerivedProfileDef","IfcDerivedUnit","IfcDerivedUnitElement","IfcDiameterDimension","IfcDimensionCalloutRelationship","IfcDimensionCurve","IfcDimensionCurveDirectedCallout","IfcDimensionCurveTerminator","IfcDimensionPair","IfcDimensionalExponents","IfcDirection","IfcDiscreteAccessory","IfcDiscreteAccessoryType","IfcDistributionChamberElement","IfcDistributionChamberElementType","IfcDistributionControlElement","IfcDistributionControlElementType","IfcDistributionElement","IfcDistributionElementType","IfcDistributionFlowElement","IfcDistributionFlowElementType","IfcDistributionPort","IfcDocumentElectronicFormat","IfcDocumentInformation","IfcDocumentInformationRelationship","IfcDocumentReference","IfcDoor","IfcDoorLiningProperties","IfcDoorPanelProperties","IfcDoorStyle","IfcDraughtingCallout","IfcDraughtingCalloutRelationship","IfcDraughtingPreDefinedColour","IfcDraughtingPreDefinedCurveFont","IfcDraughtingPreDefinedTextFont","IfcDuctFittingType","IfcDuctSegmentType","IfcDuctSilencerType","IfcEdge","IfcEdgeCurve","IfcEdgeFeature","IfcEdgeLoop","IfcElectricApplianceType","IfcElectricDistributionPoint","IfcElectricFlowStorageDeviceType","IfcElectricGeneratorType","IfcElectricHeaterType","IfcElectricMotorType","IfcElectricTimeControlType","IfcElectricalBaseProperties","IfcElectricalCircuit","IfcElectricalElement","IfcElement","IfcElementAssembly","IfcElementComponent","IfcElementComponentType","IfcElementQuantity","IfcElementType","IfcElementarySurface","IfcEllipse","IfcEllipseProfileDef","IfcEnergyConversionDevice","IfcEnergyConversionDeviceType","IfcEnergyProperties","IfcEnvironmentalImpactValue","IfcEquipmentElement","IfcEquipmentStandard","IfcEvaporativeCoolerType","IfcEvaporatorType","IfcExtendedMaterialProperties","IfcExternalReference","IfcExternallyDefinedHatchStyle","IfcExternallyDefinedSurfaceStyle","IfcExternallyDefinedSymbol","IfcExternallyDefinedTextFont","IfcExtrudedAreaSolid","IfcFace","IfcFaceBasedSurfaceModel","IfcFaceBound","IfcFaceOuterBound","IfcFaceSurface","IfcFacetedBrep","IfcFacetedBrepWithVoids","IfcFailureConnectionCondition","IfcFanType","IfcFastener","IfcFastenerType","IfcFeatureElement","IfcFeatureElementAddition","IfcFeatureElementSubtraction","IfcFillAreaStyle","IfcFillAreaStyleHatching","IfcFillAreaStyleTileSymbolWithStyle","IfcFillAreaStyleTiles","IfcFilterType","IfcFireSuppressionTerminalType","IfcFlowController","IfcFlowControllerType","IfcFlowFitting","IfcFlowFittingType","IfcFlowInstrumentType","IfcFlowMeterType","IfcFlowMovingDevice","IfcFlowMovingDeviceType","IfcFlowSegment","IfcFlowSegmentType","IfcFlowStorageDevice","IfcFlowStorageDeviceType","IfcFlowTerminal","IfcFlowTerminalType","IfcFlowTreatmentDevice","IfcFlowTreatmentDeviceType","IfcFluidFlowProperties","IfcFooting","IfcFuelProperties","IfcFurnishingElement","IfcFurnishingElementType","IfcFurnitureStandard","IfcFurnitureType","IfcGasTerminalType","IfcGeneralMaterialProperties","IfcGeneralProfileProperties","IfcGeometricCurveSet","IfcGeometricRepresentationContext","IfcGeometricRepresentationItem","IfcGeometricRepresentationSubContext","IfcGeometricSet","IfcGrid","IfcGridAxis","IfcGridPlacement","IfcGroup","IfcHalfSpaceSolid","IfcHeatExchangerType","IfcHumidifierType","IfcHygroscopicMaterialProperties","IfcIShapeProfileDef","IfcImageTexture","IfcInventory","IfcIrregularTimeSeries","IfcIrregularTimeSeriesValue","IfcJunctionBoxType","IfcLShapeProfileDef","IfcLaborResource","IfcLampType","IfcLibraryInformation","IfcLibraryReference","IfcLightDistributionData","IfcLightFixtureType","IfcLightIntensityDistribution","IfcLightSource","IfcLightSourceAmbient","IfcLightSourceDirectional","IfcLightSourceGoniometric","IfcLightSourcePositional","IfcLightSourceSpot","IfcLine","IfcLinearDimension","IfcLocalPlacement","IfcLocalTime","IfcLoop","IfcManifoldSolidBrep","IfcMappedItem","IfcMaterial","IfcMaterialClassificationRelationship","IfcMaterialDefinitionRepresentation","IfcMaterialLayer","IfcMaterialLayerSet","IfcMaterialLayerSetUsage","IfcMaterialList","IfcMaterialProperties","IfcMeasureWithUnit","IfcMechanicalConcreteMaterialProperties","IfcMechanicalFastener","IfcMechanicalFastenerType","IfcMechanicalMaterialProperties","IfcMechanicalSteelMaterialProperties","IfcMember","IfcMemberType","IfcMetric","IfcMonetaryUnit","IfcMotorConnectionType","IfcMove","IfcNamedUnit","IfcObject","IfcObjectDefinition","IfcObjectPlacement","IfcObjective","IfcOccupant","IfcOffsetCurve2D","IfcOffsetCurve3D","IfcOneDirectionRepeatFactor","IfcOpenShell","IfcOpeningElement","IfcOpticalMaterialProperties","IfcOrderAction","IfcOrganization","IfcOrganizationRelationship","IfcOrientedEdge","IfcOutletType","IfcOwnerHistory","IfcParameterizedProfileDef","IfcPath","IfcPerformanceHistory","IfcPermeableCoveringProperties","IfcPermit","IfcPerson","IfcPersonAndOrganization","IfcPhysicalComplexQuantity","IfcPhysicalQuantity","IfcPhysicalSimpleQuantity","IfcPile","IfcPipeFittingType","IfcPipeSegmentType","IfcPixelTexture","IfcPlacement","IfcPlanarBox","IfcPlanarExtent","IfcPlane","IfcPlate","IfcPlateType","IfcPoint","IfcPointOnCurve","IfcPointOnSurface","IfcPolyLoop","IfcPolygonalBoundedHalfSpace","IfcPolyline","IfcPort","IfcPostalAddress","IfcPreDefinedColour","IfcPreDefinedCurveFont","IfcPreDefinedDimensionSymbol","IfcPreDefinedItem","IfcPreDefinedPointMarkerSymbol","IfcPreDefinedSymbol","IfcPreDefinedTerminatorSymbol","IfcPreDefinedTextFont","IfcPresentationLayerAssignment","IfcPresentationLayerWithStyle","IfcPresentationStyle","IfcPresentationStyleAssignment","IfcProcedure","IfcProcess","IfcProduct","IfcProductDefinitionShape","IfcProductRepresentation","IfcProductsOfCombustionProperties","IfcProfileDef","IfcProfileProperties","IfcProject","IfcProjectOrder","IfcProjectOrderRecord","IfcProjectionCurve","IfcProjectionElement","IfcProperty","IfcPropertyBoundedValue","IfcPropertyConstraintRelationship","IfcPropertyDefinition","IfcPropertyDependencyRelationship","IfcPropertyEnumeratedValue","IfcPropertyEnumeration","IfcPropertyListValue","IfcPropertyReferenceValue","IfcPropertySet","IfcPropertySetDefinition","IfcPropertySingleValue","IfcPropertyTableValue","IfcProtectiveDeviceType","IfcProxy","IfcPumpType","IfcQuantityArea","IfcQuantityCount","IfcQuantityLength","IfcQuantityTime","IfcQuantityVolume","IfcQuantityWeight","IfcRadiusDimension","IfcRailing","IfcRailingType","IfcRamp","IfcRampFlight","IfcRampFlightType","IfcRationalBezierCurve","IfcRectangleHollowProfileDef","IfcRectangleProfileDef","IfcRectangularPyramid","IfcRectangularTrimmedSurface","IfcReferencesValueDocument","IfcRegularTimeSeries","IfcReinforcementBarProperties","IfcReinforcementDefinitionProperties","IfcReinforcingBar","IfcReinforcingElement","IfcReinforcingMesh","IfcRelAggregates","IfcRelAssigns","IfcRelAssignsTasks","IfcRelAssignsToActor","IfcRelAssignsToControl","IfcRelAssignsToGroup","IfcRelAssignsToProcess","IfcRelAssignsToProduct","IfcRelAssignsToProjectOrder","IfcRelAssignsToResource","IfcRelAssociates","IfcRelAssociatesAppliedValue","IfcRelAssociatesApproval","IfcRelAssociatesClassification","IfcRelAssociatesConstraint","IfcRelAssociatesDocument","IfcRelAssociatesLibrary","IfcRelAssociatesMaterial","IfcRelAssociatesProfileProperties","IfcRelConnects","IfcRelConnectsElements","IfcRelConnectsPathElements","IfcRelConnectsPortToElement","IfcRelConnectsPorts","IfcRelConnectsStructuralActivity","IfcRelConnectsStructuralElement","IfcRelConnectsStructuralMember","IfcRelConnectsWithEccentricity","IfcRelConnectsWithRealizingElements","IfcRelContainedInSpatialStructure","IfcRelCoversBldgElements","IfcRelCoversSpaces","IfcRelDecomposes","IfcRelDefines","IfcRelDefinesByProperties","IfcRelDefinesByType","IfcRelFillsElement","IfcRelFlowControlElements","IfcRelInteractionRequirements","IfcRelNests","IfcRelOccupiesSpaces","IfcRelOverridesProperties","IfcRelProjectsElement","IfcRelReferencedInSpatialStructure","IfcRelSchedulesCostItems","IfcRelSequence","IfcRelServicesBuildings","IfcRelSpaceBoundary","IfcRelVoidsElement","IfcRelationship","IfcRelaxation","IfcRepresentation","IfcRepresentationContext","IfcRepresentationItem","IfcRepresentationMap","IfcResource","IfcRevolvedAreaSolid","IfcRibPlateProfileProperties","IfcRightCircularCone","IfcRightCircularCylinder","IfcRoof","IfcRoot","IfcRoundedEdgeFeature","IfcRoundedRectangleProfileDef","IfcSIUnit","IfcSanitaryTerminalType","IfcScheduleTimeControl","IfcSectionProperties","IfcSectionReinforcementProperties","IfcSectionedSpine","IfcSensorType","IfcServiceLife","IfcServiceLifeFactor","IfcShapeAspect","IfcShapeModel","IfcShapeRepresentation","IfcShellBasedSurfaceModel","IfcSimpleProperty","IfcSite","IfcSlab","IfcSlabType","IfcSlippageConnectionCondition","IfcSolidModel","IfcSoundProperties","IfcSoundValue","IfcSpace","IfcSpaceHeaterType","IfcSpaceProgram","IfcSpaceThermalLoadProperties","IfcSpaceType","IfcSpatialStructureElement","IfcSpatialStructureElementType","IfcSphere","IfcStackTerminalType","IfcStair","IfcStairFlight","IfcStairFlightType","IfcStructuralAction","IfcStructuralActivity","IfcStructuralAnalysisModel","IfcStructuralConnection","IfcStructuralConnectionCondition","IfcStructuralCurveConnection","IfcStructuralCurveMember","IfcStructuralCurveMemberVarying","IfcStructuralItem","IfcStructuralLinearAction","IfcStructuralLinearActionVarying","IfcStructuralLoad","IfcStructuralLoadGroup","IfcStructuralLoadLinearForce","IfcStructuralLoadPlanarForce","IfcStructuralLoadSingleDisplacement","IfcStructuralLoadSingleDisplacementDistortion","IfcStructuralLoadSingleForce","IfcStructuralLoadSingleForceWarping","IfcStructuralLoadStatic","IfcStructuralLoadTemperature","IfcStructuralMember","IfcStructuralPlanarAction","IfcStructuralPlanarActionVarying","IfcStructuralPointAction","IfcStructuralPointConnection","IfcStructuralPointReaction","IfcStructuralProfileProperties","IfcStructuralReaction","IfcStructuralResultGroup","IfcStructuralSteelProfileProperties","IfcStructuralSurfaceConnection","IfcStructuralSurfaceMember","IfcStructuralSurfaceMemberVarying","IfcStructuredDimensionCallout","IfcStyleModel","IfcStyledItem","IfcStyledRepresentation","IfcSubContractResource","IfcSubedge","IfcSurface","IfcSurfaceCurveSweptAreaSolid","IfcSurfaceOfLinearExtrusion","IfcSurfaceOfRevolution","IfcSurfaceStyle","IfcSurfaceStyleLighting","IfcSurfaceStyleRefraction","IfcSurfaceStyleRendering","IfcSurfaceStyleShading","IfcSurfaceStyleWithTextures","IfcSurfaceTexture","IfcSweptAreaSolid","IfcSweptDiskSolid","IfcSweptSurface","IfcSwitchingDeviceType","IfcSymbolStyle","IfcSystem","IfcSystemFurnitureElementType","IfcTShapeProfileDef","IfcTable","IfcTableRow","IfcTankType","IfcTask","IfcTelecomAddress","IfcTendon","IfcTendonAnchor","IfcTerminatorSymbol","IfcTextLiteral","IfcTextLiteralWithExtent","IfcTextStyle","IfcTextStyleFontModel","IfcTextStyleForDefinedFont","IfcTextStyleTextModel","IfcTextStyleWithBoxCharacteristics","IfcTextureCoordinate","IfcTextureCoordinateGenerator","IfcTextureMap","IfcTextureVertex","IfcThermalMaterialProperties","IfcTimeSeries","IfcTimeSeriesReferenceRelationship","IfcTimeSeriesSchedule","IfcTimeSeriesValue","IfcTopologicalRepresentationItem","IfcTopologyRepresentation","IfcTransformerType","IfcTransportElement","IfcTransportElementType","IfcTrapeziumProfileDef","IfcTrimmedCurve","IfcTubeBundleType","IfcTwoDirectionRepeatFactor","IfcTypeObject","IfcTypeProduct","IfcUShapeProfileDef","IfcUnitAssignment","IfcUnitaryEquipmentType","IfcValveType","IfcVector","IfcVertex","IfcVertexBasedTextureMap","IfcVertexLoop","IfcVertexPoint","IfcVibrationIsolatorType","IfcVirtualElement","IfcVirtualGridIntersection","IfcWall","IfcWallStandardCase","IfcWallType","IfcWasteTerminalType","IfcWaterProperties","IfcWindow","IfcWindowLiningProperties","IfcWindowPanelProperties","IfcWindowStyle","IfcWorkControl","IfcWorkPlan","IfcWorkSchedule","IfcZShapeProfileDef","IfcZone" }; return names[v]; } Type::Enum Type::FromString(const std::string& s){ - if(s=="IFCSOUNDPOWERMEASURE" ) { return IfcSoundPowerMeasure; } - if(s=="IFCROTATIONALFREQUENCYMEASURE" ) { return IfcRotationalFrequencyMeasure; } - if(s=="IFCSPECIFICHEATCAPACITYMEASURE" ) { return IfcSpecificHeatCapacityMeasure; } - if(s=="IFCELECTRICCONDUCTANCEMEASURE" ) { return IfcElectricConductanceMeasure; } - if(s=="IFCELECTRICCHARGEMEASURE" ) { return IfcElectricChargeMeasure; } - if(s=="IFCPOSITIVELENGTHMEASURE" ) { return IfcPositiveLengthMeasure; } + if(s=="IFCABSORBEDDOSEMEASURE" ) { return IfcAbsorbedDoseMeasure; } + if(s=="IFCACCELERATIONMEASURE" ) { return IfcAccelerationMeasure; } + if(s=="IFCAMOUNTOFSUBSTANCEMEASURE" ) { return IfcAmountOfSubstanceMeasure; } if(s=="IFCANGULARVELOCITYMEASURE" ) { return IfcAngularVelocityMeasure; } - if(s=="IFCNULLSTYLE" ) { return IfcNullStyle; } - if(s=="IFCIONCONCENTRATIONMEASURE" ) { return IfcIonConcentrationMeasure; } - if(s=="IFCMODULUSOFLINEARSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfLinearSubgradeReactionMeasure; } + if(s=="IFCAREAMEASURE" ) { return IfcAreaMeasure; } + if(s=="IFCBOOLEAN" ) { return IfcBoolean; } + if(s=="IFCCOLOUR" ) { return IfcColour; } + if(s=="IFCCOMPLEXNUMBER" ) { return IfcComplexNumber; } + if(s=="IFCCOMPOUNDPLANEANGLEMEASURE" ) { return IfcCompoundPlaneAngleMeasure; } + if(s=="IFCCONTEXTDEPENDENTMEASURE" ) { return IfcContextDependentMeasure; } + if(s=="IFCCOUNTMEASURE" ) { return IfcCountMeasure; } + if(s=="IFCCURVATUREMEASURE" ) { return IfcCurvatureMeasure; } + if(s=="IFCDATETIMESELECT" ) { return IfcDateTimeSelect; } + if(s=="IFCDERIVEDMEASUREVALUE" ) { return IfcDerivedMeasureValue; } + if(s=="IFCDESCRIPTIVEMEASURE" ) { return IfcDescriptiveMeasure; } + if(s=="IFCDOSEEQUIVALENTMEASURE" ) { return IfcDoseEquivalentMeasure; } + if(s=="IFCDYNAMICVISCOSITYMEASURE" ) { return IfcDynamicViscosityMeasure; } + if(s=="IFCELECTRICCAPACITANCEMEASURE" ) { return IfcElectricCapacitanceMeasure; } + if(s=="IFCELECTRICCHARGEMEASURE" ) { return IfcElectricChargeMeasure; } + if(s=="IFCELECTRICCONDUCTANCEMEASURE" ) { return IfcElectricConductanceMeasure; } + if(s=="IFCELECTRICCURRENTMEASURE" ) { return IfcElectricCurrentMeasure; } + if(s=="IFCELECTRICRESISTANCEMEASURE" ) { return IfcElectricResistanceMeasure; } + if(s=="IFCELECTRICVOLTAGEMEASURE" ) { return IfcElectricVoltageMeasure; } + if(s=="IFCENERGYMEASURE" ) { return IfcEnergyMeasure; } + if(s=="IFCFORCEMEASURE" ) { return IfcForceMeasure; } + if(s=="IFCFREQUENCYMEASURE" ) { return IfcFrequencyMeasure; } if(s=="IFCHEATFLUXDENSITYMEASURE" ) { return IfcHeatFluxDensityMeasure; } if(s=="IFCHEATINGVALUEMEASURE" ) { return IfcHeatingValueMeasure; } - if(s=="IFCFORCEMEASURE" ) { return IfcForceMeasure; } - if(s=="IFCPOSITIVERATIOMEASURE" ) { return IfcPositiveRatioMeasure; } - if(s=="IFCMOLECULARWEIGHTMEASURE" ) { return IfcMolecularWeightMeasure; } - if(s=="IFCLUMINOUSFLUXMEASURE" ) { return IfcLuminousFluxMeasure; } - if(s=="IFCNORMALISEDRATIOMEASURE" ) { return IfcNormalisedRatioMeasure; } - if(s=="IFCLABEL" ) { return IfcLabel; } - if(s=="IFCTIMESTAMP" ) { return IfcTimeStamp; } - if(s=="IFCNUMERICMEASURE" ) { return IfcNumericMeasure; } - if(s=="IFCROTATIONALMASSMEASURE" ) { return IfcRotationalMassMeasure; } - if(s=="IFCLINEARFORCEMEASURE" ) { return IfcLinearForceMeasure; } - if(s=="IFCKINEMATICVISCOSITYMEASURE" ) { return IfcKinematicViscosityMeasure; } - if(s=="IFCMASSDENSITYMEASURE" ) { return IfcMassDensityMeasure; } - if(s=="IFCINTEGERCOUNTRATEMEASURE" ) { return IfcIntegerCountRateMeasure; } - if(s=="IFCRADIOACTIVITYMEASURE" ) { return IfcRadioActivityMeasure; } - if(s=="IFCREAL" ) { return IfcReal; } - if(s=="IFCLINEARMOMENTMEASURE" ) { return IfcLinearMomentMeasure; } - if(s=="IFCELECTRICCURRENTMEASURE" ) { return IfcElectricCurrentMeasure; } - if(s=="IFCTHERMALTRANSMITTANCEMEASURE" ) { return IfcThermalTransmittanceMeasure; } - if(s=="IFCMODULUSOFELASTICITYMEASURE" ) { return IfcModulusOfElasticityMeasure; } - if(s=="IFCINDUCTANCEMEASURE" ) { return IfcInductanceMeasure; } - if(s=="IFCWARPINGMOMENTMEASURE" ) { return IfcWarpingMomentMeasure; } - if(s=="IFCDYNAMICVISCOSITYMEASURE" ) { return IfcDynamicViscosityMeasure; } - if(s=="IFCAREAMEASURE" ) { return IfcAreaMeasure; } - if(s=="IFCLOGICAL" ) { return IfcLogical; } - if(s=="IFCAMOUNTOFSUBSTANCEMEASURE" ) { return IfcAmountOfSubstanceMeasure; } - if(s=="IFCCONTEXTDEPENDENTMEASURE" ) { return IfcContextDependentMeasure; } - if(s=="IFCTHERMALCONDUCTIVITYMEASURE" ) { return IfcThermalConductivityMeasure; } - if(s=="IFCENERGYMEASURE" ) { return IfcEnergyMeasure; } - if(s=="IFCROTATIONALSTIFFNESSMEASURE" ) { return IfcRotationalStiffnessMeasure; } - if(s=="IFCDERIVEDMEASUREVALUE" ) { return IfcDerivedMeasureValue; } - if(s=="IFCPOWERMEASURE" ) { return IfcPowerMeasure; } - if(s=="IFCTHERMALEXPANSIONCOEFFICIENTMEASURE" ) { return IfcThermalExpansionCoefficientMeasure; } - if(s=="IFCTORQUEMEASURE" ) { return IfcTorqueMeasure; } - if(s=="IFCMASSPERLENGTHMEASURE" ) { return IfcMassPerLengthMeasure; } - if(s=="IFCCOUNTMEASURE" ) { return IfcCountMeasure; } - if(s=="IFCCURVESTYLEFONTSELECT" ) { return IfcCurveStyleFontSelect; } - if(s=="IFCVOLUMETRICFLOWRATEMEASURE" ) { return IfcVolumetricFlowRateMeasure; } - if(s=="IFCMODULUSOFSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfSubgradeReactionMeasure; } - if(s=="IFCMASSFLOWRATEMEASURE" ) { return IfcMassFlowRateMeasure; } - if(s=="IFCMONETARYMEASURE" ) { return IfcMonetaryMeasure; } - if(s=="IFCTEMPERATUREGRADIENTMEASURE" ) { return IfcTemperatureGradientMeasure; } - if(s=="IFCCOLOUR" ) { return IfcColour; } - if(s=="IFCVOLUMEMEASURE" ) { return IfcVolumeMeasure; } - if(s=="IFCSECTIONALAREAINTEGRALMEASURE" ) { return IfcSectionalAreaIntegralMeasure; } - if(s=="IFCVAPORPERMEABILITYMEASURE" ) { return IfcVaporPermeabilityMeasure; } - if(s=="IFCLINEARVELOCITYMEASURE" ) { return IfcLinearVelocityMeasure; } - if(s=="IFCLENGTHMEASURE" ) { return IfcLengthMeasure; } - if(s=="IFCMODULUSOFROTATIONALSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfRotationalSubgradeReactionMeasure; } - if(s=="IFCPLANARFORCEMEASURE" ) { return IfcPlanarForceMeasure; } - if(s=="IFCINTEGER" ) { return IfcInteger; } - if(s=="IFCSIMPLEVALUE" ) { return IfcSimpleValue; } - if(s=="IFCMEASUREVALUE" ) { return IfcMeasureValue; } - if(s=="IFCPLANEANGLEMEASURE" ) { return IfcPlaneAngleMeasure; } - if(s=="IFCWARPINGCONSTANTMEASURE" ) { return IfcWarpingConstantMeasure; } - if(s=="IFCELECTRICCAPACITANCEMEASURE" ) { return IfcElectricCapacitanceMeasure; } - if(s=="IFCSOUNDPRESSUREMEASURE" ) { return IfcSoundPressureMeasure; } - if(s=="IFCSPECULARROUGHNESS" ) { return IfcSpecularRoughness; } - if(s=="IFCILLUMINANCEMEASURE" ) { return IfcIlluminanceMeasure; } - if(s=="IFCTEXT" ) { return IfcText; } - if(s=="IFCTIMEMEASURE" ) { return IfcTimeMeasure; } - if(s=="IFCACCELERATIONMEASURE" ) { return IfcAccelerationMeasure; } - if(s=="IFCLUMINOUSINTENSITYMEASURE" ) { return IfcLuminousIntensityMeasure; } - if(s=="IFCPRESSUREMEASURE" ) { return IfcPressureMeasure; } - if(s=="IFCELECTRICVOLTAGEMEASURE" ) { return IfcElectricVoltageMeasure; } - if(s=="IFCTHERMODYNAMICTEMPERATUREMEASURE" ) { return IfcThermodynamicTemperatureMeasure; } - if(s=="IFCMAGNETICFLUXMEASURE" ) { return IfcMagneticFluxMeasure; } - if(s=="IFCSOLIDANGLEMEASURE" ) { return IfcSolidAngleMeasure; } - if(s=="IFCFREQUENCYMEASURE" ) { return IfcFrequencyMeasure; } - if(s=="IFCPHMEASURE" ) { return IfcPHMeasure; } - if(s=="IFCTHERMALADMITTANCEMEASURE" ) { return IfcThermalAdmittanceMeasure; } - if(s=="IFCSPECULAREXPONENT" ) { return IfcSpecularExponent; } - if(s=="IFCDATETIMESELECT" ) { return IfcDateTimeSelect; } - if(s=="IFCLINEARSTIFFNESSMEASURE" ) { return IfcLinearStiffnessMeasure; } - if(s=="IFCCOMPOUNDPLANEANGLEMEASURE" ) { return IfcCompoundPlaneAngleMeasure; } - if(s=="IFCCURVATUREMEASURE" ) { return IfcCurvatureMeasure; } - if(s=="IFCABSORBEDDOSEMEASURE" ) { return IfcAbsorbedDoseMeasure; } - if(s=="IFCPARAMETERVALUE" ) { return IfcParameterValue; } - if(s=="IFCDESCRIPTIVEMEASURE" ) { return IfcDescriptiveMeasure; } - if(s=="IFCMOMENTOFINERTIAMEASURE" ) { return IfcMomentOfInertiaMeasure; } - if(s=="IFCDOSEEQUIVALENTMEASURE" ) { return IfcDoseEquivalentMeasure; } - if(s=="IFCCOMPLEXNUMBER" ) { return IfcComplexNumber; } - if(s=="IFCRATIOMEASURE" ) { return IfcRatioMeasure; } - if(s=="IFCLUMINOUSINTENSITYDISTRIBUTIONMEASURE" ) { return IfcLuminousIntensityDistributionMeasure; } - if(s=="IFCISOTHERMALMOISTURECAPACITYMEASURE" ) { return IfcIsothermalMoistureCapacityMeasure; } - if(s=="IFCELECTRICRESISTANCEMEASURE" ) { return IfcElectricResistanceMeasure; } - if(s=="IFCTHERMALRESISTANCEMEASURE" ) { return IfcThermalResistanceMeasure; } - if(s=="IFCSHEARMODULUSMEASURE" ) { return IfcShearModulusMeasure; } if(s=="IFCIDENTIFIER" ) { return IfcIdentifier; } - if(s=="IFCBOOLEAN" ) { return IfcBoolean; } - if(s=="IFCSECTIONMODULUSMEASURE" ) { return IfcSectionModulusMeasure; } - if(s=="IFCMASSMEASURE" ) { return IfcMassMeasure; } - if(s=="IFCMOISTUREDIFFUSIVITYMEASURE" ) { return IfcMoistureDiffusivityMeasure; } - if(s=="IFCPOSITIVEPLANEANGLEMEASURE" ) { return IfcPositivePlaneAngleMeasure; } + if(s=="IFCILLUMINANCEMEASURE" ) { return IfcIlluminanceMeasure; } + if(s=="IFCINDUCTANCEMEASURE" ) { return IfcInductanceMeasure; } + if(s=="IFCINTEGER" ) { return IfcInteger; } + if(s=="IFCINTEGERCOUNTRATEMEASURE" ) { return IfcIntegerCountRateMeasure; } + if(s=="IFCIONCONCENTRATIONMEASURE" ) { return IfcIonConcentrationMeasure; } + if(s=="IFCISOTHERMALMOISTURECAPACITYMEASURE" ) { return IfcIsothermalMoistureCapacityMeasure; } + if(s=="IFCKINEMATICVISCOSITYMEASURE" ) { return IfcKinematicViscosityMeasure; } + if(s=="IFCLABEL" ) { return IfcLabel; } + if(s=="IFCLENGTHMEASURE" ) { return IfcLengthMeasure; } + if(s=="IFCLINEARFORCEMEASURE" ) { return IfcLinearForceMeasure; } + if(s=="IFCLINEARMOMENTMEASURE" ) { return IfcLinearMomentMeasure; } + if(s=="IFCLINEARSTIFFNESSMEASURE" ) { return IfcLinearStiffnessMeasure; } + if(s=="IFCLINEARVELOCITYMEASURE" ) { return IfcLinearVelocityMeasure; } + if(s=="IFCLOGICAL" ) { return IfcLogical; } + if(s=="IFCLUMINOUSFLUXMEASURE" ) { return IfcLuminousFluxMeasure; } + if(s=="IFCLUMINOUSINTENSITYDISTRIBUTIONMEASURE" ) { return IfcLuminousIntensityDistributionMeasure; } + if(s=="IFCLUMINOUSINTENSITYMEASURE" ) { return IfcLuminousIntensityMeasure; } if(s=="IFCMAGNETICFLUXDENSITYMEASURE" ) { return IfcMagneticFluxDensityMeasure; } + if(s=="IFCMAGNETICFLUXMEASURE" ) { return IfcMagneticFluxMeasure; } + if(s=="IFCMASSDENSITYMEASURE" ) { return IfcMassDensityMeasure; } + if(s=="IFCMASSFLOWRATEMEASURE" ) { return IfcMassFlowRateMeasure; } + if(s=="IFCMASSMEASURE" ) { return IfcMassMeasure; } + if(s=="IFCMASSPERLENGTHMEASURE" ) { return IfcMassPerLengthMeasure; } + if(s=="IFCMEASUREVALUE" ) { return IfcMeasureValue; } + if(s=="IFCMODULUSOFELASTICITYMEASURE" ) { return IfcModulusOfElasticityMeasure; } + if(s=="IFCMODULUSOFLINEARSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfLinearSubgradeReactionMeasure; } + if(s=="IFCMODULUSOFROTATIONALSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfRotationalSubgradeReactionMeasure; } + if(s=="IFCMODULUSOFSUBGRADEREACTIONMEASURE" ) { return IfcModulusOfSubgradeReactionMeasure; } + if(s=="IFCMOISTUREDIFFUSIVITYMEASURE" ) { return IfcMoistureDiffusivityMeasure; } + if(s=="IFCMOLECULARWEIGHTMEASURE" ) { return IfcMolecularWeightMeasure; } + if(s=="IFCMOMENTOFINERTIAMEASURE" ) { return IfcMomentOfInertiaMeasure; } + if(s=="IFCMONETARYMEASURE" ) { return IfcMonetaryMeasure; } + if(s=="IFCNORMALISEDRATIOMEASURE" ) { return IfcNormalisedRatioMeasure; } + if(s=="IFCNULLSTYLE" ) { return IfcNullStyle; } + if(s=="IFCNUMERICMEASURE" ) { return IfcNumericMeasure; } + if(s=="IFCPHMEASURE" ) { return IfcPHMeasure; } + if(s=="IFCPARAMETERVALUE" ) { return IfcParameterValue; } + if(s=="IFCPLANARFORCEMEASURE" ) { return IfcPlanarForceMeasure; } + if(s=="IFCPLANEANGLEMEASURE" ) { return IfcPlaneAngleMeasure; } + if(s=="IFCPOSITIVELENGTHMEASURE" ) { return IfcPositiveLengthMeasure; } + if(s=="IFCPOSITIVEPLANEANGLEMEASURE" ) { return IfcPositivePlaneAngleMeasure; } + if(s=="IFCPOSITIVERATIOMEASURE" ) { return IfcPositiveRatioMeasure; } + if(s=="IFCPOWERMEASURE" ) { return IfcPowerMeasure; } + if(s=="IFCPRESSUREMEASURE" ) { return IfcPressureMeasure; } + if(s=="IFCRADIOACTIVITYMEASURE" ) { return IfcRadioActivityMeasure; } + if(s=="IFCRATIOMEASURE" ) { return IfcRatioMeasure; } + if(s=="IFCREAL" ) { return IfcReal; } + if(s=="IFCROTATIONALFREQUENCYMEASURE" ) { return IfcRotationalFrequencyMeasure; } + if(s=="IFCROTATIONALMASSMEASURE" ) { return IfcRotationalMassMeasure; } + if(s=="IFCROTATIONALSTIFFNESSMEASURE" ) { return IfcRotationalStiffnessMeasure; } + if(s=="IFCSECTIONMODULUSMEASURE" ) { return IfcSectionModulusMeasure; } + if(s=="IFCSECTIONALAREAINTEGRALMEASURE" ) { return IfcSectionalAreaIntegralMeasure; } + if(s=="IFCSHEARMODULUSMEASURE" ) { return IfcShearModulusMeasure; } + if(s=="IFCSIMPLEVALUE" ) { return IfcSimpleValue; } + if(s=="IFCSOLIDANGLEMEASURE" ) { return IfcSolidAngleMeasure; } + if(s=="IFCSOUNDPOWERMEASURE" ) { return IfcSoundPowerMeasure; } + if(s=="IFCSOUNDPRESSUREMEASURE" ) { return IfcSoundPressureMeasure; } + if(s=="IFCSPECIFICHEATCAPACITYMEASURE" ) { return IfcSpecificHeatCapacityMeasure; } + if(s=="IFCSPECULAREXPONENT" ) { return IfcSpecularExponent; } + if(s=="IFCSPECULARROUGHNESS" ) { return IfcSpecularRoughness; } + if(s=="IFCTEMPERATUREGRADIENTMEASURE" ) { return IfcTemperatureGradientMeasure; } + if(s=="IFCTEXT" ) { return IfcText; } + if(s=="IFCTHERMALADMITTANCEMEASURE" ) { return IfcThermalAdmittanceMeasure; } + if(s=="IFCTHERMALCONDUCTIVITYMEASURE" ) { return IfcThermalConductivityMeasure; } + if(s=="IFCTHERMALEXPANSIONCOEFFICIENTMEASURE" ) { return IfcThermalExpansionCoefficientMeasure; } + if(s=="IFCTHERMALRESISTANCEMEASURE" ) { return IfcThermalResistanceMeasure; } + if(s=="IFCTHERMALTRANSMITTANCEMEASURE" ) { return IfcThermalTransmittanceMeasure; } + if(s=="IFCTHERMODYNAMICTEMPERATUREMEASURE" ) { return IfcThermodynamicTemperatureMeasure; } + if(s=="IFCTIMEMEASURE" ) { return IfcTimeMeasure; } + if(s=="IFCTIMESTAMP" ) { return IfcTimeStamp; } + if(s=="IFCTORQUEMEASURE" ) { return IfcTorqueMeasure; } + if(s=="IFCVAPORPERMEABILITYMEASURE" ) { return IfcVaporPermeabilityMeasure; } + if(s=="IFCVOLUMEMEASURE" ) { return IfcVolumeMeasure; } + if(s=="IFCVOLUMETRICFLOWRATEMEASURE" ) { return IfcVolumetricFlowRateMeasure; } + if(s=="IFCWARPINGCONSTANTMEASURE" ) { return IfcWarpingConstantMeasure; } + if(s=="IFCWARPINGMOMENTMEASURE" ) { return IfcWarpingMomentMeasure; } if(s=="IFC2DCOMPOSITECURVE" ) { return Ifc2DCompositeCurve; } if(s=="IFCACTIONREQUEST" ) { return IfcActionRequest; } if(s=="IFCACTOR" ) { return IfcActor; } @@ -1560,2645 +1558,2646 @@ Type::Enum Type::FromString(const std::string& s){ throw; } std::string IfcActionSourceTypeEnum::ToString(IfcActionSourceTypeEnum v) { - if (v < 0 || v >= 27) throw; + if ( v < 0 || v >= 27 ) throw; const char* names[] = { "DEAD_LOAD_G","COMPLETION_G1","LIVE_LOAD_Q","SNOW_S","WIND_W","PRESTRESSING_P","SETTLEMENT_U","TEMPERATURE_T","EARTHQUAKE_E","FIRE","IMPULSE","IMPACT","TRANSPORT","ERECTION","PROPPING","SYSTEM_IMPERFECTION","SHRINKAGE","CREEP","LACK_OF_FIT","BUOYANCY","ICE","CURRENT","WAVE","RAIN","BRAKES","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcActionSourceTypeEnum::IfcActionSourceTypeEnum IfcActionSourceTypeEnum::FromString(const std::string& s) { + if(s=="DEAD_LOAD_G" ) return IfcActionSourceTypeEnum::DEAD_LOAD_G; + if(s=="COMPLETION_G1" ) return IfcActionSourceTypeEnum::COMPLETION_G1; + if(s=="LIVE_LOAD_Q" ) return IfcActionSourceTypeEnum::LIVE_LOAD_Q; + if(s=="SNOW_S" ) return IfcActionSourceTypeEnum::SNOW_S; + if(s=="WIND_W" ) return IfcActionSourceTypeEnum::WIND_W; + if(s=="PRESTRESSING_P" ) return IfcActionSourceTypeEnum::PRESTRESSING_P; + if(s=="SETTLEMENT_U" ) return IfcActionSourceTypeEnum::SETTLEMENT_U; + if(s=="TEMPERATURE_T" ) return IfcActionSourceTypeEnum::TEMPERATURE_T; + if(s=="EARTHQUAKE_E" ) return IfcActionSourceTypeEnum::EARTHQUAKE_E; + if(s=="FIRE" ) return IfcActionSourceTypeEnum::FIRE; + if(s=="IMPULSE" ) return IfcActionSourceTypeEnum::IMPULSE; + if(s=="IMPACT" ) return IfcActionSourceTypeEnum::IMPACT; + if(s=="TRANSPORT" ) return IfcActionSourceTypeEnum::TRANSPORT; + if(s=="ERECTION" ) return IfcActionSourceTypeEnum::ERECTION; + if(s=="PROPPING" ) return IfcActionSourceTypeEnum::PROPPING; + if(s=="SYSTEM_IMPERFECTION") return IfcActionSourceTypeEnum::SYSTEM_IMPERFECTION; + if(s=="SHRINKAGE" ) return IfcActionSourceTypeEnum::SHRINKAGE; + if(s=="CREEP" ) return IfcActionSourceTypeEnum::CREEP; + if(s=="LACK_OF_FIT" ) return IfcActionSourceTypeEnum::LACK_OF_FIT; + if(s=="BUOYANCY" ) return IfcActionSourceTypeEnum::BUOYANCY; + if(s=="ICE" ) return IfcActionSourceTypeEnum::ICE; + if(s=="CURRENT" ) return IfcActionSourceTypeEnum::CURRENT; + if(s=="WAVE" ) return IfcActionSourceTypeEnum::WAVE; + if(s=="RAIN" ) return IfcActionSourceTypeEnum::RAIN; + if(s=="BRAKES" ) return IfcActionSourceTypeEnum::BRAKES; + if(s=="USERDEFINED" ) return IfcActionSourceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcActionSourceTypeEnum::NOTDEFINED; + throw; +} std::string IfcActionTypeEnum::ToString(IfcActionTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "PERMANENT_G","VARIABLE_Q","EXTRAORDINARY_A","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcActionTypeEnum::IfcActionTypeEnum IfcActionTypeEnum::FromString(const std::string& s) { + if(s=="PERMANENT_G" ) return IfcActionTypeEnum::PERMANENT_G; + if(s=="VARIABLE_Q" ) return IfcActionTypeEnum::VARIABLE_Q; + if(s=="EXTRAORDINARY_A") return IfcActionTypeEnum::EXTRAORDINARY_A; + if(s=="USERDEFINED" ) return IfcActionTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcActionTypeEnum::NOTDEFINED; + throw; +} std::string IfcActuatorTypeEnum::ToString(IfcActuatorTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "ELECTRICACTUATOR","HANDOPERATEDACTUATOR","HYDRAULICACTUATOR","PNEUMATICACTUATOR","THERMOSTATICACTUATOR","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorTypeEnum::FromString(const std::string& s) { + if(s=="ELECTRICACTUATOR" ) return IfcActuatorTypeEnum::ELECTRICACTUATOR; + if(s=="HANDOPERATEDACTUATOR") return IfcActuatorTypeEnum::HANDOPERATEDACTUATOR; + if(s=="HYDRAULICACTUATOR" ) return IfcActuatorTypeEnum::HYDRAULICACTUATOR; + if(s=="PNEUMATICACTUATOR" ) return IfcActuatorTypeEnum::PNEUMATICACTUATOR; + if(s=="THERMOSTATICACTUATOR") return IfcActuatorTypeEnum::THERMOSTATICACTUATOR; + if(s=="USERDEFINED" ) return IfcActuatorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcActuatorTypeEnum::NOTDEFINED; + throw; +} std::string IfcAddressTypeEnum::ToString(IfcAddressTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "OFFICE","SITE","HOME","DISTRIBUTIONPOINT","USERDEFINED" }; return names[v]; } +IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddressTypeEnum::FromString(const std::string& s) { + if(s=="OFFICE" ) return IfcAddressTypeEnum::OFFICE; + if(s=="SITE" ) return IfcAddressTypeEnum::SITE; + if(s=="HOME" ) return IfcAddressTypeEnum::HOME; + if(s=="DISTRIBUTIONPOINT") return IfcAddressTypeEnum::DISTRIBUTIONPOINT; + if(s=="USERDEFINED" ) return IfcAddressTypeEnum::USERDEFINED; + throw; +} std::string IfcAheadOrBehind::ToString(IfcAheadOrBehind v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "AHEAD","BEHIND" }; return names[v]; } +IfcAheadOrBehind::IfcAheadOrBehind IfcAheadOrBehind::FromString(const std::string& s) { + if(s=="AHEAD" ) return IfcAheadOrBehind::AHEAD; + if(s=="BEHIND") return IfcAheadOrBehind::BEHIND; + throw; +} std::string IfcAirTerminalBoxTypeEnum::ToString(IfcAirTerminalBoxTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "CONSTANTFLOW","VARIABLEFLOWPRESSUREDEPENDANT","VARIABLEFLOWPRESSUREINDEPENDANT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxTypeEnum::FromString(const std::string& s) { + if(s=="CONSTANTFLOW" ) return IfcAirTerminalBoxTypeEnum::CONSTANTFLOW; + if(s=="VARIABLEFLOWPRESSUREDEPENDANT" ) return IfcAirTerminalBoxTypeEnum::VARIABLEFLOWPRESSUREDEPENDANT; + if(s=="VARIABLEFLOWPRESSUREINDEPENDANT") return IfcAirTerminalBoxTypeEnum::VARIABLEFLOWPRESSUREINDEPENDANT; + if(s=="USERDEFINED" ) return IfcAirTerminalBoxTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcAirTerminalBoxTypeEnum::NOTDEFINED; + throw; +} std::string IfcAirTerminalTypeEnum::ToString(IfcAirTerminalTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "GRILLE","REGISTER","DIFFUSER","EYEBALL","IRIS","LINEARGRILLE","LINEARDIFFUSER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalTypeEnum::FromString(const std::string& s) { + if(s=="GRILLE" ) return IfcAirTerminalTypeEnum::GRILLE; + if(s=="REGISTER" ) return IfcAirTerminalTypeEnum::REGISTER; + if(s=="DIFFUSER" ) return IfcAirTerminalTypeEnum::DIFFUSER; + if(s=="EYEBALL" ) return IfcAirTerminalTypeEnum::EYEBALL; + if(s=="IRIS" ) return IfcAirTerminalTypeEnum::IRIS; + if(s=="LINEARGRILLE" ) return IfcAirTerminalTypeEnum::LINEARGRILLE; + if(s=="LINEARDIFFUSER") return IfcAirTerminalTypeEnum::LINEARDIFFUSER; + if(s=="USERDEFINED" ) return IfcAirTerminalTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcAirTerminalTypeEnum::NOTDEFINED; + throw; +} std::string IfcAirToAirHeatRecoveryTypeEnum::ToString(IfcAirToAirHeatRecoveryTypeEnum v) { - if (v < 0 || v >= 11) throw; + if ( v < 0 || v >= 11 ) throw; const char* names[] = { "FIXEDPLATECOUNTERFLOWEXCHANGER","FIXEDPLATECROSSFLOWEXCHANGER","FIXEDPLATEPARALLELFLOWEXCHANGER","ROTARYWHEEL","RUNAROUNDCOILLOOP","HEATPIPE","TWINTOWERENTHALPYRECOVERYLOOPS","THERMOSIPHONSEALEDTUBEHEATEXCHANGERS","THERMOSIPHONCOILTYPEHEATEXCHANGERS","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryTypeEnum::FromString(const std::string& s) { + if(s=="FIXEDPLATECOUNTERFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATECOUNTERFLOWEXCHANGER; + if(s=="FIXEDPLATECROSSFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATECROSSFLOWEXCHANGER; + if(s=="FIXEDPLATEPARALLELFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATEPARALLELFLOWEXCHANGER; + if(s=="ROTARYWHEEL" ) return IfcAirToAirHeatRecoveryTypeEnum::ROTARYWHEEL; + if(s=="RUNAROUNDCOILLOOP" ) return IfcAirToAirHeatRecoveryTypeEnum::RUNAROUNDCOILLOOP; + if(s=="HEATPIPE" ) return IfcAirToAirHeatRecoveryTypeEnum::HEATPIPE; + if(s=="TWINTOWERENTHALPYRECOVERYLOOPS" ) return IfcAirToAirHeatRecoveryTypeEnum::TWINTOWERENTHALPYRECOVERYLOOPS; + if(s=="THERMOSIPHONSEALEDTUBEHEATEXCHANGERS") return IfcAirToAirHeatRecoveryTypeEnum::THERMOSIPHONSEALEDTUBEHEATEXCHANGERS; + if(s=="THERMOSIPHONCOILTYPEHEATEXCHANGERS" ) return IfcAirToAirHeatRecoveryTypeEnum::THERMOSIPHONCOILTYPEHEATEXCHANGERS; + if(s=="USERDEFINED" ) return IfcAirToAirHeatRecoveryTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcAirToAirHeatRecoveryTypeEnum::NOTDEFINED; + throw; +} std::string IfcAlarmTypeEnum::ToString(IfcAlarmTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "BELL","BREAKGLASSBUTTON","LIGHT","MANUALPULLBOX","SIREN","WHISTLE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmTypeEnum::FromString(const std::string& s) { + if(s=="BELL" ) return IfcAlarmTypeEnum::BELL; + if(s=="BREAKGLASSBUTTON") return IfcAlarmTypeEnum::BREAKGLASSBUTTON; + if(s=="LIGHT" ) return IfcAlarmTypeEnum::LIGHT; + if(s=="MANUALPULLBOX" ) return IfcAlarmTypeEnum::MANUALPULLBOX; + if(s=="SIREN" ) return IfcAlarmTypeEnum::SIREN; + if(s=="WHISTLE" ) return IfcAlarmTypeEnum::WHISTLE; + if(s=="USERDEFINED" ) return IfcAlarmTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcAlarmTypeEnum::NOTDEFINED; + throw; +} std::string IfcAnalysisModelTypeEnum::ToString(IfcAnalysisModelTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "IN_PLANE_LOADING_2D","OUT_PLANE_LOADING_2D","LOADING_3D","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcAnalysisModelTypeEnum::FromString(const std::string& s) { + if(s=="IN_PLANE_LOADING_2D" ) return IfcAnalysisModelTypeEnum::IN_PLANE_LOADING_2D; + if(s=="OUT_PLANE_LOADING_2D") return IfcAnalysisModelTypeEnum::OUT_PLANE_LOADING_2D; + if(s=="LOADING_3D" ) return IfcAnalysisModelTypeEnum::LOADING_3D; + if(s=="USERDEFINED" ) return IfcAnalysisModelTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcAnalysisModelTypeEnum::NOTDEFINED; + throw; +} std::string IfcAnalysisTheoryTypeEnum::ToString(IfcAnalysisTheoryTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "FIRST_ORDER_THEORY","SECOND_ORDER_THEORY","THIRD_ORDER_THEORY","FULL_NONLINEAR_THEORY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcAnalysisTheoryTypeEnum::FromString(const std::string& s) { + if(s=="FIRST_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::FIRST_ORDER_THEORY; + if(s=="SECOND_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::SECOND_ORDER_THEORY; + if(s=="THIRD_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::THIRD_ORDER_THEORY; + if(s=="FULL_NONLINEAR_THEORY") return IfcAnalysisTheoryTypeEnum::FULL_NONLINEAR_THEORY; + if(s=="USERDEFINED" ) return IfcAnalysisTheoryTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcAnalysisTheoryTypeEnum::NOTDEFINED; + throw; +} std::string IfcArithmeticOperatorEnum::ToString(IfcArithmeticOperatorEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "ADD","DIVIDE","MULTIPLY","SUBTRACT" }; return names[v]; } +IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcArithmeticOperatorEnum::FromString(const std::string& s) { + if(s=="ADD" ) return IfcArithmeticOperatorEnum::ADD; + if(s=="DIVIDE" ) return IfcArithmeticOperatorEnum::DIVIDE; + if(s=="MULTIPLY") return IfcArithmeticOperatorEnum::MULTIPLY; + if(s=="SUBTRACT") return IfcArithmeticOperatorEnum::SUBTRACT; + throw; +} std::string IfcAssemblyPlaceEnum::ToString(IfcAssemblyPlaceEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "SITE","FACTORY","NOTDEFINED" }; return names[v]; } +IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcAssemblyPlaceEnum::FromString(const std::string& s) { + if(s=="SITE" ) return IfcAssemblyPlaceEnum::SITE; + if(s=="FACTORY" ) return IfcAssemblyPlaceEnum::FACTORY; + if(s=="NOTDEFINED") return IfcAssemblyPlaceEnum::NOTDEFINED; + throw; +} std::string IfcBSplineCurveForm::ToString(IfcBSplineCurveForm v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "POLYLINE_FORM","CIRCULAR_ARC","ELLIPTIC_ARC","PARABOLIC_ARC","HYPERBOLIC_ARC","UNSPECIFIED" }; return names[v]; } +IfcBSplineCurveForm::IfcBSplineCurveForm IfcBSplineCurveForm::FromString(const std::string& s) { + if(s=="POLYLINE_FORM" ) return IfcBSplineCurveForm::POLYLINE_FORM; + if(s=="CIRCULAR_ARC" ) return IfcBSplineCurveForm::CIRCULAR_ARC; + if(s=="ELLIPTIC_ARC" ) return IfcBSplineCurveForm::ELLIPTIC_ARC; + if(s=="PARABOLIC_ARC" ) return IfcBSplineCurveForm::PARABOLIC_ARC; + if(s=="HYPERBOLIC_ARC") return IfcBSplineCurveForm::HYPERBOLIC_ARC; + if(s=="UNSPECIFIED" ) return IfcBSplineCurveForm::UNSPECIFIED; + throw; +} std::string IfcBeamTypeEnum::ToString(IfcBeamTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "BEAM","JOIST","LINTEL","T_BEAM","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamTypeEnum::FromString(const std::string& s) { + if(s=="BEAM" ) return IfcBeamTypeEnum::BEAM; + if(s=="JOIST" ) return IfcBeamTypeEnum::JOIST; + if(s=="LINTEL" ) return IfcBeamTypeEnum::LINTEL; + if(s=="T_BEAM" ) return IfcBeamTypeEnum::T_BEAM; + if(s=="USERDEFINED") return IfcBeamTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcBeamTypeEnum::NOTDEFINED; + throw; +} std::string IfcBenchmarkEnum::ToString(IfcBenchmarkEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "GREATERTHAN","GREATERTHANOREQUALTO","LESSTHAN","LESSTHANOREQUALTO","EQUALTO","NOTEQUALTO" }; return names[v]; } +IfcBenchmarkEnum::IfcBenchmarkEnum IfcBenchmarkEnum::FromString(const std::string& s) { + if(s=="GREATERTHAN" ) return IfcBenchmarkEnum::GREATERTHAN; + if(s=="GREATERTHANOREQUALTO") return IfcBenchmarkEnum::GREATERTHANOREQUALTO; + if(s=="LESSTHAN" ) return IfcBenchmarkEnum::LESSTHAN; + if(s=="LESSTHANOREQUALTO" ) return IfcBenchmarkEnum::LESSTHANOREQUALTO; + if(s=="EQUALTO" ) return IfcBenchmarkEnum::EQUALTO; + if(s=="NOTEQUALTO" ) return IfcBenchmarkEnum::NOTEQUALTO; + throw; +} std::string IfcBoilerTypeEnum::ToString(IfcBoilerTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "WATER","STEAM","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerTypeEnum::FromString(const std::string& s) { + if(s=="WATER" ) return IfcBoilerTypeEnum::WATER; + if(s=="STEAM" ) return IfcBoilerTypeEnum::STEAM; + if(s=="USERDEFINED") return IfcBoilerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcBoilerTypeEnum::NOTDEFINED; + throw; +} std::string IfcBooleanOperator::ToString(IfcBooleanOperator v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "UNION","INTERSECTION","DIFFERENCE" }; return names[v]; } +IfcBooleanOperator::IfcBooleanOperator IfcBooleanOperator::FromString(const std::string& s) { + if(s=="UNION" ) return IfcBooleanOperator::UNION; + if(s=="INTERSECTION") return IfcBooleanOperator::INTERSECTION; + if(s=="DIFFERENCE" ) return IfcBooleanOperator::DIFFERENCE; + throw; +} std::string IfcBuildingElementProxyTypeEnum::ToString(IfcBuildingElementProxyTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyTypeEnum::FromString(const std::string& s) { + if(s=="USERDEFINED") return IfcBuildingElementProxyTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcBuildingElementProxyTypeEnum::NOTDEFINED; + throw; +} std::string IfcCableCarrierFittingTypeEnum::ToString(IfcCableCarrierFittingTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "BEND","CROSS","REDUCER","TEE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingTypeEnum::FromString(const std::string& s) { + if(s=="BEND" ) return IfcCableCarrierFittingTypeEnum::BEND; + if(s=="CROSS" ) return IfcCableCarrierFittingTypeEnum::CROSS; + if(s=="REDUCER" ) return IfcCableCarrierFittingTypeEnum::REDUCER; + if(s=="TEE" ) return IfcCableCarrierFittingTypeEnum::TEE; + if(s=="USERDEFINED") return IfcCableCarrierFittingTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCableCarrierFittingTypeEnum::NOTDEFINED; + throw; +} std::string IfcCableCarrierSegmentTypeEnum::ToString(IfcCableCarrierSegmentTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "CABLELADDERSEGMENT","CABLETRAYSEGMENT","CABLETRUNKINGSEGMENT","CONDUITSEGMENT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentTypeEnum::FromString(const std::string& s) { + if(s=="CABLELADDERSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CABLELADDERSEGMENT; + if(s=="CABLETRAYSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CABLETRAYSEGMENT; + if(s=="CABLETRUNKINGSEGMENT") return IfcCableCarrierSegmentTypeEnum::CABLETRUNKINGSEGMENT; + if(s=="CONDUITSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CONDUITSEGMENT; + if(s=="USERDEFINED" ) return IfcCableCarrierSegmentTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCableCarrierSegmentTypeEnum::NOTDEFINED; + throw; +} std::string IfcCableSegmentTypeEnum::ToString(IfcCableSegmentTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "CABLESEGMENT","CONDUCTORSEGMENT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentTypeEnum::FromString(const std::string& s) { + if(s=="CABLESEGMENT" ) return IfcCableSegmentTypeEnum::CABLESEGMENT; + if(s=="CONDUCTORSEGMENT") return IfcCableSegmentTypeEnum::CONDUCTORSEGMENT; + if(s=="USERDEFINED" ) return IfcCableSegmentTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCableSegmentTypeEnum::NOTDEFINED; + throw; +} std::string IfcChangeActionEnum::ToString(IfcChangeActionEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "NOCHANGE","MODIFIED","ADDED","DELETED","MODIFIEDADDED","MODIFIEDDELETED" }; return names[v]; } +IfcChangeActionEnum::IfcChangeActionEnum IfcChangeActionEnum::FromString(const std::string& s) { + if(s=="NOCHANGE" ) return IfcChangeActionEnum::NOCHANGE; + if(s=="MODIFIED" ) return IfcChangeActionEnum::MODIFIED; + if(s=="ADDED" ) return IfcChangeActionEnum::ADDED; + if(s=="DELETED" ) return IfcChangeActionEnum::DELETED; + if(s=="MODIFIEDADDED" ) return IfcChangeActionEnum::MODIFIEDADDED; + if(s=="MODIFIEDDELETED") return IfcChangeActionEnum::MODIFIEDDELETED; + throw; +} std::string IfcChillerTypeEnum::ToString(IfcChillerTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "AIRCOOLED","WATERCOOLED","HEATRECOVERY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerTypeEnum::FromString(const std::string& s) { + if(s=="AIRCOOLED" ) return IfcChillerTypeEnum::AIRCOOLED; + if(s=="WATERCOOLED" ) return IfcChillerTypeEnum::WATERCOOLED; + if(s=="HEATRECOVERY") return IfcChillerTypeEnum::HEATRECOVERY; + if(s=="USERDEFINED" ) return IfcChillerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcChillerTypeEnum::NOTDEFINED; + throw; +} std::string IfcCoilTypeEnum::ToString(IfcCoilTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "DXCOOLINGCOIL","WATERCOOLINGCOIL","STEAMHEATINGCOIL","WATERHEATINGCOIL","ELECTRICHEATINGCOIL","GASHEATINGCOIL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilTypeEnum::FromString(const std::string& s) { + if(s=="DXCOOLINGCOIL" ) return IfcCoilTypeEnum::DXCOOLINGCOIL; + if(s=="WATERCOOLINGCOIL" ) return IfcCoilTypeEnum::WATERCOOLINGCOIL; + if(s=="STEAMHEATINGCOIL" ) return IfcCoilTypeEnum::STEAMHEATINGCOIL; + if(s=="WATERHEATINGCOIL" ) return IfcCoilTypeEnum::WATERHEATINGCOIL; + if(s=="ELECTRICHEATINGCOIL") return IfcCoilTypeEnum::ELECTRICHEATINGCOIL; + if(s=="GASHEATINGCOIL" ) return IfcCoilTypeEnum::GASHEATINGCOIL; + if(s=="USERDEFINED" ) return IfcCoilTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCoilTypeEnum::NOTDEFINED; + throw; +} std::string IfcColumnTypeEnum::ToString(IfcColumnTypeEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "COLUMN","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnTypeEnum::FromString(const std::string& s) { + if(s=="COLUMN" ) return IfcColumnTypeEnum::COLUMN; + if(s=="USERDEFINED") return IfcColumnTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcColumnTypeEnum::NOTDEFINED; + throw; +} std::string IfcCompressorTypeEnum::ToString(IfcCompressorTypeEnum v) { - if (v < 0 || v >= 17) throw; + if ( v < 0 || v >= 17 ) throw; const char* names[] = { "DYNAMIC","RECIPROCATING","ROTARY","SCROLL","TROCHOIDAL","SINGLESTAGE","BOOSTER","OPENTYPE","HERMETIC","SEMIHERMETIC","WELDEDSHELLHERMETIC","ROLLINGPISTON","ROTARYVANE","SINGLESCREW","TWINSCREW","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorTypeEnum::FromString(const std::string& s) { + if(s=="DYNAMIC" ) return IfcCompressorTypeEnum::DYNAMIC; + if(s=="RECIPROCATING" ) return IfcCompressorTypeEnum::RECIPROCATING; + if(s=="ROTARY" ) return IfcCompressorTypeEnum::ROTARY; + if(s=="SCROLL" ) return IfcCompressorTypeEnum::SCROLL; + if(s=="TROCHOIDAL" ) return IfcCompressorTypeEnum::TROCHOIDAL; + if(s=="SINGLESTAGE" ) return IfcCompressorTypeEnum::SINGLESTAGE; + if(s=="BOOSTER" ) return IfcCompressorTypeEnum::BOOSTER; + if(s=="OPENTYPE" ) return IfcCompressorTypeEnum::OPENTYPE; + if(s=="HERMETIC" ) return IfcCompressorTypeEnum::HERMETIC; + if(s=="SEMIHERMETIC" ) return IfcCompressorTypeEnum::SEMIHERMETIC; + if(s=="WELDEDSHELLHERMETIC") return IfcCompressorTypeEnum::WELDEDSHELLHERMETIC; + if(s=="ROLLINGPISTON" ) return IfcCompressorTypeEnum::ROLLINGPISTON; + if(s=="ROTARYVANE" ) return IfcCompressorTypeEnum::ROTARYVANE; + if(s=="SINGLESCREW" ) return IfcCompressorTypeEnum::SINGLESCREW; + if(s=="TWINSCREW" ) return IfcCompressorTypeEnum::TWINSCREW; + if(s=="USERDEFINED" ) return IfcCompressorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCompressorTypeEnum::NOTDEFINED; + throw; +} std::string IfcCondenserTypeEnum::ToString(IfcCondenserTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "WATERCOOLEDSHELLTUBE","WATERCOOLEDSHELLCOIL","WATERCOOLEDTUBEINTUBE","WATERCOOLEDBRAZEDPLATE","AIRCOOLED","EVAPORATIVECOOLED","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserTypeEnum::FromString(const std::string& s) { + if(s=="WATERCOOLEDSHELLTUBE" ) return IfcCondenserTypeEnum::WATERCOOLEDSHELLTUBE; + if(s=="WATERCOOLEDSHELLCOIL" ) return IfcCondenserTypeEnum::WATERCOOLEDSHELLCOIL; + if(s=="WATERCOOLEDTUBEINTUBE" ) return IfcCondenserTypeEnum::WATERCOOLEDTUBEINTUBE; + if(s=="WATERCOOLEDBRAZEDPLATE") return IfcCondenserTypeEnum::WATERCOOLEDBRAZEDPLATE; + if(s=="AIRCOOLED" ) return IfcCondenserTypeEnum::AIRCOOLED; + if(s=="EVAPORATIVECOOLED" ) return IfcCondenserTypeEnum::EVAPORATIVECOOLED; + if(s=="USERDEFINED" ) return IfcCondenserTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCondenserTypeEnum::NOTDEFINED; + throw; +} std::string IfcConnectionTypeEnum::ToString(IfcConnectionTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "ATPATH","ATSTART","ATEND","NOTDEFINED" }; return names[v]; } +IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcConnectionTypeEnum::FromString(const std::string& s) { + if(s=="ATPATH" ) return IfcConnectionTypeEnum::ATPATH; + if(s=="ATSTART" ) return IfcConnectionTypeEnum::ATSTART; + if(s=="ATEND" ) return IfcConnectionTypeEnum::ATEND; + if(s=="NOTDEFINED") return IfcConnectionTypeEnum::NOTDEFINED; + throw; +} std::string IfcConstraintEnum::ToString(IfcConstraintEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "HARD","SOFT","ADVISORY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcConstraintEnum::IfcConstraintEnum IfcConstraintEnum::FromString(const std::string& s) { + if(s=="HARD" ) return IfcConstraintEnum::HARD; + if(s=="SOFT" ) return IfcConstraintEnum::SOFT; + if(s=="ADVISORY" ) return IfcConstraintEnum::ADVISORY; + if(s=="USERDEFINED") return IfcConstraintEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcConstraintEnum::NOTDEFINED; + throw; +} std::string IfcControllerTypeEnum::ToString(IfcControllerTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "FLOATING","PROPORTIONAL","PROPORTIONALINTEGRAL","PROPORTIONALINTEGRALDERIVATIVE","TIMEDTWOPOSITION","TWOPOSITION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerTypeEnum::FromString(const std::string& s) { + if(s=="FLOATING" ) return IfcControllerTypeEnum::FLOATING; + if(s=="PROPORTIONAL" ) return IfcControllerTypeEnum::PROPORTIONAL; + if(s=="PROPORTIONALINTEGRAL" ) return IfcControllerTypeEnum::PROPORTIONALINTEGRAL; + if(s=="PROPORTIONALINTEGRALDERIVATIVE") return IfcControllerTypeEnum::PROPORTIONALINTEGRALDERIVATIVE; + if(s=="TIMEDTWOPOSITION" ) return IfcControllerTypeEnum::TIMEDTWOPOSITION; + if(s=="TWOPOSITION" ) return IfcControllerTypeEnum::TWOPOSITION; + if(s=="USERDEFINED" ) return IfcControllerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcControllerTypeEnum::NOTDEFINED; + throw; +} std::string IfcCooledBeamTypeEnum::ToString(IfcCooledBeamTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "ACTIVE","PASSIVE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamTypeEnum::FromString(const std::string& s) { + if(s=="ACTIVE" ) return IfcCooledBeamTypeEnum::ACTIVE; + if(s=="PASSIVE" ) return IfcCooledBeamTypeEnum::PASSIVE; + if(s=="USERDEFINED") return IfcCooledBeamTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCooledBeamTypeEnum::NOTDEFINED; + throw; +} std::string IfcCoolingTowerTypeEnum::ToString(IfcCoolingTowerTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "NATURALDRAFT","MECHANICALINDUCEDDRAFT","MECHANICALFORCEDDRAFT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerTypeEnum::FromString(const std::string& s) { + if(s=="NATURALDRAFT" ) return IfcCoolingTowerTypeEnum::NATURALDRAFT; + if(s=="MECHANICALINDUCEDDRAFT") return IfcCoolingTowerTypeEnum::MECHANICALINDUCEDDRAFT; + if(s=="MECHANICALFORCEDDRAFT" ) return IfcCoolingTowerTypeEnum::MECHANICALFORCEDDRAFT; + if(s=="USERDEFINED" ) return IfcCoolingTowerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCoolingTowerTypeEnum::NOTDEFINED; + throw; +} std::string IfcCostScheduleTypeEnum::ToString(IfcCostScheduleTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "BUDGET","COSTPLAN","ESTIMATE","TENDER","PRICEDBILLOFQUANTITIES","UNPRICEDBILLOFQUANTITIES","SCHEDULEOFRATES","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostScheduleTypeEnum::FromString(const std::string& s) { + if(s=="BUDGET" ) return IfcCostScheduleTypeEnum::BUDGET; + if(s=="COSTPLAN" ) return IfcCostScheduleTypeEnum::COSTPLAN; + if(s=="ESTIMATE" ) return IfcCostScheduleTypeEnum::ESTIMATE; + if(s=="TENDER" ) return IfcCostScheduleTypeEnum::TENDER; + if(s=="PRICEDBILLOFQUANTITIES" ) return IfcCostScheduleTypeEnum::PRICEDBILLOFQUANTITIES; + if(s=="UNPRICEDBILLOFQUANTITIES") return IfcCostScheduleTypeEnum::UNPRICEDBILLOFQUANTITIES; + if(s=="SCHEDULEOFRATES" ) return IfcCostScheduleTypeEnum::SCHEDULEOFRATES; + if(s=="USERDEFINED" ) return IfcCostScheduleTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCostScheduleTypeEnum::NOTDEFINED; + throw; +} std::string IfcCoveringTypeEnum::ToString(IfcCoveringTypeEnum v) { - if (v < 0 || v >= 10) throw; + if ( v < 0 || v >= 10 ) throw; const char* names[] = { "CEILING","FLOORING","CLADDING","ROOFING","INSULATION","MEMBRANE","SLEEVING","WRAPPING","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringTypeEnum::FromString(const std::string& s) { + if(s=="CEILING" ) return IfcCoveringTypeEnum::CEILING; + if(s=="FLOORING" ) return IfcCoveringTypeEnum::FLOORING; + if(s=="CLADDING" ) return IfcCoveringTypeEnum::CLADDING; + if(s=="ROOFING" ) return IfcCoveringTypeEnum::ROOFING; + if(s=="INSULATION" ) return IfcCoveringTypeEnum::INSULATION; + if(s=="MEMBRANE" ) return IfcCoveringTypeEnum::MEMBRANE; + if(s=="SLEEVING" ) return IfcCoveringTypeEnum::SLEEVING; + if(s=="WRAPPING" ) return IfcCoveringTypeEnum::WRAPPING; + if(s=="USERDEFINED") return IfcCoveringTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCoveringTypeEnum::NOTDEFINED; + throw; +} std::string IfcCurrencyEnum::ToString(IfcCurrencyEnum v) { - if (v < 0 || v >= 83) throw; + if ( v < 0 || v >= 83 ) throw; const char* names[] = { "AED","AES","ATS","AUD","BBD","BEG","BGL","BHD","BMD","BND","BRL","BSD","BWP","BZD","CAD","CBD","CHF","CLP","CNY","CYS","CZK","DDP","DEM","DKK","EGL","EST","EUR","FAK","FIM","FJD","FKP","FRF","GBP","GIP","GMD","GRX","HKD","HUF","ICK","IDR","ILS","INR","IRP","ITL","JMD","JOD","JPY","KES","KRW","KWD","KYD","LKR","LUF","MTL","MUR","MXN","MYR","NLG","NZD","OMR","PGK","PHP","PKR","PLN","PTN","QAR","RUR","SAR","SCR","SEK","SGD","SKP","THB","TRL","TTD","TWD","USD","VEB","VND","XEU","ZAR","ZWD","NOK" }; return names[v]; } +IfcCurrencyEnum::IfcCurrencyEnum IfcCurrencyEnum::FromString(const std::string& s) { + if(s=="AED") return IfcCurrencyEnum::AED; + if(s=="AES") return IfcCurrencyEnum::AES; + if(s=="ATS") return IfcCurrencyEnum::ATS; + if(s=="AUD") return IfcCurrencyEnum::AUD; + if(s=="BBD") return IfcCurrencyEnum::BBD; + if(s=="BEG") return IfcCurrencyEnum::BEG; + if(s=="BGL") return IfcCurrencyEnum::BGL; + if(s=="BHD") return IfcCurrencyEnum::BHD; + if(s=="BMD") return IfcCurrencyEnum::BMD; + if(s=="BND") return IfcCurrencyEnum::BND; + if(s=="BRL") return IfcCurrencyEnum::BRL; + if(s=="BSD") return IfcCurrencyEnum::BSD; + if(s=="BWP") return IfcCurrencyEnum::BWP; + if(s=="BZD") return IfcCurrencyEnum::BZD; + if(s=="CAD") return IfcCurrencyEnum::CAD; + if(s=="CBD") return IfcCurrencyEnum::CBD; + if(s=="CHF") return IfcCurrencyEnum::CHF; + if(s=="CLP") return IfcCurrencyEnum::CLP; + if(s=="CNY") return IfcCurrencyEnum::CNY; + if(s=="CYS") return IfcCurrencyEnum::CYS; + if(s=="CZK") return IfcCurrencyEnum::CZK; + if(s=="DDP") return IfcCurrencyEnum::DDP; + if(s=="DEM") return IfcCurrencyEnum::DEM; + if(s=="DKK") return IfcCurrencyEnum::DKK; + if(s=="EGL") return IfcCurrencyEnum::EGL; + if(s=="EST") return IfcCurrencyEnum::EST; + if(s=="EUR") return IfcCurrencyEnum::EUR; + if(s=="FAK") return IfcCurrencyEnum::FAK; + if(s=="FIM") return IfcCurrencyEnum::FIM; + if(s=="FJD") return IfcCurrencyEnum::FJD; + if(s=="FKP") return IfcCurrencyEnum::FKP; + if(s=="FRF") return IfcCurrencyEnum::FRF; + if(s=="GBP") return IfcCurrencyEnum::GBP; + if(s=="GIP") return IfcCurrencyEnum::GIP; + if(s=="GMD") return IfcCurrencyEnum::GMD; + if(s=="GRX") return IfcCurrencyEnum::GRX; + if(s=="HKD") return IfcCurrencyEnum::HKD; + if(s=="HUF") return IfcCurrencyEnum::HUF; + if(s=="ICK") return IfcCurrencyEnum::ICK; + if(s=="IDR") return IfcCurrencyEnum::IDR; + if(s=="ILS") return IfcCurrencyEnum::ILS; + if(s=="INR") return IfcCurrencyEnum::INR; + if(s=="IRP") return IfcCurrencyEnum::IRP; + if(s=="ITL") return IfcCurrencyEnum::ITL; + if(s=="JMD") return IfcCurrencyEnum::JMD; + if(s=="JOD") return IfcCurrencyEnum::JOD; + if(s=="JPY") return IfcCurrencyEnum::JPY; + if(s=="KES") return IfcCurrencyEnum::KES; + if(s=="KRW") return IfcCurrencyEnum::KRW; + if(s=="KWD") return IfcCurrencyEnum::KWD; + if(s=="KYD") return IfcCurrencyEnum::KYD; + if(s=="LKR") return IfcCurrencyEnum::LKR; + if(s=="LUF") return IfcCurrencyEnum::LUF; + if(s=="MTL") return IfcCurrencyEnum::MTL; + if(s=="MUR") return IfcCurrencyEnum::MUR; + if(s=="MXN") return IfcCurrencyEnum::MXN; + if(s=="MYR") return IfcCurrencyEnum::MYR; + if(s=="NLG") return IfcCurrencyEnum::NLG; + if(s=="NZD") return IfcCurrencyEnum::NZD; + if(s=="OMR") return IfcCurrencyEnum::OMR; + if(s=="PGK") return IfcCurrencyEnum::PGK; + if(s=="PHP") return IfcCurrencyEnum::PHP; + if(s=="PKR") return IfcCurrencyEnum::PKR; + if(s=="PLN") return IfcCurrencyEnum::PLN; + if(s=="PTN") return IfcCurrencyEnum::PTN; + if(s=="QAR") return IfcCurrencyEnum::QAR; + if(s=="RUR") return IfcCurrencyEnum::RUR; + if(s=="SAR") return IfcCurrencyEnum::SAR; + if(s=="SCR") return IfcCurrencyEnum::SCR; + if(s=="SEK") return IfcCurrencyEnum::SEK; + if(s=="SGD") return IfcCurrencyEnum::SGD; + if(s=="SKP") return IfcCurrencyEnum::SKP; + if(s=="THB") return IfcCurrencyEnum::THB; + if(s=="TRL") return IfcCurrencyEnum::TRL; + if(s=="TTD") return IfcCurrencyEnum::TTD; + if(s=="TWD") return IfcCurrencyEnum::TWD; + if(s=="USD") return IfcCurrencyEnum::USD; + if(s=="VEB") return IfcCurrencyEnum::VEB; + if(s=="VND") return IfcCurrencyEnum::VND; + if(s=="XEU") return IfcCurrencyEnum::XEU; + if(s=="ZAR") return IfcCurrencyEnum::ZAR; + if(s=="ZWD") return IfcCurrencyEnum::ZWD; + if(s=="NOK") return IfcCurrencyEnum::NOK; + throw; +} std::string IfcCurtainWallTypeEnum::ToString(IfcCurtainWallTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallTypeEnum::FromString(const std::string& s) { + if(s=="USERDEFINED") return IfcCurtainWallTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcCurtainWallTypeEnum::NOTDEFINED; + throw; +} std::string IfcDamperTypeEnum::ToString(IfcDamperTypeEnum v) { - if (v < 0 || v >= 13) throw; + if ( v < 0 || v >= 13 ) throw; const char* names[] = { "CONTROLDAMPER","FIREDAMPER","SMOKEDAMPER","FIRESMOKEDAMPER","BACKDRAFTDAMPER","RELIEFDAMPER","BLASTDAMPER","GRAVITYDAMPER","GRAVITYRELIEFDAMPER","BALANCINGDAMPER","FUMEHOODEXHAUST","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperTypeEnum::FromString(const std::string& s) { + if(s=="CONTROLDAMPER" ) return IfcDamperTypeEnum::CONTROLDAMPER; + if(s=="FIREDAMPER" ) return IfcDamperTypeEnum::FIREDAMPER; + if(s=="SMOKEDAMPER" ) return IfcDamperTypeEnum::SMOKEDAMPER; + if(s=="FIRESMOKEDAMPER" ) return IfcDamperTypeEnum::FIRESMOKEDAMPER; + if(s=="BACKDRAFTDAMPER" ) return IfcDamperTypeEnum::BACKDRAFTDAMPER; + if(s=="RELIEFDAMPER" ) return IfcDamperTypeEnum::RELIEFDAMPER; + if(s=="BLASTDAMPER" ) return IfcDamperTypeEnum::BLASTDAMPER; + if(s=="GRAVITYDAMPER" ) return IfcDamperTypeEnum::GRAVITYDAMPER; + if(s=="GRAVITYRELIEFDAMPER") return IfcDamperTypeEnum::GRAVITYRELIEFDAMPER; + if(s=="BALANCINGDAMPER" ) return IfcDamperTypeEnum::BALANCINGDAMPER; + if(s=="FUMEHOODEXHAUST" ) return IfcDamperTypeEnum::FUMEHOODEXHAUST; + if(s=="USERDEFINED" ) return IfcDamperTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDamperTypeEnum::NOTDEFINED; + throw; +} std::string IfcDataOriginEnum::ToString(IfcDataOriginEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "MEASURED","PREDICTED","SIMULATED","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDataOriginEnum::IfcDataOriginEnum IfcDataOriginEnum::FromString(const std::string& s) { + if(s=="MEASURED" ) return IfcDataOriginEnum::MEASURED; + if(s=="PREDICTED" ) return IfcDataOriginEnum::PREDICTED; + if(s=="SIMULATED" ) return IfcDataOriginEnum::SIMULATED; + if(s=="USERDEFINED") return IfcDataOriginEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDataOriginEnum::NOTDEFINED; + throw; +} std::string IfcDerivedUnitEnum::ToString(IfcDerivedUnitEnum v) { - if (v < 0 || v >= 49) throw; + if ( v < 0 || v >= 49 ) throw; const char* names[] = { "ANGULARVELOCITYUNIT","COMPOUNDPLANEANGLEUNIT","DYNAMICVISCOSITYUNIT","HEATFLUXDENSITYUNIT","INTEGERCOUNTRATEUNIT","ISOTHERMALMOISTURECAPACITYUNIT","KINEMATICVISCOSITYUNIT","LINEARVELOCITYUNIT","MASSDENSITYUNIT","MASSFLOWRATEUNIT","MOISTUREDIFFUSIVITYUNIT","MOLECULARWEIGHTUNIT","SPECIFICHEATCAPACITYUNIT","THERMALADMITTANCEUNIT","THERMALCONDUCTANCEUNIT","THERMALRESISTANCEUNIT","THERMALTRANSMITTANCEUNIT","VAPORPERMEABILITYUNIT","VOLUMETRICFLOWRATEUNIT","ROTATIONALFREQUENCYUNIT","TORQUEUNIT","MOMENTOFINERTIAUNIT","LINEARMOMENTUNIT","LINEARFORCEUNIT","PLANARFORCEUNIT","MODULUSOFELASTICITYUNIT","SHEARMODULUSUNIT","LINEARSTIFFNESSUNIT","ROTATIONALSTIFFNESSUNIT","MODULUSOFSUBGRADEREACTIONUNIT","ACCELERATIONUNIT","CURVATUREUNIT","HEATINGVALUEUNIT","IONCONCENTRATIONUNIT","LUMINOUSINTENSITYDISTRIBUTIONUNIT","MASSPERLENGTHUNIT","MODULUSOFLINEARSUBGRADEREACTIONUNIT","MODULUSOFROTATIONALSUBGRADEREACTIONUNIT","PHUNIT","ROTATIONALMASSUNIT","SECTIONAREAINTEGRALUNIT","SECTIONMODULUSUNIT","SOUNDPOWERUNIT","SOUNDPRESSUREUNIT","TEMPERATUREGRADIENTUNIT","THERMALEXPANSIONCOEFFICIENTUNIT","WARPINGCONSTANTUNIT","WARPINGMOMENTUNIT","USERDEFINED" }; return names[v]; } +IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnitEnum::FromString(const std::string& s) { + if(s=="ANGULARVELOCITYUNIT" ) return IfcDerivedUnitEnum::ANGULARVELOCITYUNIT; + if(s=="COMPOUNDPLANEANGLEUNIT" ) return IfcDerivedUnitEnum::COMPOUNDPLANEANGLEUNIT; + if(s=="DYNAMICVISCOSITYUNIT" ) return IfcDerivedUnitEnum::DYNAMICVISCOSITYUNIT; + if(s=="HEATFLUXDENSITYUNIT" ) return IfcDerivedUnitEnum::HEATFLUXDENSITYUNIT; + if(s=="INTEGERCOUNTRATEUNIT" ) return IfcDerivedUnitEnum::INTEGERCOUNTRATEUNIT; + if(s=="ISOTHERMALMOISTURECAPACITYUNIT" ) return IfcDerivedUnitEnum::ISOTHERMALMOISTURECAPACITYUNIT; + if(s=="KINEMATICVISCOSITYUNIT" ) return IfcDerivedUnitEnum::KINEMATICVISCOSITYUNIT; + if(s=="LINEARVELOCITYUNIT" ) return IfcDerivedUnitEnum::LINEARVELOCITYUNIT; + if(s=="MASSDENSITYUNIT" ) return IfcDerivedUnitEnum::MASSDENSITYUNIT; + if(s=="MASSFLOWRATEUNIT" ) return IfcDerivedUnitEnum::MASSFLOWRATEUNIT; + if(s=="MOISTUREDIFFUSIVITYUNIT" ) return IfcDerivedUnitEnum::MOISTUREDIFFUSIVITYUNIT; + if(s=="MOLECULARWEIGHTUNIT" ) return IfcDerivedUnitEnum::MOLECULARWEIGHTUNIT; + if(s=="SPECIFICHEATCAPACITYUNIT" ) return IfcDerivedUnitEnum::SPECIFICHEATCAPACITYUNIT; + if(s=="THERMALADMITTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALADMITTANCEUNIT; + if(s=="THERMALCONDUCTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALCONDUCTANCEUNIT; + if(s=="THERMALRESISTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALRESISTANCEUNIT; + if(s=="THERMALTRANSMITTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALTRANSMITTANCEUNIT; + if(s=="VAPORPERMEABILITYUNIT" ) return IfcDerivedUnitEnum::VAPORPERMEABILITYUNIT; + if(s=="VOLUMETRICFLOWRATEUNIT" ) return IfcDerivedUnitEnum::VOLUMETRICFLOWRATEUNIT; + if(s=="ROTATIONALFREQUENCYUNIT" ) return IfcDerivedUnitEnum::ROTATIONALFREQUENCYUNIT; + if(s=="TORQUEUNIT" ) return IfcDerivedUnitEnum::TORQUEUNIT; + if(s=="MOMENTOFINERTIAUNIT" ) return IfcDerivedUnitEnum::MOMENTOFINERTIAUNIT; + if(s=="LINEARMOMENTUNIT" ) return IfcDerivedUnitEnum::LINEARMOMENTUNIT; + if(s=="LINEARFORCEUNIT" ) return IfcDerivedUnitEnum::LINEARFORCEUNIT; + if(s=="PLANARFORCEUNIT" ) return IfcDerivedUnitEnum::PLANARFORCEUNIT; + if(s=="MODULUSOFELASTICITYUNIT" ) return IfcDerivedUnitEnum::MODULUSOFELASTICITYUNIT; + if(s=="SHEARMODULUSUNIT" ) return IfcDerivedUnitEnum::SHEARMODULUSUNIT; + if(s=="LINEARSTIFFNESSUNIT" ) return IfcDerivedUnitEnum::LINEARSTIFFNESSUNIT; + if(s=="ROTATIONALSTIFFNESSUNIT" ) return IfcDerivedUnitEnum::ROTATIONALSTIFFNESSUNIT; + if(s=="MODULUSOFSUBGRADEREACTIONUNIT" ) return IfcDerivedUnitEnum::MODULUSOFSUBGRADEREACTIONUNIT; + if(s=="ACCELERATIONUNIT" ) return IfcDerivedUnitEnum::ACCELERATIONUNIT; + if(s=="CURVATUREUNIT" ) return IfcDerivedUnitEnum::CURVATUREUNIT; + if(s=="HEATINGVALUEUNIT" ) return IfcDerivedUnitEnum::HEATINGVALUEUNIT; + if(s=="IONCONCENTRATIONUNIT" ) return IfcDerivedUnitEnum::IONCONCENTRATIONUNIT; + if(s=="LUMINOUSINTENSITYDISTRIBUTIONUNIT" ) return IfcDerivedUnitEnum::LUMINOUSINTENSITYDISTRIBUTIONUNIT; + if(s=="MASSPERLENGTHUNIT" ) return IfcDerivedUnitEnum::MASSPERLENGTHUNIT; + if(s=="MODULUSOFLINEARSUBGRADEREACTIONUNIT" ) return IfcDerivedUnitEnum::MODULUSOFLINEARSUBGRADEREACTIONUNIT; + if(s=="MODULUSOFROTATIONALSUBGRADEREACTIONUNIT") return IfcDerivedUnitEnum::MODULUSOFROTATIONALSUBGRADEREACTIONUNIT; + if(s=="PHUNIT" ) return IfcDerivedUnitEnum::PHUNIT; + if(s=="ROTATIONALMASSUNIT" ) return IfcDerivedUnitEnum::ROTATIONALMASSUNIT; + if(s=="SECTIONAREAINTEGRALUNIT" ) return IfcDerivedUnitEnum::SECTIONAREAINTEGRALUNIT; + if(s=="SECTIONMODULUSUNIT" ) return IfcDerivedUnitEnum::SECTIONMODULUSUNIT; + if(s=="SOUNDPOWERUNIT" ) return IfcDerivedUnitEnum::SOUNDPOWERUNIT; + if(s=="SOUNDPRESSUREUNIT" ) return IfcDerivedUnitEnum::SOUNDPRESSUREUNIT; + if(s=="TEMPERATUREGRADIENTUNIT" ) return IfcDerivedUnitEnum::TEMPERATUREGRADIENTUNIT; + if(s=="THERMALEXPANSIONCOEFFICIENTUNIT" ) return IfcDerivedUnitEnum::THERMALEXPANSIONCOEFFICIENTUNIT; + if(s=="WARPINGCONSTANTUNIT" ) return IfcDerivedUnitEnum::WARPINGCONSTANTUNIT; + if(s=="WARPINGMOMENTUNIT" ) return IfcDerivedUnitEnum::WARPINGMOMENTUNIT; + if(s=="USERDEFINED" ) return IfcDerivedUnitEnum::USERDEFINED; + throw; +} std::string IfcDimensionExtentUsage::ToString(IfcDimensionExtentUsage v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "ORIGIN","TARGET" }; return names[v]; } +IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionExtentUsage::FromString(const std::string& s) { + if(s=="ORIGIN") return IfcDimensionExtentUsage::ORIGIN; + if(s=="TARGET") return IfcDimensionExtentUsage::TARGET; + throw; +} std::string IfcDirectionSenseEnum::ToString(IfcDirectionSenseEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "POSITIVE","NEGATIVE" }; return names[v]; } +IfcDirectionSenseEnum::IfcDirectionSenseEnum IfcDirectionSenseEnum::FromString(const std::string& s) { + if(s=="POSITIVE") return IfcDirectionSenseEnum::POSITIVE; + if(s=="NEGATIVE") return IfcDirectionSenseEnum::NEGATIVE; + throw; +} std::string IfcDistributionChamberElementTypeEnum::ToString(IfcDistributionChamberElementTypeEnum v) { - if (v < 0 || v >= 10) throw; + if ( v < 0 || v >= 10 ) throw; const char* names[] = { "FORMEDDUCT","INSPECTIONCHAMBER","INSPECTIONPIT","MANHOLE","METERCHAMBER","SUMP","TRENCH","VALVECHAMBER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementTypeEnum::FromString(const std::string& s) { + if(s=="FORMEDDUCT" ) return IfcDistributionChamberElementTypeEnum::FORMEDDUCT; + if(s=="INSPECTIONCHAMBER") return IfcDistributionChamberElementTypeEnum::INSPECTIONCHAMBER; + if(s=="INSPECTIONPIT" ) return IfcDistributionChamberElementTypeEnum::INSPECTIONPIT; + if(s=="MANHOLE" ) return IfcDistributionChamberElementTypeEnum::MANHOLE; + if(s=="METERCHAMBER" ) return IfcDistributionChamberElementTypeEnum::METERCHAMBER; + if(s=="SUMP" ) return IfcDistributionChamberElementTypeEnum::SUMP; + if(s=="TRENCH" ) return IfcDistributionChamberElementTypeEnum::TRENCH; + if(s=="VALVECHAMBER" ) return IfcDistributionChamberElementTypeEnum::VALVECHAMBER; + if(s=="USERDEFINED" ) return IfcDistributionChamberElementTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDistributionChamberElementTypeEnum::NOTDEFINED; + throw; +} std::string IfcDocumentConfidentialityEnum::ToString(IfcDocumentConfidentialityEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "PUBLIC","RESTRICTED","CONFIDENTIAL","PERSONAL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum IfcDocumentConfidentialityEnum::FromString(const std::string& s) { + if(s=="PUBLIC" ) return IfcDocumentConfidentialityEnum::PUBLIC; + if(s=="RESTRICTED" ) return IfcDocumentConfidentialityEnum::RESTRICTED; + if(s=="CONFIDENTIAL") return IfcDocumentConfidentialityEnum::CONFIDENTIAL; + if(s=="PERSONAL" ) return IfcDocumentConfidentialityEnum::PERSONAL; + if(s=="USERDEFINED" ) return IfcDocumentConfidentialityEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDocumentConfidentialityEnum::NOTDEFINED; + throw; +} std::string IfcDocumentStatusEnum::ToString(IfcDocumentStatusEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "DRAFT","FINALDRAFT","FINAL","REVISION","NOTDEFINED" }; return names[v]; } +IfcDocumentStatusEnum::IfcDocumentStatusEnum IfcDocumentStatusEnum::FromString(const std::string& s) { + if(s=="DRAFT" ) return IfcDocumentStatusEnum::DRAFT; + if(s=="FINALDRAFT") return IfcDocumentStatusEnum::FINALDRAFT; + if(s=="FINAL" ) return IfcDocumentStatusEnum::FINAL; + if(s=="REVISION" ) return IfcDocumentStatusEnum::REVISION; + if(s=="NOTDEFINED") return IfcDocumentStatusEnum::NOTDEFINED; + throw; +} std::string IfcDoorPanelOperationEnum::ToString(IfcDoorPanelOperationEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "SWINGING","DOUBLE_ACTING","SLIDING","FOLDING","REVOLVING","ROLLINGUP","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum IfcDoorPanelOperationEnum::FromString(const std::string& s) { + if(s=="SWINGING" ) return IfcDoorPanelOperationEnum::SWINGING; + if(s=="DOUBLE_ACTING") return IfcDoorPanelOperationEnum::DOUBLE_ACTING; + if(s=="SLIDING" ) return IfcDoorPanelOperationEnum::SLIDING; + if(s=="FOLDING" ) return IfcDoorPanelOperationEnum::FOLDING; + if(s=="REVOLVING" ) return IfcDoorPanelOperationEnum::REVOLVING; + if(s=="ROLLINGUP" ) return IfcDoorPanelOperationEnum::ROLLINGUP; + if(s=="USERDEFINED" ) return IfcDoorPanelOperationEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDoorPanelOperationEnum::NOTDEFINED; + throw; +} std::string IfcDoorPanelPositionEnum::ToString(IfcDoorPanelPositionEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "LEFT","MIDDLE","RIGHT","NOTDEFINED" }; return names[v]; } +IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum IfcDoorPanelPositionEnum::FromString(const std::string& s) { + if(s=="LEFT" ) return IfcDoorPanelPositionEnum::LEFT; + if(s=="MIDDLE" ) return IfcDoorPanelPositionEnum::MIDDLE; + if(s=="RIGHT" ) return IfcDoorPanelPositionEnum::RIGHT; + if(s=="NOTDEFINED") return IfcDoorPanelPositionEnum::NOTDEFINED; + throw; +} std::string IfcDoorStyleConstructionEnum::ToString(IfcDoorStyleConstructionEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "ALUMINIUM","HIGH_GRADE_STEEL","STEEL","WOOD","ALUMINIUM_WOOD","ALUMINIUM_PLASTIC","PLASTIC","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyleConstructionEnum::FromString(const std::string& s) { + if(s=="ALUMINIUM" ) return IfcDoorStyleConstructionEnum::ALUMINIUM; + if(s=="HIGH_GRADE_STEEL" ) return IfcDoorStyleConstructionEnum::HIGH_GRADE_STEEL; + if(s=="STEEL" ) return IfcDoorStyleConstructionEnum::STEEL; + if(s=="WOOD" ) return IfcDoorStyleConstructionEnum::WOOD; + if(s=="ALUMINIUM_WOOD" ) return IfcDoorStyleConstructionEnum::ALUMINIUM_WOOD; + if(s=="ALUMINIUM_PLASTIC") return IfcDoorStyleConstructionEnum::ALUMINIUM_PLASTIC; + if(s=="PLASTIC" ) return IfcDoorStyleConstructionEnum::PLASTIC; + if(s=="USERDEFINED" ) return IfcDoorStyleConstructionEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDoorStyleConstructionEnum::NOTDEFINED; + throw; +} std::string IfcDoorStyleOperationEnum::ToString(IfcDoorStyleOperationEnum v) { - if (v < 0 || v >= 18) throw; + if ( v < 0 || v >= 18 ) throw; const char* names[] = { "SINGLE_SWING_LEFT","SINGLE_SWING_RIGHT","DOUBLE_DOOR_SINGLE_SWING","DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT","DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT","DOUBLE_SWING_LEFT","DOUBLE_SWING_RIGHT","DOUBLE_DOOR_DOUBLE_SWING","SLIDING_TO_LEFT","SLIDING_TO_RIGHT","DOUBLE_DOOR_SLIDING","FOLDING_TO_LEFT","FOLDING_TO_RIGHT","DOUBLE_DOOR_FOLDING","REVOLVING","ROLLINGUP","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyleOperationEnum::FromString(const std::string& s) { + if(s=="SINGLE_SWING_LEFT" ) return IfcDoorStyleOperationEnum::SINGLE_SWING_LEFT; + if(s=="SINGLE_SWING_RIGHT" ) return IfcDoorStyleOperationEnum::SINGLE_SWING_RIGHT; + if(s=="DOUBLE_DOOR_SINGLE_SWING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING; + if(s=="DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT; + if(s=="DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT") return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT; + if(s=="DOUBLE_SWING_LEFT" ) return IfcDoorStyleOperationEnum::DOUBLE_SWING_LEFT; + if(s=="DOUBLE_SWING_RIGHT" ) return IfcDoorStyleOperationEnum::DOUBLE_SWING_RIGHT; + if(s=="DOUBLE_DOOR_DOUBLE_SWING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_DOUBLE_SWING; + if(s=="SLIDING_TO_LEFT" ) return IfcDoorStyleOperationEnum::SLIDING_TO_LEFT; + if(s=="SLIDING_TO_RIGHT" ) return IfcDoorStyleOperationEnum::SLIDING_TO_RIGHT; + if(s=="DOUBLE_DOOR_SLIDING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SLIDING; + if(s=="FOLDING_TO_LEFT" ) return IfcDoorStyleOperationEnum::FOLDING_TO_LEFT; + if(s=="FOLDING_TO_RIGHT" ) return IfcDoorStyleOperationEnum::FOLDING_TO_RIGHT; + if(s=="DOUBLE_DOOR_FOLDING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_FOLDING; + if(s=="REVOLVING" ) return IfcDoorStyleOperationEnum::REVOLVING; + if(s=="ROLLINGUP" ) return IfcDoorStyleOperationEnum::ROLLINGUP; + if(s=="USERDEFINED" ) return IfcDoorStyleOperationEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDoorStyleOperationEnum::NOTDEFINED; + throw; +} std::string IfcDuctFittingTypeEnum::ToString(IfcDuctFittingTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "BEND","CONNECTOR","ENTRY","EXIT","JUNCTION","OBSTRUCTION","TRANSITION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingTypeEnum::FromString(const std::string& s) { + if(s=="BEND" ) return IfcDuctFittingTypeEnum::BEND; + if(s=="CONNECTOR" ) return IfcDuctFittingTypeEnum::CONNECTOR; + if(s=="ENTRY" ) return IfcDuctFittingTypeEnum::ENTRY; + if(s=="EXIT" ) return IfcDuctFittingTypeEnum::EXIT; + if(s=="JUNCTION" ) return IfcDuctFittingTypeEnum::JUNCTION; + if(s=="OBSTRUCTION") return IfcDuctFittingTypeEnum::OBSTRUCTION; + if(s=="TRANSITION" ) return IfcDuctFittingTypeEnum::TRANSITION; + if(s=="USERDEFINED") return IfcDuctFittingTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDuctFittingTypeEnum::NOTDEFINED; + throw; +} std::string IfcDuctSegmentTypeEnum::ToString(IfcDuctSegmentTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "RIGIDSEGMENT","FLEXIBLESEGMENT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentTypeEnum::FromString(const std::string& s) { + if(s=="RIGIDSEGMENT" ) return IfcDuctSegmentTypeEnum::RIGIDSEGMENT; + if(s=="FLEXIBLESEGMENT") return IfcDuctSegmentTypeEnum::FLEXIBLESEGMENT; + if(s=="USERDEFINED" ) return IfcDuctSegmentTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDuctSegmentTypeEnum::NOTDEFINED; + throw; +} std::string IfcDuctSilencerTypeEnum::ToString(IfcDuctSilencerTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "FLATOVAL","RECTANGULAR","ROUND","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerTypeEnum::FromString(const std::string& s) { + if(s=="FLATOVAL" ) return IfcDuctSilencerTypeEnum::FLATOVAL; + if(s=="RECTANGULAR") return IfcDuctSilencerTypeEnum::RECTANGULAR; + if(s=="ROUND" ) return IfcDuctSilencerTypeEnum::ROUND; + if(s=="USERDEFINED") return IfcDuctSilencerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcDuctSilencerTypeEnum::NOTDEFINED; + throw; +} std::string IfcElectricApplianceTypeEnum::ToString(IfcElectricApplianceTypeEnum v) { - if (v < 0 || v >= 26) throw; + if ( v < 0 || v >= 26 ) throw; const char* names[] = { "COMPUTER","DIRECTWATERHEATER","DISHWASHER","ELECTRICCOOKER","ELECTRICHEATER","FACSIMILE","FREESTANDINGFAN","FREEZER","FRIDGE_FREEZER","HANDDRYER","INDIRECTWATERHEATER","MICROWAVE","PHOTOCOPIER","PRINTER","REFRIGERATOR","RADIANTHEATER","SCANNER","TELEPHONE","TUMBLEDRYER","TV","VENDINGMACHINE","WASHINGMACHINE","WATERHEATER","WATERCOOLER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceTypeEnum::FromString(const std::string& s) { + if(s=="COMPUTER" ) return IfcElectricApplianceTypeEnum::COMPUTER; + if(s=="DIRECTWATERHEATER" ) return IfcElectricApplianceTypeEnum::DIRECTWATERHEATER; + if(s=="DISHWASHER" ) return IfcElectricApplianceTypeEnum::DISHWASHER; + if(s=="ELECTRICCOOKER" ) return IfcElectricApplianceTypeEnum::ELECTRICCOOKER; + if(s=="ELECTRICHEATER" ) return IfcElectricApplianceTypeEnum::ELECTRICHEATER; + if(s=="FACSIMILE" ) return IfcElectricApplianceTypeEnum::FACSIMILE; + if(s=="FREESTANDINGFAN" ) return IfcElectricApplianceTypeEnum::FREESTANDINGFAN; + if(s=="FREEZER" ) return IfcElectricApplianceTypeEnum::FREEZER; + if(s=="FRIDGE_FREEZER" ) return IfcElectricApplianceTypeEnum::FRIDGE_FREEZER; + if(s=="HANDDRYER" ) return IfcElectricApplianceTypeEnum::HANDDRYER; + if(s=="INDIRECTWATERHEATER") return IfcElectricApplianceTypeEnum::INDIRECTWATERHEATER; + if(s=="MICROWAVE" ) return IfcElectricApplianceTypeEnum::MICROWAVE; + if(s=="PHOTOCOPIER" ) return IfcElectricApplianceTypeEnum::PHOTOCOPIER; + if(s=="PRINTER" ) return IfcElectricApplianceTypeEnum::PRINTER; + if(s=="REFRIGERATOR" ) return IfcElectricApplianceTypeEnum::REFRIGERATOR; + if(s=="RADIANTHEATER" ) return IfcElectricApplianceTypeEnum::RADIANTHEATER; + if(s=="SCANNER" ) return IfcElectricApplianceTypeEnum::SCANNER; + if(s=="TELEPHONE" ) return IfcElectricApplianceTypeEnum::TELEPHONE; + if(s=="TUMBLEDRYER" ) return IfcElectricApplianceTypeEnum::TUMBLEDRYER; + if(s=="TV" ) return IfcElectricApplianceTypeEnum::TV; + if(s=="VENDINGMACHINE" ) return IfcElectricApplianceTypeEnum::VENDINGMACHINE; + if(s=="WASHINGMACHINE" ) return IfcElectricApplianceTypeEnum::WASHINGMACHINE; + if(s=="WATERHEATER" ) return IfcElectricApplianceTypeEnum::WATERHEATER; + if(s=="WATERCOOLER" ) return IfcElectricApplianceTypeEnum::WATERCOOLER; + if(s=="USERDEFINED" ) return IfcElectricApplianceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricApplianceTypeEnum::NOTDEFINED; + throw; +} std::string IfcElectricCurrentEnum::ToString(IfcElectricCurrentEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "ALTERNATING","DIRECT","NOTDEFINED" }; return names[v]; } +IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricCurrentEnum::FromString(const std::string& s) { + if(s=="ALTERNATING") return IfcElectricCurrentEnum::ALTERNATING; + if(s=="DIRECT" ) return IfcElectricCurrentEnum::DIRECT; + if(s=="NOTDEFINED" ) return IfcElectricCurrentEnum::NOTDEFINED; + throw; +} std::string IfcElectricDistributionPointFunctionEnum::ToString(IfcElectricDistributionPointFunctionEnum v) { - if (v < 0 || v >= 11) throw; + if ( v < 0 || v >= 11 ) throw; const char* names[] = { "ALARMPANEL","CONSUMERUNIT","CONTROLPANEL","DISTRIBUTIONBOARD","GASDETECTORPANEL","INDICATORPANEL","MIMICPANEL","MOTORCONTROLCENTRE","SWITCHBOARD","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPointFunctionEnum::FromString(const std::string& s) { + if(s=="ALARMPANEL" ) return IfcElectricDistributionPointFunctionEnum::ALARMPANEL; + if(s=="CONSUMERUNIT" ) return IfcElectricDistributionPointFunctionEnum::CONSUMERUNIT; + if(s=="CONTROLPANEL" ) return IfcElectricDistributionPointFunctionEnum::CONTROLPANEL; + if(s=="DISTRIBUTIONBOARD" ) return IfcElectricDistributionPointFunctionEnum::DISTRIBUTIONBOARD; + if(s=="GASDETECTORPANEL" ) return IfcElectricDistributionPointFunctionEnum::GASDETECTORPANEL; + if(s=="INDICATORPANEL" ) return IfcElectricDistributionPointFunctionEnum::INDICATORPANEL; + if(s=="MIMICPANEL" ) return IfcElectricDistributionPointFunctionEnum::MIMICPANEL; + if(s=="MOTORCONTROLCENTRE") return IfcElectricDistributionPointFunctionEnum::MOTORCONTROLCENTRE; + if(s=="SWITCHBOARD" ) return IfcElectricDistributionPointFunctionEnum::SWITCHBOARD; + if(s=="USERDEFINED" ) return IfcElectricDistributionPointFunctionEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricDistributionPointFunctionEnum::NOTDEFINED; + throw; +} std::string IfcElectricFlowStorageDeviceTypeEnum::ToString(IfcElectricFlowStorageDeviceTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "BATTERY","CAPACITORBANK","HARMONICFILTER","INDUCTORBANK","UPS","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceTypeEnum::FromString(const std::string& s) { + if(s=="BATTERY" ) return IfcElectricFlowStorageDeviceTypeEnum::BATTERY; + if(s=="CAPACITORBANK" ) return IfcElectricFlowStorageDeviceTypeEnum::CAPACITORBANK; + if(s=="HARMONICFILTER") return IfcElectricFlowStorageDeviceTypeEnum::HARMONICFILTER; + if(s=="INDUCTORBANK" ) return IfcElectricFlowStorageDeviceTypeEnum::INDUCTORBANK; + if(s=="UPS" ) return IfcElectricFlowStorageDeviceTypeEnum::UPS; + if(s=="USERDEFINED" ) return IfcElectricFlowStorageDeviceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricFlowStorageDeviceTypeEnum::NOTDEFINED; + throw; +} std::string IfcElectricGeneratorTypeEnum::ToString(IfcElectricGeneratorTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorTypeEnum::FromString(const std::string& s) { + if(s=="USERDEFINED") return IfcElectricGeneratorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricGeneratorTypeEnum::NOTDEFINED; + throw; +} std::string IfcElectricHeaterTypeEnum::ToString(IfcElectricHeaterTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "ELECTRICPOINTHEATER","ELECTRICCABLEHEATER","ELECTRICMATHEATER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterTypeEnum::FromString(const std::string& s) { + if(s=="ELECTRICPOINTHEATER") return IfcElectricHeaterTypeEnum::ELECTRICPOINTHEATER; + if(s=="ELECTRICCABLEHEATER") return IfcElectricHeaterTypeEnum::ELECTRICCABLEHEATER; + if(s=="ELECTRICMATHEATER" ) return IfcElectricHeaterTypeEnum::ELECTRICMATHEATER; + if(s=="USERDEFINED" ) return IfcElectricHeaterTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricHeaterTypeEnum::NOTDEFINED; + throw; +} std::string IfcElectricMotorTypeEnum::ToString(IfcElectricMotorTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "DC","INDUCTION","POLYPHASE","RELUCTANCESYNCHRONOUS","SYNCHRONOUS","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorTypeEnum::FromString(const std::string& s) { + if(s=="DC" ) return IfcElectricMotorTypeEnum::DC; + if(s=="INDUCTION" ) return IfcElectricMotorTypeEnum::INDUCTION; + if(s=="POLYPHASE" ) return IfcElectricMotorTypeEnum::POLYPHASE; + if(s=="RELUCTANCESYNCHRONOUS") return IfcElectricMotorTypeEnum::RELUCTANCESYNCHRONOUS; + if(s=="SYNCHRONOUS" ) return IfcElectricMotorTypeEnum::SYNCHRONOUS; + if(s=="USERDEFINED" ) return IfcElectricMotorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricMotorTypeEnum::NOTDEFINED; + throw; +} std::string IfcElectricTimeControlTypeEnum::ToString(IfcElectricTimeControlTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "TIMECLOCK","TIMEDELAY","RELAY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlTypeEnum::FromString(const std::string& s) { + if(s=="TIMECLOCK" ) return IfcElectricTimeControlTypeEnum::TIMECLOCK; + if(s=="TIMEDELAY" ) return IfcElectricTimeControlTypeEnum::TIMEDELAY; + if(s=="RELAY" ) return IfcElectricTimeControlTypeEnum::RELAY; + if(s=="USERDEFINED") return IfcElectricTimeControlTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElectricTimeControlTypeEnum::NOTDEFINED; + throw; +} std::string IfcElementAssemblyTypeEnum::ToString(IfcElementAssemblyTypeEnum v) { - if (v < 0 || v >= 11) throw; + if ( v < 0 || v >= 11 ) throw; const char* names[] = { "ACCESSORY_ASSEMBLY","ARCH","BEAM_GRID","BRACED_FRAME","GIRDER","REINFORCEMENT_UNIT","RIGID_FRAME","SLAB_FIELD","TRUSS","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssemblyTypeEnum::FromString(const std::string& s) { + if(s=="ACCESSORY_ASSEMBLY") return IfcElementAssemblyTypeEnum::ACCESSORY_ASSEMBLY; + if(s=="ARCH" ) return IfcElementAssemblyTypeEnum::ARCH; + if(s=="BEAM_GRID" ) return IfcElementAssemblyTypeEnum::BEAM_GRID; + if(s=="BRACED_FRAME" ) return IfcElementAssemblyTypeEnum::BRACED_FRAME; + if(s=="GIRDER" ) return IfcElementAssemblyTypeEnum::GIRDER; + if(s=="REINFORCEMENT_UNIT") return IfcElementAssemblyTypeEnum::REINFORCEMENT_UNIT; + if(s=="RIGID_FRAME" ) return IfcElementAssemblyTypeEnum::RIGID_FRAME; + if(s=="SLAB_FIELD" ) return IfcElementAssemblyTypeEnum::SLAB_FIELD; + if(s=="TRUSS" ) return IfcElementAssemblyTypeEnum::TRUSS; + if(s=="USERDEFINED" ) return IfcElementAssemblyTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcElementAssemblyTypeEnum::NOTDEFINED; + throw; +} std::string IfcElementCompositionEnum::ToString(IfcElementCompositionEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "COMPLEX","ELEMENT","PARTIAL" }; return names[v]; } +IfcElementCompositionEnum::IfcElementCompositionEnum IfcElementCompositionEnum::FromString(const std::string& s) { + if(s=="COMPLEX") return IfcElementCompositionEnum::COMPLEX; + if(s=="ELEMENT") return IfcElementCompositionEnum::ELEMENT; + if(s=="PARTIAL") return IfcElementCompositionEnum::PARTIAL; + throw; +} std::string IfcEnergySequenceEnum::ToString(IfcEnergySequenceEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "PRIMARY","SECONDARY","TERTIARY","AUXILIARY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergySequenceEnum::FromString(const std::string& s) { + if(s=="PRIMARY" ) return IfcEnergySequenceEnum::PRIMARY; + if(s=="SECONDARY" ) return IfcEnergySequenceEnum::SECONDARY; + if(s=="TERTIARY" ) return IfcEnergySequenceEnum::TERTIARY; + if(s=="AUXILIARY" ) return IfcEnergySequenceEnum::AUXILIARY; + if(s=="USERDEFINED") return IfcEnergySequenceEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcEnergySequenceEnum::NOTDEFINED; + throw; +} std::string IfcEnvironmentalImpactCategoryEnum::ToString(IfcEnvironmentalImpactCategoryEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "COMBINEDVALUE","DISPOSAL","EXTRACTION","INSTALLATION","MANUFACTURE","TRANSPORTATION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactCategoryEnum::FromString(const std::string& s) { + if(s=="COMBINEDVALUE" ) return IfcEnvironmentalImpactCategoryEnum::COMBINEDVALUE; + if(s=="DISPOSAL" ) return IfcEnvironmentalImpactCategoryEnum::DISPOSAL; + if(s=="EXTRACTION" ) return IfcEnvironmentalImpactCategoryEnum::EXTRACTION; + if(s=="INSTALLATION" ) return IfcEnvironmentalImpactCategoryEnum::INSTALLATION; + if(s=="MANUFACTURE" ) return IfcEnvironmentalImpactCategoryEnum::MANUFACTURE; + if(s=="TRANSPORTATION") return IfcEnvironmentalImpactCategoryEnum::TRANSPORTATION; + if(s=="USERDEFINED" ) return IfcEnvironmentalImpactCategoryEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcEnvironmentalImpactCategoryEnum::NOTDEFINED; + throw; +} std::string IfcEvaporativeCoolerTypeEnum::ToString(IfcEvaporativeCoolerTypeEnum v) { - if (v < 0 || v >= 11) throw; + if ( v < 0 || v >= 11 ) throw; const char* names[] = { "DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER","DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER","DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER","DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER","DIRECTEVAPORATIVEAIRWASHER","INDIRECTEVAPORATIVEPACKAGEAIRCOOLER","INDIRECTEVAPORATIVEWETCOIL","INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER","INDIRECTDIRECTCOMBINATION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerTypeEnum::FromString(const std::string& s) { + if(s=="DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER; + if(s=="DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER; + if(s=="DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER; + if(s=="DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER; + if(s=="DIRECTEVAPORATIVEAIRWASHER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVEAIRWASHER; + if(s=="INDIRECTEVAPORATIVEPACKAGEAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVEPACKAGEAIRCOOLER; + if(s=="INDIRECTEVAPORATIVEWETCOIL" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVEWETCOIL; + if(s=="INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER") return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER; + if(s=="INDIRECTDIRECTCOMBINATION" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTDIRECTCOMBINATION; + if(s=="USERDEFINED" ) return IfcEvaporativeCoolerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcEvaporativeCoolerTypeEnum::NOTDEFINED; + throw; +} std::string IfcEvaporatorTypeEnum::ToString(IfcEvaporatorTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "DIRECTEXPANSIONSHELLANDTUBE","DIRECTEXPANSIONTUBEINTUBE","DIRECTEXPANSIONBRAZEDPLATE","FLOODEDSHELLANDTUBE","SHELLANDCOIL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorTypeEnum::FromString(const std::string& s) { + if(s=="DIRECTEXPANSIONSHELLANDTUBE") return IfcEvaporatorTypeEnum::DIRECTEXPANSIONSHELLANDTUBE; + if(s=="DIRECTEXPANSIONTUBEINTUBE" ) return IfcEvaporatorTypeEnum::DIRECTEXPANSIONTUBEINTUBE; + if(s=="DIRECTEXPANSIONBRAZEDPLATE" ) return IfcEvaporatorTypeEnum::DIRECTEXPANSIONBRAZEDPLATE; + if(s=="FLOODEDSHELLANDTUBE" ) return IfcEvaporatorTypeEnum::FLOODEDSHELLANDTUBE; + if(s=="SHELLANDCOIL" ) return IfcEvaporatorTypeEnum::SHELLANDCOIL; + if(s=="USERDEFINED" ) return IfcEvaporatorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcEvaporatorTypeEnum::NOTDEFINED; + throw; +} std::string IfcFanTypeEnum::ToString(IfcFanTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "CENTRIFUGALFORWARDCURVED","CENTRIFUGALRADIAL","CENTRIFUGALBACKWARDINCLINEDCURVED","CENTRIFUGALAIRFOIL","TUBEAXIAL","VANEAXIAL","PROPELLORAXIAL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcFanTypeEnum::IfcFanTypeEnum IfcFanTypeEnum::FromString(const std::string& s) { + if(s=="CENTRIFUGALFORWARDCURVED" ) return IfcFanTypeEnum::CENTRIFUGALFORWARDCURVED; + if(s=="CENTRIFUGALRADIAL" ) return IfcFanTypeEnum::CENTRIFUGALRADIAL; + if(s=="CENTRIFUGALBACKWARDINCLINEDCURVED") return IfcFanTypeEnum::CENTRIFUGALBACKWARDINCLINEDCURVED; + if(s=="CENTRIFUGALAIRFOIL" ) return IfcFanTypeEnum::CENTRIFUGALAIRFOIL; + if(s=="TUBEAXIAL" ) return IfcFanTypeEnum::TUBEAXIAL; + if(s=="VANEAXIAL" ) return IfcFanTypeEnum::VANEAXIAL; + if(s=="PROPELLORAXIAL" ) return IfcFanTypeEnum::PROPELLORAXIAL; + if(s=="USERDEFINED" ) return IfcFanTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcFanTypeEnum::NOTDEFINED; + throw; +} std::string IfcFilterTypeEnum::ToString(IfcFilterTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "AIRPARTICLEFILTER","ODORFILTER","OILFILTER","STRAINER","WATERFILTER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterTypeEnum::FromString(const std::string& s) { + if(s=="AIRPARTICLEFILTER") return IfcFilterTypeEnum::AIRPARTICLEFILTER; + if(s=="ODORFILTER" ) return IfcFilterTypeEnum::ODORFILTER; + if(s=="OILFILTER" ) return IfcFilterTypeEnum::OILFILTER; + if(s=="STRAINER" ) return IfcFilterTypeEnum::STRAINER; + if(s=="WATERFILTER" ) return IfcFilterTypeEnum::WATERFILTER; + if(s=="USERDEFINED" ) return IfcFilterTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcFilterTypeEnum::NOTDEFINED; + throw; +} std::string IfcFireSuppressionTerminalTypeEnum::ToString(IfcFireSuppressionTerminalTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "BREECHINGINLET","FIREHYDRANT","HOSEREEL","SPRINKLER","SPRINKLERDEFLECTOR","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalTypeEnum::FromString(const std::string& s) { + if(s=="BREECHINGINLET" ) return IfcFireSuppressionTerminalTypeEnum::BREECHINGINLET; + if(s=="FIREHYDRANT" ) return IfcFireSuppressionTerminalTypeEnum::FIREHYDRANT; + if(s=="HOSEREEL" ) return IfcFireSuppressionTerminalTypeEnum::HOSEREEL; + if(s=="SPRINKLER" ) return IfcFireSuppressionTerminalTypeEnum::SPRINKLER; + if(s=="SPRINKLERDEFLECTOR") return IfcFireSuppressionTerminalTypeEnum::SPRINKLERDEFLECTOR; + if(s=="USERDEFINED" ) return IfcFireSuppressionTerminalTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcFireSuppressionTerminalTypeEnum::NOTDEFINED; + throw; +} std::string IfcFlowDirectionEnum::ToString(IfcFlowDirectionEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "SOURCE","SINK","SOURCEANDSINK","NOTDEFINED" }; return names[v]; } +IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcFlowDirectionEnum::FromString(const std::string& s) { + if(s=="SOURCE" ) return IfcFlowDirectionEnum::SOURCE; + if(s=="SINK" ) return IfcFlowDirectionEnum::SINK; + if(s=="SOURCEANDSINK") return IfcFlowDirectionEnum::SOURCEANDSINK; + if(s=="NOTDEFINED" ) return IfcFlowDirectionEnum::NOTDEFINED; + throw; +} std::string IfcFlowInstrumentTypeEnum::ToString(IfcFlowInstrumentTypeEnum v) { - if (v < 0 || v >= 10) throw; + if ( v < 0 || v >= 10 ) throw; const char* names[] = { "PRESSUREGAUGE","THERMOMETER","AMMETER","FREQUENCYMETER","POWERFACTORMETER","PHASEANGLEMETER","VOLTMETER_PEAK","VOLTMETER_RMS","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentTypeEnum::FromString(const std::string& s) { + if(s=="PRESSUREGAUGE" ) return IfcFlowInstrumentTypeEnum::PRESSUREGAUGE; + if(s=="THERMOMETER" ) return IfcFlowInstrumentTypeEnum::THERMOMETER; + if(s=="AMMETER" ) return IfcFlowInstrumentTypeEnum::AMMETER; + if(s=="FREQUENCYMETER" ) return IfcFlowInstrumentTypeEnum::FREQUENCYMETER; + if(s=="POWERFACTORMETER") return IfcFlowInstrumentTypeEnum::POWERFACTORMETER; + if(s=="PHASEANGLEMETER" ) return IfcFlowInstrumentTypeEnum::PHASEANGLEMETER; + if(s=="VOLTMETER_PEAK" ) return IfcFlowInstrumentTypeEnum::VOLTMETER_PEAK; + if(s=="VOLTMETER_RMS" ) return IfcFlowInstrumentTypeEnum::VOLTMETER_RMS; + if(s=="USERDEFINED" ) return IfcFlowInstrumentTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcFlowInstrumentTypeEnum::NOTDEFINED; + throw; +} std::string IfcFlowMeterTypeEnum::ToString(IfcFlowMeterTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "ELECTRICMETER","ENERGYMETER","FLOWMETER","GASMETER","OILMETER","WATERMETER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterTypeEnum::FromString(const std::string& s) { + if(s=="ELECTRICMETER") return IfcFlowMeterTypeEnum::ELECTRICMETER; + if(s=="ENERGYMETER" ) return IfcFlowMeterTypeEnum::ENERGYMETER; + if(s=="FLOWMETER" ) return IfcFlowMeterTypeEnum::FLOWMETER; + if(s=="GASMETER" ) return IfcFlowMeterTypeEnum::GASMETER; + if(s=="OILMETER" ) return IfcFlowMeterTypeEnum::OILMETER; + if(s=="WATERMETER" ) return IfcFlowMeterTypeEnum::WATERMETER; + if(s=="USERDEFINED" ) return IfcFlowMeterTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcFlowMeterTypeEnum::NOTDEFINED; + throw; +} std::string IfcFootingTypeEnum::ToString(IfcFootingTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "FOOTING_BEAM","PAD_FOOTING","PILE_CAP","STRIP_FOOTING","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcFootingTypeEnum::IfcFootingTypeEnum IfcFootingTypeEnum::FromString(const std::string& s) { + if(s=="FOOTING_BEAM" ) return IfcFootingTypeEnum::FOOTING_BEAM; + if(s=="PAD_FOOTING" ) return IfcFootingTypeEnum::PAD_FOOTING; + if(s=="PILE_CAP" ) return IfcFootingTypeEnum::PILE_CAP; + if(s=="STRIP_FOOTING") return IfcFootingTypeEnum::STRIP_FOOTING; + if(s=="USERDEFINED" ) return IfcFootingTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcFootingTypeEnum::NOTDEFINED; + throw; +} std::string IfcGasTerminalTypeEnum::ToString(IfcGasTerminalTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "GASAPPLIANCE","GASBOOSTER","GASBURNER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalTypeEnum::FromString(const std::string& s) { + if(s=="GASAPPLIANCE") return IfcGasTerminalTypeEnum::GASAPPLIANCE; + if(s=="GASBOOSTER" ) return IfcGasTerminalTypeEnum::GASBOOSTER; + if(s=="GASBURNER" ) return IfcGasTerminalTypeEnum::GASBURNER; + if(s=="USERDEFINED" ) return IfcGasTerminalTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcGasTerminalTypeEnum::NOTDEFINED; + throw; +} std::string IfcGeometricProjectionEnum::ToString(IfcGeometricProjectionEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "GRAPH_VIEW","SKETCH_VIEW","MODEL_VIEW","PLAN_VIEW","REFLECTED_PLAN_VIEW","SECTION_VIEW","ELEVATION_VIEW","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcGeometricProjectionEnum::IfcGeometricProjectionEnum IfcGeometricProjectionEnum::FromString(const std::string& s) { + if(s=="GRAPH_VIEW" ) return IfcGeometricProjectionEnum::GRAPH_VIEW; + if(s=="SKETCH_VIEW" ) return IfcGeometricProjectionEnum::SKETCH_VIEW; + if(s=="MODEL_VIEW" ) return IfcGeometricProjectionEnum::MODEL_VIEW; + if(s=="PLAN_VIEW" ) return IfcGeometricProjectionEnum::PLAN_VIEW; + if(s=="REFLECTED_PLAN_VIEW") return IfcGeometricProjectionEnum::REFLECTED_PLAN_VIEW; + if(s=="SECTION_VIEW" ) return IfcGeometricProjectionEnum::SECTION_VIEW; + if(s=="ELEVATION_VIEW" ) return IfcGeometricProjectionEnum::ELEVATION_VIEW; + if(s=="USERDEFINED" ) return IfcGeometricProjectionEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcGeometricProjectionEnum::NOTDEFINED; + throw; +} std::string IfcGlobalOrLocalEnum::ToString(IfcGlobalOrLocalEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "GLOBAL_COORDS","LOCAL_COORDS" }; return names[v]; } +IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcGlobalOrLocalEnum::FromString(const std::string& s) { + if(s=="GLOBAL_COORDS") return IfcGlobalOrLocalEnum::GLOBAL_COORDS; + if(s=="LOCAL_COORDS" ) return IfcGlobalOrLocalEnum::LOCAL_COORDS; + throw; +} std::string IfcHeatExchangerTypeEnum::ToString(IfcHeatExchangerTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "PLATE","SHELLANDTUBE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerTypeEnum::FromString(const std::string& s) { + if(s=="PLATE" ) return IfcHeatExchangerTypeEnum::PLATE; + if(s=="SHELLANDTUBE") return IfcHeatExchangerTypeEnum::SHELLANDTUBE; + if(s=="USERDEFINED" ) return IfcHeatExchangerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcHeatExchangerTypeEnum::NOTDEFINED; + throw; +} std::string IfcHumidifierTypeEnum::ToString(IfcHumidifierTypeEnum v) { - if (v < 0 || v >= 15) throw; + if ( v < 0 || v >= 15 ) throw; const char* names[] = { "STEAMINJECTION","ADIABATICAIRWASHER","ADIABATICPAN","ADIABATICWETTEDELEMENT","ADIABATICATOMIZING","ADIABATICULTRASONIC","ADIABATICRIGIDMEDIA","ADIABATICCOMPRESSEDAIRNOZZLE","ASSISTEDELECTRIC","ASSISTEDNATURALGAS","ASSISTEDPROPANE","ASSISTEDBUTANE","ASSISTEDSTEAM","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierTypeEnum::FromString(const std::string& s) { + if(s=="STEAMINJECTION" ) return IfcHumidifierTypeEnum::STEAMINJECTION; + if(s=="ADIABATICAIRWASHER" ) return IfcHumidifierTypeEnum::ADIABATICAIRWASHER; + if(s=="ADIABATICPAN" ) return IfcHumidifierTypeEnum::ADIABATICPAN; + if(s=="ADIABATICWETTEDELEMENT" ) return IfcHumidifierTypeEnum::ADIABATICWETTEDELEMENT; + if(s=="ADIABATICATOMIZING" ) return IfcHumidifierTypeEnum::ADIABATICATOMIZING; + if(s=="ADIABATICULTRASONIC" ) return IfcHumidifierTypeEnum::ADIABATICULTRASONIC; + if(s=="ADIABATICRIGIDMEDIA" ) return IfcHumidifierTypeEnum::ADIABATICRIGIDMEDIA; + if(s=="ADIABATICCOMPRESSEDAIRNOZZLE") return IfcHumidifierTypeEnum::ADIABATICCOMPRESSEDAIRNOZZLE; + if(s=="ASSISTEDELECTRIC" ) return IfcHumidifierTypeEnum::ASSISTEDELECTRIC; + if(s=="ASSISTEDNATURALGAS" ) return IfcHumidifierTypeEnum::ASSISTEDNATURALGAS; + if(s=="ASSISTEDPROPANE" ) return IfcHumidifierTypeEnum::ASSISTEDPROPANE; + if(s=="ASSISTEDBUTANE" ) return IfcHumidifierTypeEnum::ASSISTEDBUTANE; + if(s=="ASSISTEDSTEAM" ) return IfcHumidifierTypeEnum::ASSISTEDSTEAM; + if(s=="USERDEFINED" ) return IfcHumidifierTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcHumidifierTypeEnum::NOTDEFINED; + throw; +} std::string IfcInternalOrExternalEnum::ToString(IfcInternalOrExternalEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "INTERNAL","EXTERNAL","NOTDEFINED" }; return names[v]; } +IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcInternalOrExternalEnum::FromString(const std::string& s) { + if(s=="INTERNAL" ) return IfcInternalOrExternalEnum::INTERNAL; + if(s=="EXTERNAL" ) return IfcInternalOrExternalEnum::EXTERNAL; + if(s=="NOTDEFINED") return IfcInternalOrExternalEnum::NOTDEFINED; + throw; +} std::string IfcInventoryTypeEnum::ToString(IfcInventoryTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "ASSETINVENTORY","SPACEINVENTORY","FURNITUREINVENTORY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventoryTypeEnum::FromString(const std::string& s) { + if(s=="ASSETINVENTORY" ) return IfcInventoryTypeEnum::ASSETINVENTORY; + if(s=="SPACEINVENTORY" ) return IfcInventoryTypeEnum::SPACEINVENTORY; + if(s=="FURNITUREINVENTORY") return IfcInventoryTypeEnum::FURNITUREINVENTORY; + if(s=="USERDEFINED" ) return IfcInventoryTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcInventoryTypeEnum::NOTDEFINED; + throw; +} std::string IfcJunctionBoxTypeEnum::ToString(IfcJunctionBoxTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxTypeEnum::FromString(const std::string& s) { + if(s=="USERDEFINED") return IfcJunctionBoxTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcJunctionBoxTypeEnum::NOTDEFINED; + throw; +} std::string IfcLampTypeEnum::ToString(IfcLampTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "COMPACTFLUORESCENT","FLUORESCENT","HIGHPRESSUREMERCURY","HIGHPRESSURESODIUM","METALHALIDE","TUNGSTENFILAMENT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcLampTypeEnum::IfcLampTypeEnum IfcLampTypeEnum::FromString(const std::string& s) { + if(s=="COMPACTFLUORESCENT" ) return IfcLampTypeEnum::COMPACTFLUORESCENT; + if(s=="FLUORESCENT" ) return IfcLampTypeEnum::FLUORESCENT; + if(s=="HIGHPRESSUREMERCURY") return IfcLampTypeEnum::HIGHPRESSUREMERCURY; + if(s=="HIGHPRESSURESODIUM" ) return IfcLampTypeEnum::HIGHPRESSURESODIUM; + if(s=="METALHALIDE" ) return IfcLampTypeEnum::METALHALIDE; + if(s=="TUNGSTENFILAMENT" ) return IfcLampTypeEnum::TUNGSTENFILAMENT; + if(s=="USERDEFINED" ) return IfcLampTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcLampTypeEnum::NOTDEFINED; + throw; +} std::string IfcLayerSetDirectionEnum::ToString(IfcLayerSetDirectionEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "AXIS1","AXIS2","AXIS3" }; return names[v]; } +IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcLayerSetDirectionEnum::FromString(const std::string& s) { + if(s=="AXIS1") return IfcLayerSetDirectionEnum::AXIS1; + if(s=="AXIS2") return IfcLayerSetDirectionEnum::AXIS2; + if(s=="AXIS3") return IfcLayerSetDirectionEnum::AXIS3; + throw; +} std::string IfcLightDistributionCurveEnum::ToString(IfcLightDistributionCurveEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "TYPE_A","TYPE_B","TYPE_C","NOTDEFINED" }; return names[v]; } +IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightDistributionCurveEnum::FromString(const std::string& s) { + if(s=="TYPE_A" ) return IfcLightDistributionCurveEnum::TYPE_A; + if(s=="TYPE_B" ) return IfcLightDistributionCurveEnum::TYPE_B; + if(s=="TYPE_C" ) return IfcLightDistributionCurveEnum::TYPE_C; + if(s=="NOTDEFINED") return IfcLightDistributionCurveEnum::NOTDEFINED; + throw; +} std::string IfcLightEmissionSourceEnum::ToString(IfcLightEmissionSourceEnum v) { - if (v < 0 || v >= 11) throw; + if ( v < 0 || v >= 11 ) throw; const char* names[] = { "COMPACTFLUORESCENT","FLUORESCENT","HIGHPRESSUREMERCURY","HIGHPRESSURESODIUM","LIGHTEMITTINGDIODE","LOWPRESSURESODIUM","LOWVOLTAGEHALOGEN","MAINVOLTAGEHALOGEN","METALHALIDE","TUNGSTENFILAMENT","NOTDEFINED" }; return names[v]; } +IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum IfcLightEmissionSourceEnum::FromString(const std::string& s) { + if(s=="COMPACTFLUORESCENT" ) return IfcLightEmissionSourceEnum::COMPACTFLUORESCENT; + if(s=="FLUORESCENT" ) return IfcLightEmissionSourceEnum::FLUORESCENT; + if(s=="HIGHPRESSUREMERCURY") return IfcLightEmissionSourceEnum::HIGHPRESSUREMERCURY; + if(s=="HIGHPRESSURESODIUM" ) return IfcLightEmissionSourceEnum::HIGHPRESSURESODIUM; + if(s=="LIGHTEMITTINGDIODE" ) return IfcLightEmissionSourceEnum::LIGHTEMITTINGDIODE; + if(s=="LOWPRESSURESODIUM" ) return IfcLightEmissionSourceEnum::LOWPRESSURESODIUM; + if(s=="LOWVOLTAGEHALOGEN" ) return IfcLightEmissionSourceEnum::LOWVOLTAGEHALOGEN; + if(s=="MAINVOLTAGEHALOGEN" ) return IfcLightEmissionSourceEnum::MAINVOLTAGEHALOGEN; + if(s=="METALHALIDE" ) return IfcLightEmissionSourceEnum::METALHALIDE; + if(s=="TUNGSTENFILAMENT" ) return IfcLightEmissionSourceEnum::TUNGSTENFILAMENT; + if(s=="NOTDEFINED" ) return IfcLightEmissionSourceEnum::NOTDEFINED; + throw; +} std::string IfcLightFixtureTypeEnum::ToString(IfcLightFixtureTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "POINTSOURCE","DIRECTIONSOURCE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureTypeEnum::FromString(const std::string& s) { + if(s=="POINTSOURCE" ) return IfcLightFixtureTypeEnum::POINTSOURCE; + if(s=="DIRECTIONSOURCE") return IfcLightFixtureTypeEnum::DIRECTIONSOURCE; + if(s=="USERDEFINED" ) return IfcLightFixtureTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcLightFixtureTypeEnum::NOTDEFINED; + throw; +} std::string IfcLoadGroupTypeEnum::ToString(IfcLoadGroupTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "LOAD_GROUP","LOAD_CASE","LOAD_COMBINATION_GROUP","LOAD_COMBINATION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcLoadGroupTypeEnum::FromString(const std::string& s) { + if(s=="LOAD_GROUP" ) return IfcLoadGroupTypeEnum::LOAD_GROUP; + if(s=="LOAD_CASE" ) return IfcLoadGroupTypeEnum::LOAD_CASE; + if(s=="LOAD_COMBINATION_GROUP") return IfcLoadGroupTypeEnum::LOAD_COMBINATION_GROUP; + if(s=="LOAD_COMBINATION" ) return IfcLoadGroupTypeEnum::LOAD_COMBINATION; + if(s=="USERDEFINED" ) return IfcLoadGroupTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcLoadGroupTypeEnum::NOTDEFINED; + throw; +} std::string IfcLogicalOperatorEnum::ToString(IfcLogicalOperatorEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "LOGICALAND","LOGICALOR" }; return names[v]; } +IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcLogicalOperatorEnum::FromString(const std::string& s) { + if(s=="LOGICALAND") return IfcLogicalOperatorEnum::LOGICALAND; + if(s=="LOGICALOR" ) return IfcLogicalOperatorEnum::LOGICALOR; + throw; +} std::string IfcMemberTypeEnum::ToString(IfcMemberTypeEnum v) { - if (v < 0 || v >= 14) throw; + if ( v < 0 || v >= 14 ) throw; const char* names[] = { "BRACE","CHORD","COLLAR","MEMBER","MULLION","PLATE","POST","PURLIN","RAFTER","STRINGER","STRUT","STUD","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberTypeEnum::FromString(const std::string& s) { + if(s=="BRACE" ) return IfcMemberTypeEnum::BRACE; + if(s=="CHORD" ) return IfcMemberTypeEnum::CHORD; + if(s=="COLLAR" ) return IfcMemberTypeEnum::COLLAR; + if(s=="MEMBER" ) return IfcMemberTypeEnum::MEMBER; + if(s=="MULLION" ) return IfcMemberTypeEnum::MULLION; + if(s=="PLATE" ) return IfcMemberTypeEnum::PLATE; + if(s=="POST" ) return IfcMemberTypeEnum::POST; + if(s=="PURLIN" ) return IfcMemberTypeEnum::PURLIN; + if(s=="RAFTER" ) return IfcMemberTypeEnum::RAFTER; + if(s=="STRINGER" ) return IfcMemberTypeEnum::STRINGER; + if(s=="STRUT" ) return IfcMemberTypeEnum::STRUT; + if(s=="STUD" ) return IfcMemberTypeEnum::STUD; + if(s=="USERDEFINED") return IfcMemberTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcMemberTypeEnum::NOTDEFINED; + throw; +} std::string IfcMotorConnectionTypeEnum::ToString(IfcMotorConnectionTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "BELTDRIVE","COUPLING","DIRECTDRIVE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionTypeEnum::FromString(const std::string& s) { + if(s=="BELTDRIVE" ) return IfcMotorConnectionTypeEnum::BELTDRIVE; + if(s=="COUPLING" ) return IfcMotorConnectionTypeEnum::COUPLING; + if(s=="DIRECTDRIVE") return IfcMotorConnectionTypeEnum::DIRECTDRIVE; + if(s=="USERDEFINED") return IfcMotorConnectionTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcMotorConnectionTypeEnum::NOTDEFINED; + throw; +} std::string IfcNullStyle::ToString(IfcNullStyle v) { - if (v < 0 || v >= 1) throw; + if ( v < 0 || v >= 1 ) throw; const char* names[] = { "IFC_NULL" }; return names[v]; } +IfcNullStyle::IfcNullStyle IfcNullStyle::FromString(const std::string& s) { + if(s=="IFC_NULL") return IfcNullStyle::IFC_NULL; + throw; +} std::string IfcObjectTypeEnum::ToString(IfcObjectTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "PRODUCT","PROCESS","CONTROL","RESOURCE","ACTOR","GROUP","PROJECT","NOTDEFINED" }; return names[v]; } +IfcObjectTypeEnum::IfcObjectTypeEnum IfcObjectTypeEnum::FromString(const std::string& s) { + if(s=="PRODUCT" ) return IfcObjectTypeEnum::PRODUCT; + if(s=="PROCESS" ) return IfcObjectTypeEnum::PROCESS; + if(s=="CONTROL" ) return IfcObjectTypeEnum::CONTROL; + if(s=="RESOURCE" ) return IfcObjectTypeEnum::RESOURCE; + if(s=="ACTOR" ) return IfcObjectTypeEnum::ACTOR; + if(s=="GROUP" ) return IfcObjectTypeEnum::GROUP; + if(s=="PROJECT" ) return IfcObjectTypeEnum::PROJECT; + if(s=="NOTDEFINED") return IfcObjectTypeEnum::NOTDEFINED; + throw; +} std::string IfcObjectiveEnum::ToString(IfcObjectiveEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "CODECOMPLIANCE","DESIGNINTENT","HEALTHANDSAFETY","REQUIREMENT","SPECIFICATION","TRIGGERCONDITION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcObjectiveEnum::IfcObjectiveEnum IfcObjectiveEnum::FromString(const std::string& s) { + if(s=="CODECOMPLIANCE" ) return IfcObjectiveEnum::CODECOMPLIANCE; + if(s=="DESIGNINTENT" ) return IfcObjectiveEnum::DESIGNINTENT; + if(s=="HEALTHANDSAFETY" ) return IfcObjectiveEnum::HEALTHANDSAFETY; + if(s=="REQUIREMENT" ) return IfcObjectiveEnum::REQUIREMENT; + if(s=="SPECIFICATION" ) return IfcObjectiveEnum::SPECIFICATION; + if(s=="TRIGGERCONDITION") return IfcObjectiveEnum::TRIGGERCONDITION; + if(s=="USERDEFINED" ) return IfcObjectiveEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcObjectiveEnum::NOTDEFINED; + throw; +} std::string IfcOccupantTypeEnum::ToString(IfcOccupantTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "ASSIGNEE","ASSIGNOR","LESSEE","LESSOR","LETTINGAGENT","OWNER","TENANT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupantTypeEnum::FromString(const std::string& s) { + if(s=="ASSIGNEE" ) return IfcOccupantTypeEnum::ASSIGNEE; + if(s=="ASSIGNOR" ) return IfcOccupantTypeEnum::ASSIGNOR; + if(s=="LESSEE" ) return IfcOccupantTypeEnum::LESSEE; + if(s=="LESSOR" ) return IfcOccupantTypeEnum::LESSOR; + if(s=="LETTINGAGENT") return IfcOccupantTypeEnum::LETTINGAGENT; + if(s=="OWNER" ) return IfcOccupantTypeEnum::OWNER; + if(s=="TENANT" ) return IfcOccupantTypeEnum::TENANT; + if(s=="USERDEFINED" ) return IfcOccupantTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcOccupantTypeEnum::NOTDEFINED; + throw; +} std::string IfcOutletTypeEnum::ToString(IfcOutletTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "AUDIOVISUALOUTLET","COMMUNICATIONSOUTLET","POWEROUTLET","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletTypeEnum::FromString(const std::string& s) { + if(s=="AUDIOVISUALOUTLET" ) return IfcOutletTypeEnum::AUDIOVISUALOUTLET; + if(s=="COMMUNICATIONSOUTLET") return IfcOutletTypeEnum::COMMUNICATIONSOUTLET; + if(s=="POWEROUTLET" ) return IfcOutletTypeEnum::POWEROUTLET; + if(s=="USERDEFINED" ) return IfcOutletTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcOutletTypeEnum::NOTDEFINED; + throw; +} std::string IfcPermeableCoveringOperationEnum::ToString(IfcPermeableCoveringOperationEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "GRILL","LOUVER","SCREEN","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringOperationEnum::FromString(const std::string& s) { + if(s=="GRILL" ) return IfcPermeableCoveringOperationEnum::GRILL; + if(s=="LOUVER" ) return IfcPermeableCoveringOperationEnum::LOUVER; + if(s=="SCREEN" ) return IfcPermeableCoveringOperationEnum::SCREEN; + if(s=="USERDEFINED") return IfcPermeableCoveringOperationEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPermeableCoveringOperationEnum::NOTDEFINED; + throw; +} std::string IfcPhysicalOrVirtualEnum::ToString(IfcPhysicalOrVirtualEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "PHYSICAL","VIRTUAL","NOTDEFINED" }; return names[v]; } +IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum IfcPhysicalOrVirtualEnum::FromString(const std::string& s) { + if(s=="PHYSICAL" ) return IfcPhysicalOrVirtualEnum::PHYSICAL; + if(s=="VIRTUAL" ) return IfcPhysicalOrVirtualEnum::VIRTUAL; + if(s=="NOTDEFINED") return IfcPhysicalOrVirtualEnum::NOTDEFINED; + throw; +} std::string IfcPileConstructionEnum::ToString(IfcPileConstructionEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "CAST_IN_PLACE","COMPOSITE","PRECAST_CONCRETE","PREFAB_STEEL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPileConstructionEnum::IfcPileConstructionEnum IfcPileConstructionEnum::FromString(const std::string& s) { + if(s=="CAST_IN_PLACE" ) return IfcPileConstructionEnum::CAST_IN_PLACE; + if(s=="COMPOSITE" ) return IfcPileConstructionEnum::COMPOSITE; + if(s=="PRECAST_CONCRETE") return IfcPileConstructionEnum::PRECAST_CONCRETE; + if(s=="PREFAB_STEEL" ) return IfcPileConstructionEnum::PREFAB_STEEL; + if(s=="USERDEFINED" ) return IfcPileConstructionEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPileConstructionEnum::NOTDEFINED; + throw; +} std::string IfcPileTypeEnum::ToString(IfcPileTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "COHESION","FRICTION","SUPPORT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPileTypeEnum::IfcPileTypeEnum IfcPileTypeEnum::FromString(const std::string& s) { + if(s=="COHESION" ) return IfcPileTypeEnum::COHESION; + if(s=="FRICTION" ) return IfcPileTypeEnum::FRICTION; + if(s=="SUPPORT" ) return IfcPileTypeEnum::SUPPORT; + if(s=="USERDEFINED") return IfcPileTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPileTypeEnum::NOTDEFINED; + throw; +} std::string IfcPipeFittingTypeEnum::ToString(IfcPipeFittingTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "BEND","CONNECTOR","ENTRY","EXIT","JUNCTION","OBSTRUCTION","TRANSITION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingTypeEnum::FromString(const std::string& s) { + if(s=="BEND" ) return IfcPipeFittingTypeEnum::BEND; + if(s=="CONNECTOR" ) return IfcPipeFittingTypeEnum::CONNECTOR; + if(s=="ENTRY" ) return IfcPipeFittingTypeEnum::ENTRY; + if(s=="EXIT" ) return IfcPipeFittingTypeEnum::EXIT; + if(s=="JUNCTION" ) return IfcPipeFittingTypeEnum::JUNCTION; + if(s=="OBSTRUCTION") return IfcPipeFittingTypeEnum::OBSTRUCTION; + if(s=="TRANSITION" ) return IfcPipeFittingTypeEnum::TRANSITION; + if(s=="USERDEFINED") return IfcPipeFittingTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPipeFittingTypeEnum::NOTDEFINED; + throw; +} std::string IfcPipeSegmentTypeEnum::ToString(IfcPipeSegmentTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "FLEXIBLESEGMENT","RIGIDSEGMENT","GUTTER","SPOOL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentTypeEnum::FromString(const std::string& s) { + if(s=="FLEXIBLESEGMENT") return IfcPipeSegmentTypeEnum::FLEXIBLESEGMENT; + if(s=="RIGIDSEGMENT" ) return IfcPipeSegmentTypeEnum::RIGIDSEGMENT; + if(s=="GUTTER" ) return IfcPipeSegmentTypeEnum::GUTTER; + if(s=="SPOOL" ) return IfcPipeSegmentTypeEnum::SPOOL; + if(s=="USERDEFINED" ) return IfcPipeSegmentTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPipeSegmentTypeEnum::NOTDEFINED; + throw; +} std::string IfcPlateTypeEnum::ToString(IfcPlateTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "CURTAIN_PANEL","SHEET","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateTypeEnum::FromString(const std::string& s) { + if(s=="CURTAIN_PANEL") return IfcPlateTypeEnum::CURTAIN_PANEL; + if(s=="SHEET" ) return IfcPlateTypeEnum::SHEET; + if(s=="USERDEFINED" ) return IfcPlateTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPlateTypeEnum::NOTDEFINED; + throw; +} std::string IfcProcedureTypeEnum::ToString(IfcProcedureTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "ADVICE_CAUTION","ADVICE_NOTE","ADVICE_WARNING","CALIBRATION","DIAGNOSTIC","SHUTDOWN","STARTUP","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedureTypeEnum::FromString(const std::string& s) { + if(s=="ADVICE_CAUTION") return IfcProcedureTypeEnum::ADVICE_CAUTION; + if(s=="ADVICE_NOTE" ) return IfcProcedureTypeEnum::ADVICE_NOTE; + if(s=="ADVICE_WARNING") return IfcProcedureTypeEnum::ADVICE_WARNING; + if(s=="CALIBRATION" ) return IfcProcedureTypeEnum::CALIBRATION; + if(s=="DIAGNOSTIC" ) return IfcProcedureTypeEnum::DIAGNOSTIC; + if(s=="SHUTDOWN" ) return IfcProcedureTypeEnum::SHUTDOWN; + if(s=="STARTUP" ) return IfcProcedureTypeEnum::STARTUP; + if(s=="USERDEFINED" ) return IfcProcedureTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcProcedureTypeEnum::NOTDEFINED; + throw; +} std::string IfcProfileTypeEnum::ToString(IfcProfileTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "CURVE","AREA" }; return names[v]; } +IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileTypeEnum::FromString(const std::string& s) { + if(s=="CURVE") return IfcProfileTypeEnum::CURVE; + if(s=="AREA" ) return IfcProfileTypeEnum::AREA; + throw; +} std::string IfcProjectOrderRecordTypeEnum::ToString(IfcProjectOrderRecordTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "CHANGE","MAINTENANCE","MOVE","PURCHASE","WORK","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecordTypeEnum::FromString(const std::string& s) { + if(s=="CHANGE" ) return IfcProjectOrderRecordTypeEnum::CHANGE; + if(s=="MAINTENANCE") return IfcProjectOrderRecordTypeEnum::MAINTENANCE; + if(s=="MOVE" ) return IfcProjectOrderRecordTypeEnum::MOVE; + if(s=="PURCHASE" ) return IfcProjectOrderRecordTypeEnum::PURCHASE; + if(s=="WORK" ) return IfcProjectOrderRecordTypeEnum::WORK; + if(s=="USERDEFINED") return IfcProjectOrderRecordTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcProjectOrderRecordTypeEnum::NOTDEFINED; + throw; +} std::string IfcProjectOrderTypeEnum::ToString(IfcProjectOrderTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "CHANGEORDER","MAINTENANCEWORKORDER","MOVEORDER","PURCHASEORDER","WORKORDER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrderTypeEnum::FromString(const std::string& s) { + if(s=="CHANGEORDER" ) return IfcProjectOrderTypeEnum::CHANGEORDER; + if(s=="MAINTENANCEWORKORDER") return IfcProjectOrderTypeEnum::MAINTENANCEWORKORDER; + if(s=="MOVEORDER" ) return IfcProjectOrderTypeEnum::MOVEORDER; + if(s=="PURCHASEORDER" ) return IfcProjectOrderTypeEnum::PURCHASEORDER; + if(s=="WORKORDER" ) return IfcProjectOrderTypeEnum::WORKORDER; + if(s=="USERDEFINED" ) return IfcProjectOrderTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcProjectOrderTypeEnum::NOTDEFINED; + throw; +} std::string IfcProjectedOrTrueLengthEnum::ToString(IfcProjectedOrTrueLengthEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "PROJECTED_LENGTH","TRUE_LENGTH" }; return names[v]; } +IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcProjectedOrTrueLengthEnum::FromString(const std::string& s) { + if(s=="PROJECTED_LENGTH") return IfcProjectedOrTrueLengthEnum::PROJECTED_LENGTH; + if(s=="TRUE_LENGTH" ) return IfcProjectedOrTrueLengthEnum::TRUE_LENGTH; + throw; +} std::string IfcPropertySourceEnum::ToString(IfcPropertySourceEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "DESIGN","DESIGNMAXIMUM","DESIGNMINIMUM","SIMULATED","ASBUILT","COMMISSIONING","MEASURED","USERDEFINED","NOTKNOWN" }; return names[v]; } +IfcPropertySourceEnum::IfcPropertySourceEnum IfcPropertySourceEnum::FromString(const std::string& s) { + if(s=="DESIGN" ) return IfcPropertySourceEnum::DESIGN; + if(s=="DESIGNMAXIMUM") return IfcPropertySourceEnum::DESIGNMAXIMUM; + if(s=="DESIGNMINIMUM") return IfcPropertySourceEnum::DESIGNMINIMUM; + if(s=="SIMULATED" ) return IfcPropertySourceEnum::SIMULATED; + if(s=="ASBUILT" ) return IfcPropertySourceEnum::ASBUILT; + if(s=="COMMISSIONING") return IfcPropertySourceEnum::COMMISSIONING; + if(s=="MEASURED" ) return IfcPropertySourceEnum::MEASURED; + if(s=="USERDEFINED" ) return IfcPropertySourceEnum::USERDEFINED; + if(s=="NOTKNOWN" ) return IfcPropertySourceEnum::NOTKNOWN; + throw; +} std::string IfcProtectiveDeviceTypeEnum::ToString(IfcProtectiveDeviceTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "FUSEDISCONNECTOR","CIRCUITBREAKER","EARTHFAILUREDEVICE","RESIDUALCURRENTCIRCUITBREAKER","RESIDUALCURRENTSWITCH","VARISTOR","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceTypeEnum::FromString(const std::string& s) { + if(s=="FUSEDISCONNECTOR" ) return IfcProtectiveDeviceTypeEnum::FUSEDISCONNECTOR; + if(s=="CIRCUITBREAKER" ) return IfcProtectiveDeviceTypeEnum::CIRCUITBREAKER; + if(s=="EARTHFAILUREDEVICE" ) return IfcProtectiveDeviceTypeEnum::EARTHFAILUREDEVICE; + if(s=="RESIDUALCURRENTCIRCUITBREAKER") return IfcProtectiveDeviceTypeEnum::RESIDUALCURRENTCIRCUITBREAKER; + if(s=="RESIDUALCURRENTSWITCH" ) return IfcProtectiveDeviceTypeEnum::RESIDUALCURRENTSWITCH; + if(s=="VARISTOR" ) return IfcProtectiveDeviceTypeEnum::VARISTOR; + if(s=="USERDEFINED" ) return IfcProtectiveDeviceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcProtectiveDeviceTypeEnum::NOTDEFINED; + throw; +} std::string IfcPumpTypeEnum::ToString(IfcPumpTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "CIRCULATOR","ENDSUCTION","SPLITCASE","VERTICALINLINE","VERTICALTURBINE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpTypeEnum::FromString(const std::string& s) { + if(s=="CIRCULATOR" ) return IfcPumpTypeEnum::CIRCULATOR; + if(s=="ENDSUCTION" ) return IfcPumpTypeEnum::ENDSUCTION; + if(s=="SPLITCASE" ) return IfcPumpTypeEnum::SPLITCASE; + if(s=="VERTICALINLINE" ) return IfcPumpTypeEnum::VERTICALINLINE; + if(s=="VERTICALTURBINE") return IfcPumpTypeEnum::VERTICALTURBINE; + if(s=="USERDEFINED" ) return IfcPumpTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcPumpTypeEnum::NOTDEFINED; + throw; +} std::string IfcRailingTypeEnum::ToString(IfcRailingTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "HANDRAIL","GUARDRAIL","BALUSTRADE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingTypeEnum::FromString(const std::string& s) { + if(s=="HANDRAIL" ) return IfcRailingTypeEnum::HANDRAIL; + if(s=="GUARDRAIL" ) return IfcRailingTypeEnum::GUARDRAIL; + if(s=="BALUSTRADE" ) return IfcRailingTypeEnum::BALUSTRADE; + if(s=="USERDEFINED") return IfcRailingTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcRailingTypeEnum::NOTDEFINED; + throw; +} std::string IfcRampFlightTypeEnum::ToString(IfcRampFlightTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "STRAIGHT","SPIRAL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightTypeEnum::FromString(const std::string& s) { + if(s=="STRAIGHT" ) return IfcRampFlightTypeEnum::STRAIGHT; + if(s=="SPIRAL" ) return IfcRampFlightTypeEnum::SPIRAL; + if(s=="USERDEFINED") return IfcRampFlightTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcRampFlightTypeEnum::NOTDEFINED; + throw; +} std::string IfcRampTypeEnum::ToString(IfcRampTypeEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "STRAIGHT_RUN_RAMP","TWO_STRAIGHT_RUN_RAMP","QUARTER_TURN_RAMP","TWO_QUARTER_TURN_RAMP","HALF_TURN_RAMP","SPIRAL_RAMP","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcRampTypeEnum::IfcRampTypeEnum IfcRampTypeEnum::FromString(const std::string& s) { + if(s=="STRAIGHT_RUN_RAMP" ) return IfcRampTypeEnum::STRAIGHT_RUN_RAMP; + if(s=="TWO_STRAIGHT_RUN_RAMP") return IfcRampTypeEnum::TWO_STRAIGHT_RUN_RAMP; + if(s=="QUARTER_TURN_RAMP" ) return IfcRampTypeEnum::QUARTER_TURN_RAMP; + if(s=="TWO_QUARTER_TURN_RAMP") return IfcRampTypeEnum::TWO_QUARTER_TURN_RAMP; + if(s=="HALF_TURN_RAMP" ) return IfcRampTypeEnum::HALF_TURN_RAMP; + if(s=="SPIRAL_RAMP" ) return IfcRampTypeEnum::SPIRAL_RAMP; + if(s=="USERDEFINED" ) return IfcRampTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcRampTypeEnum::NOTDEFINED; + throw; +} std::string IfcReflectanceMethodEnum::ToString(IfcReflectanceMethodEnum v) { - if (v < 0 || v >= 10) throw; + if ( v < 0 || v >= 10 ) throw; const char* names[] = { "BLINN","FLAT","GLASS","MATT","METAL","MIRROR","PHONG","PLASTIC","STRAUSS","NOTDEFINED" }; return names[v]; } +IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcReflectanceMethodEnum::FromString(const std::string& s) { + if(s=="BLINN" ) return IfcReflectanceMethodEnum::BLINN; + if(s=="FLAT" ) return IfcReflectanceMethodEnum::FLAT; + if(s=="GLASS" ) return IfcReflectanceMethodEnum::GLASS; + if(s=="MATT" ) return IfcReflectanceMethodEnum::MATT; + if(s=="METAL" ) return IfcReflectanceMethodEnum::METAL; + if(s=="MIRROR" ) return IfcReflectanceMethodEnum::MIRROR; + if(s=="PHONG" ) return IfcReflectanceMethodEnum::PHONG; + if(s=="PLASTIC" ) return IfcReflectanceMethodEnum::PLASTIC; + if(s=="STRAUSS" ) return IfcReflectanceMethodEnum::STRAUSS; + if(s=="NOTDEFINED") return IfcReflectanceMethodEnum::NOTDEFINED; + throw; +} std::string IfcReinforcingBarRoleEnum::ToString(IfcReinforcingBarRoleEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "MAIN","SHEAR","LIGATURE","STUD","PUNCHING","EDGE","RING","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcReinforcingBarRoleEnum::FromString(const std::string& s) { + if(s=="MAIN" ) return IfcReinforcingBarRoleEnum::MAIN; + if(s=="SHEAR" ) return IfcReinforcingBarRoleEnum::SHEAR; + if(s=="LIGATURE" ) return IfcReinforcingBarRoleEnum::LIGATURE; + if(s=="STUD" ) return IfcReinforcingBarRoleEnum::STUD; + if(s=="PUNCHING" ) return IfcReinforcingBarRoleEnum::PUNCHING; + if(s=="EDGE" ) return IfcReinforcingBarRoleEnum::EDGE; + if(s=="RING" ) return IfcReinforcingBarRoleEnum::RING; + if(s=="USERDEFINED") return IfcReinforcingBarRoleEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcReinforcingBarRoleEnum::NOTDEFINED; + throw; +} std::string IfcReinforcingBarSurfaceEnum::ToString(IfcReinforcingBarSurfaceEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "PLAIN","TEXTURED" }; return names[v]; } +IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBarSurfaceEnum::FromString(const std::string& s) { + if(s=="PLAIN" ) return IfcReinforcingBarSurfaceEnum::PLAIN; + if(s=="TEXTURED") return IfcReinforcingBarSurfaceEnum::TEXTURED; + throw; +} std::string IfcResourceConsumptionEnum::ToString(IfcResourceConsumptionEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "CONSUMED","PARTIALLYCONSUMED","NOTCONSUMED","OCCUPIED","PARTIALLYOCCUPIED","NOTOCCUPIED","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcResourceConsumptionEnum::IfcResourceConsumptionEnum IfcResourceConsumptionEnum::FromString(const std::string& s) { + if(s=="CONSUMED" ) return IfcResourceConsumptionEnum::CONSUMED; + if(s=="PARTIALLYCONSUMED") return IfcResourceConsumptionEnum::PARTIALLYCONSUMED; + if(s=="NOTCONSUMED" ) return IfcResourceConsumptionEnum::NOTCONSUMED; + if(s=="OCCUPIED" ) return IfcResourceConsumptionEnum::OCCUPIED; + if(s=="PARTIALLYOCCUPIED") return IfcResourceConsumptionEnum::PARTIALLYOCCUPIED; + if(s=="NOTOCCUPIED" ) return IfcResourceConsumptionEnum::NOTOCCUPIED; + if(s=="USERDEFINED" ) return IfcResourceConsumptionEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcResourceConsumptionEnum::NOTDEFINED; + throw; +} std::string IfcRibPlateDirectionEnum::ToString(IfcRibPlateDirectionEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "DIRECTION_X","DIRECTION_Y" }; return names[v]; } +IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateDirectionEnum::FromString(const std::string& s) { + if(s=="DIRECTION_X") return IfcRibPlateDirectionEnum::DIRECTION_X; + if(s=="DIRECTION_Y") return IfcRibPlateDirectionEnum::DIRECTION_Y; + throw; +} std::string IfcRoleEnum::ToString(IfcRoleEnum v) { - if (v < 0 || v >= 23) throw; + if ( v < 0 || v >= 23 ) throw; const char* names[] = { "SUPPLIER","MANUFACTURER","CONTRACTOR","SUBCONTRACTOR","ARCHITECT","STRUCTURALENGINEER","COSTENGINEER","CLIENT","BUILDINGOWNER","BUILDINGOPERATOR","MECHANICALENGINEER","ELECTRICALENGINEER","PROJECTMANAGER","FACILITIESMANAGER","CIVILENGINEER","COMISSIONINGENGINEER","ENGINEER","OWNER","CONSULTANT","CONSTRUCTIONMANAGER","FIELDCONSTRUCTIONMANAGER","RESELLER","USERDEFINED" }; return names[v]; } +IfcRoleEnum::IfcRoleEnum IfcRoleEnum::FromString(const std::string& s) { + if(s=="SUPPLIER" ) return IfcRoleEnum::SUPPLIER; + if(s=="MANUFACTURER" ) return IfcRoleEnum::MANUFACTURER; + if(s=="CONTRACTOR" ) return IfcRoleEnum::CONTRACTOR; + if(s=="SUBCONTRACTOR" ) return IfcRoleEnum::SUBCONTRACTOR; + if(s=="ARCHITECT" ) return IfcRoleEnum::ARCHITECT; + if(s=="STRUCTURALENGINEER" ) return IfcRoleEnum::STRUCTURALENGINEER; + if(s=="COSTENGINEER" ) return IfcRoleEnum::COSTENGINEER; + if(s=="CLIENT" ) return IfcRoleEnum::CLIENT; + if(s=="BUILDINGOWNER" ) return IfcRoleEnum::BUILDINGOWNER; + if(s=="BUILDINGOPERATOR" ) return IfcRoleEnum::BUILDINGOPERATOR; + if(s=="MECHANICALENGINEER" ) return IfcRoleEnum::MECHANICALENGINEER; + if(s=="ELECTRICALENGINEER" ) return IfcRoleEnum::ELECTRICALENGINEER; + if(s=="PROJECTMANAGER" ) return IfcRoleEnum::PROJECTMANAGER; + if(s=="FACILITIESMANAGER" ) return IfcRoleEnum::FACILITIESMANAGER; + if(s=="CIVILENGINEER" ) return IfcRoleEnum::CIVILENGINEER; + if(s=="COMISSIONINGENGINEER" ) return IfcRoleEnum::COMISSIONINGENGINEER; + if(s=="ENGINEER" ) return IfcRoleEnum::ENGINEER; + if(s=="OWNER" ) return IfcRoleEnum::OWNER; + if(s=="CONSULTANT" ) return IfcRoleEnum::CONSULTANT; + if(s=="CONSTRUCTIONMANAGER" ) return IfcRoleEnum::CONSTRUCTIONMANAGER; + if(s=="FIELDCONSTRUCTIONMANAGER") return IfcRoleEnum::FIELDCONSTRUCTIONMANAGER; + if(s=="RESELLER" ) return IfcRoleEnum::RESELLER; + if(s=="USERDEFINED" ) return IfcRoleEnum::USERDEFINED; + throw; +} std::string IfcRoofTypeEnum::ToString(IfcRoofTypeEnum v) { - if (v < 0 || v >= 14) throw; + if ( v < 0 || v >= 14 ) throw; const char* names[] = { "FLAT_ROOF","SHED_ROOF","GABLE_ROOF","HIP_ROOF","HIPPED_GABLE_ROOF","GAMBREL_ROOF","MANSARD_ROOF","BARREL_ROOF","RAINBOW_ROOF","BUTTERFLY_ROOF","PAVILION_ROOF","DOME_ROOF","FREEFORM","NOTDEFINED" }; return names[v]; } +IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoofTypeEnum::FromString(const std::string& s) { + if(s=="FLAT_ROOF" ) return IfcRoofTypeEnum::FLAT_ROOF; + if(s=="SHED_ROOF" ) return IfcRoofTypeEnum::SHED_ROOF; + if(s=="GABLE_ROOF" ) return IfcRoofTypeEnum::GABLE_ROOF; + if(s=="HIP_ROOF" ) return IfcRoofTypeEnum::HIP_ROOF; + if(s=="HIPPED_GABLE_ROOF") return IfcRoofTypeEnum::HIPPED_GABLE_ROOF; + if(s=="GAMBREL_ROOF" ) return IfcRoofTypeEnum::GAMBREL_ROOF; + if(s=="MANSARD_ROOF" ) return IfcRoofTypeEnum::MANSARD_ROOF; + if(s=="BARREL_ROOF" ) return IfcRoofTypeEnum::BARREL_ROOF; + if(s=="RAINBOW_ROOF" ) return IfcRoofTypeEnum::RAINBOW_ROOF; + if(s=="BUTTERFLY_ROOF" ) return IfcRoofTypeEnum::BUTTERFLY_ROOF; + if(s=="PAVILION_ROOF" ) return IfcRoofTypeEnum::PAVILION_ROOF; + if(s=="DOME_ROOF" ) return IfcRoofTypeEnum::DOME_ROOF; + if(s=="FREEFORM" ) return IfcRoofTypeEnum::FREEFORM; + if(s=="NOTDEFINED" ) return IfcRoofTypeEnum::NOTDEFINED; + throw; +} std::string IfcSIPrefix::ToString(IfcSIPrefix v) { - if (v < 0 || v >= 16) throw; + if ( v < 0 || v >= 16 ) throw; const char* names[] = { "EXA","PETA","TERA","GIGA","MEGA","KILO","HECTO","DECA","DECI","CENTI","MILLI","MICRO","NANO","PICO","FEMTO","ATTO" }; return names[v]; } +IfcSIPrefix::IfcSIPrefix IfcSIPrefix::FromString(const std::string& s) { + if(s=="EXA" ) return IfcSIPrefix::EXA; + if(s=="PETA" ) return IfcSIPrefix::PETA; + if(s=="TERA" ) return IfcSIPrefix::TERA; + if(s=="GIGA" ) return IfcSIPrefix::GIGA; + if(s=="MEGA" ) return IfcSIPrefix::MEGA; + if(s=="KILO" ) return IfcSIPrefix::KILO; + if(s=="HECTO") return IfcSIPrefix::HECTO; + if(s=="DECA" ) return IfcSIPrefix::DECA; + if(s=="DECI" ) return IfcSIPrefix::DECI; + if(s=="CENTI") return IfcSIPrefix::CENTI; + if(s=="MILLI") return IfcSIPrefix::MILLI; + if(s=="MICRO") return IfcSIPrefix::MICRO; + if(s=="NANO" ) return IfcSIPrefix::NANO; + if(s=="PICO" ) return IfcSIPrefix::PICO; + if(s=="FEMTO") return IfcSIPrefix::FEMTO; + if(s=="ATTO" ) return IfcSIPrefix::ATTO; + throw; +} std::string IfcSIUnitName::ToString(IfcSIUnitName v) { - if (v < 0 || v >= 30) throw; + if ( v < 0 || v >= 30 ) throw; const char* names[] = { "AMPERE","BECQUEREL","CANDELA","COULOMB","CUBIC_METRE","DEGREE_CELSIUS","FARAD","GRAM","GRAY","HENRY","HERTZ","JOULE","KELVIN","LUMEN","LUX","METRE","MOLE","NEWTON","OHM","PASCAL","RADIAN","SECOND","SIEMENS","SIEVERT","SQUARE_METRE","STERADIAN","TESLA","VOLT","WATT","WEBER" }; return names[v]; } +IfcSIUnitName::IfcSIUnitName IfcSIUnitName::FromString(const std::string& s) { + if(s=="AMPERE" ) return IfcSIUnitName::AMPERE; + if(s=="BECQUEREL" ) return IfcSIUnitName::BECQUEREL; + if(s=="CANDELA" ) return IfcSIUnitName::CANDELA; + if(s=="COULOMB" ) return IfcSIUnitName::COULOMB; + if(s=="CUBIC_METRE" ) return IfcSIUnitName::CUBIC_METRE; + if(s=="DEGREE_CELSIUS") return IfcSIUnitName::DEGREE_CELSIUS; + if(s=="FARAD" ) return IfcSIUnitName::FARAD; + if(s=="GRAM" ) return IfcSIUnitName::GRAM; + if(s=="GRAY" ) return IfcSIUnitName::GRAY; + if(s=="HENRY" ) return IfcSIUnitName::HENRY; + if(s=="HERTZ" ) return IfcSIUnitName::HERTZ; + if(s=="JOULE" ) return IfcSIUnitName::JOULE; + if(s=="KELVIN" ) return IfcSIUnitName::KELVIN; + if(s=="LUMEN" ) return IfcSIUnitName::LUMEN; + if(s=="LUX" ) return IfcSIUnitName::LUX; + if(s=="METRE" ) return IfcSIUnitName::METRE; + if(s=="MOLE" ) return IfcSIUnitName::MOLE; + if(s=="NEWTON" ) return IfcSIUnitName::NEWTON; + if(s=="OHM" ) return IfcSIUnitName::OHM; + if(s=="PASCAL" ) return IfcSIUnitName::PASCAL; + if(s=="RADIAN" ) return IfcSIUnitName::RADIAN; + if(s=="SECOND" ) return IfcSIUnitName::SECOND; + if(s=="SIEMENS" ) return IfcSIUnitName::SIEMENS; + if(s=="SIEVERT" ) return IfcSIUnitName::SIEVERT; + if(s=="SQUARE_METRE" ) return IfcSIUnitName::SQUARE_METRE; + if(s=="STERADIAN" ) return IfcSIUnitName::STERADIAN; + if(s=="TESLA" ) return IfcSIUnitName::TESLA; + if(s=="VOLT" ) return IfcSIUnitName::VOLT; + if(s=="WATT" ) return IfcSIUnitName::WATT; + if(s=="WEBER" ) return IfcSIUnitName::WEBER; + throw; +} std::string IfcSanitaryTerminalTypeEnum::ToString(IfcSanitaryTerminalTypeEnum v) { - if (v < 0 || v >= 12) throw; + if ( v < 0 || v >= 12 ) throw; const char* names[] = { "BATH","BIDET","CISTERN","SHOWER","SINK","SANITARYFOUNTAIN","TOILETPAN","URINAL","WASHHANDBASIN","WCSEAT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalTypeEnum::FromString(const std::string& s) { + if(s=="BATH" ) return IfcSanitaryTerminalTypeEnum::BATH; + if(s=="BIDET" ) return IfcSanitaryTerminalTypeEnum::BIDET; + if(s=="CISTERN" ) return IfcSanitaryTerminalTypeEnum::CISTERN; + if(s=="SHOWER" ) return IfcSanitaryTerminalTypeEnum::SHOWER; + if(s=="SINK" ) return IfcSanitaryTerminalTypeEnum::SINK; + if(s=="SANITARYFOUNTAIN") return IfcSanitaryTerminalTypeEnum::SANITARYFOUNTAIN; + if(s=="TOILETPAN" ) return IfcSanitaryTerminalTypeEnum::TOILETPAN; + if(s=="URINAL" ) return IfcSanitaryTerminalTypeEnum::URINAL; + if(s=="WASHHANDBASIN" ) return IfcSanitaryTerminalTypeEnum::WASHHANDBASIN; + if(s=="WCSEAT" ) return IfcSanitaryTerminalTypeEnum::WCSEAT; + if(s=="USERDEFINED" ) return IfcSanitaryTerminalTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSanitaryTerminalTypeEnum::NOTDEFINED; + throw; +} std::string IfcSectionTypeEnum::ToString(IfcSectionTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "UNIFORM","TAPERED" }; return names[v]; } +IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionTypeEnum::FromString(const std::string& s) { + if(s=="UNIFORM") return IfcSectionTypeEnum::UNIFORM; + if(s=="TAPERED") return IfcSectionTypeEnum::TAPERED; + throw; +} std::string IfcSensorTypeEnum::ToString(IfcSensorTypeEnum v) { - if (v < 0 || v >= 15) throw; + if ( v < 0 || v >= 15 ) throw; const char* names[] = { "CO2SENSOR","FIRESENSOR","FLOWSENSOR","GASSENSOR","HEATSENSOR","HUMIDITYSENSOR","LIGHTSENSOR","MOISTURESENSOR","MOVEMENTSENSOR","PRESSURESENSOR","SMOKESENSOR","SOUNDSENSOR","TEMPERATURESENSOR","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorTypeEnum::FromString(const std::string& s) { + if(s=="CO2SENSOR" ) return IfcSensorTypeEnum::CO2SENSOR; + if(s=="FIRESENSOR" ) return IfcSensorTypeEnum::FIRESENSOR; + if(s=="FLOWSENSOR" ) return IfcSensorTypeEnum::FLOWSENSOR; + if(s=="GASSENSOR" ) return IfcSensorTypeEnum::GASSENSOR; + if(s=="HEATSENSOR" ) return IfcSensorTypeEnum::HEATSENSOR; + if(s=="HUMIDITYSENSOR" ) return IfcSensorTypeEnum::HUMIDITYSENSOR; + if(s=="LIGHTSENSOR" ) return IfcSensorTypeEnum::LIGHTSENSOR; + if(s=="MOISTURESENSOR" ) return IfcSensorTypeEnum::MOISTURESENSOR; + if(s=="MOVEMENTSENSOR" ) return IfcSensorTypeEnum::MOVEMENTSENSOR; + if(s=="PRESSURESENSOR" ) return IfcSensorTypeEnum::PRESSURESENSOR; + if(s=="SMOKESENSOR" ) return IfcSensorTypeEnum::SMOKESENSOR; + if(s=="SOUNDSENSOR" ) return IfcSensorTypeEnum::SOUNDSENSOR; + if(s=="TEMPERATURESENSOR") return IfcSensorTypeEnum::TEMPERATURESENSOR; + if(s=="USERDEFINED" ) return IfcSensorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSensorTypeEnum::NOTDEFINED; + throw; +} std::string IfcSequenceEnum::ToString(IfcSequenceEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "START_START","START_FINISH","FINISH_START","FINISH_FINISH","NOTDEFINED" }; return names[v]; } +IfcSequenceEnum::IfcSequenceEnum IfcSequenceEnum::FromString(const std::string& s) { + if(s=="START_START" ) return IfcSequenceEnum::START_START; + if(s=="START_FINISH" ) return IfcSequenceEnum::START_FINISH; + if(s=="FINISH_START" ) return IfcSequenceEnum::FINISH_START; + if(s=="FINISH_FINISH") return IfcSequenceEnum::FINISH_FINISH; + if(s=="NOTDEFINED" ) return IfcSequenceEnum::NOTDEFINED; + throw; +} std::string IfcServiceLifeFactorTypeEnum::ToString(IfcServiceLifeFactorTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "A_QUALITYOFCOMPONENTS","B_DESIGNLEVEL","C_WORKEXECUTIONLEVEL","D_INDOORENVIRONMENT","E_OUTDOORENVIRONMENT","F_INUSECONDITIONS","G_MAINTENANCELEVEL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactorTypeEnum::FromString(const std::string& s) { + if(s=="A_QUALITYOFCOMPONENTS") return IfcServiceLifeFactorTypeEnum::A_QUALITYOFCOMPONENTS; + if(s=="B_DESIGNLEVEL" ) return IfcServiceLifeFactorTypeEnum::B_DESIGNLEVEL; + if(s=="C_WORKEXECUTIONLEVEL" ) return IfcServiceLifeFactorTypeEnum::C_WORKEXECUTIONLEVEL; + if(s=="D_INDOORENVIRONMENT" ) return IfcServiceLifeFactorTypeEnum::D_INDOORENVIRONMENT; + if(s=="E_OUTDOORENVIRONMENT" ) return IfcServiceLifeFactorTypeEnum::E_OUTDOORENVIRONMENT; + if(s=="F_INUSECONDITIONS" ) return IfcServiceLifeFactorTypeEnum::F_INUSECONDITIONS; + if(s=="G_MAINTENANCELEVEL" ) return IfcServiceLifeFactorTypeEnum::G_MAINTENANCELEVEL; + if(s=="USERDEFINED" ) return IfcServiceLifeFactorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcServiceLifeFactorTypeEnum::NOTDEFINED; + throw; +} std::string IfcServiceLifeTypeEnum::ToString(IfcServiceLifeTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "ACTUALSERVICELIFE","EXPECTEDSERVICELIFE","OPTIMISTICREFERENCESERVICELIFE","PESSIMISTICREFERENCESERVICELIFE","REFERENCESERVICELIFE" }; return names[v]; } +IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLifeTypeEnum::FromString(const std::string& s) { + if(s=="ACTUALSERVICELIFE" ) return IfcServiceLifeTypeEnum::ACTUALSERVICELIFE; + if(s=="EXPECTEDSERVICELIFE" ) return IfcServiceLifeTypeEnum::EXPECTEDSERVICELIFE; + if(s=="OPTIMISTICREFERENCESERVICELIFE" ) return IfcServiceLifeTypeEnum::OPTIMISTICREFERENCESERVICELIFE; + if(s=="PESSIMISTICREFERENCESERVICELIFE") return IfcServiceLifeTypeEnum::PESSIMISTICREFERENCESERVICELIFE; + if(s=="REFERENCESERVICELIFE" ) return IfcServiceLifeTypeEnum::REFERENCESERVICELIFE; + throw; +} std::string IfcSlabTypeEnum::ToString(IfcSlabTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "FLOOR","ROOF","LANDING","BASESLAB","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabTypeEnum::FromString(const std::string& s) { + if(s=="FLOOR" ) return IfcSlabTypeEnum::FLOOR; + if(s=="ROOF" ) return IfcSlabTypeEnum::ROOF; + if(s=="LANDING" ) return IfcSlabTypeEnum::LANDING; + if(s=="BASESLAB" ) return IfcSlabTypeEnum::BASESLAB; + if(s=="USERDEFINED") return IfcSlabTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSlabTypeEnum::NOTDEFINED; + throw; +} std::string IfcSoundScaleEnum::ToString(IfcSoundScaleEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "DBA","DBB","DBC","NC","NR","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSoundScaleEnum::IfcSoundScaleEnum IfcSoundScaleEnum::FromString(const std::string& s) { + if(s=="DBA" ) return IfcSoundScaleEnum::DBA; + if(s=="DBB" ) return IfcSoundScaleEnum::DBB; + if(s=="DBC" ) return IfcSoundScaleEnum::DBC; + if(s=="NC" ) return IfcSoundScaleEnum::NC; + if(s=="NR" ) return IfcSoundScaleEnum::NR; + if(s=="USERDEFINED") return IfcSoundScaleEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSoundScaleEnum::NOTDEFINED; + throw; +} std::string IfcSpaceHeaterTypeEnum::ToString(IfcSpaceHeaterTypeEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "SECTIONALRADIATOR","PANELRADIATOR","TUBULARRADIATOR","CONVECTOR","BASEBOARDHEATER","FINNEDTUBEUNIT","UNITHEATER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterTypeEnum::FromString(const std::string& s) { + if(s=="SECTIONALRADIATOR") return IfcSpaceHeaterTypeEnum::SECTIONALRADIATOR; + if(s=="PANELRADIATOR" ) return IfcSpaceHeaterTypeEnum::PANELRADIATOR; + if(s=="TUBULARRADIATOR" ) return IfcSpaceHeaterTypeEnum::TUBULARRADIATOR; + if(s=="CONVECTOR" ) return IfcSpaceHeaterTypeEnum::CONVECTOR; + if(s=="BASEBOARDHEATER" ) return IfcSpaceHeaterTypeEnum::BASEBOARDHEATER; + if(s=="FINNEDTUBEUNIT" ) return IfcSpaceHeaterTypeEnum::FINNEDTUBEUNIT; + if(s=="UNITHEATER" ) return IfcSpaceHeaterTypeEnum::UNITHEATER; + if(s=="USERDEFINED" ) return IfcSpaceHeaterTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSpaceHeaterTypeEnum::NOTDEFINED; + throw; +} std::string IfcSpaceTypeEnum::ToString(IfcSpaceTypeEnum v) { - if (v < 0 || v >= 2) throw; + if ( v < 0 || v >= 2 ) throw; const char* names[] = { "USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceTypeEnum::FromString(const std::string& s) { + if(s=="USERDEFINED") return IfcSpaceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSpaceTypeEnum::NOTDEFINED; + throw; +} std::string IfcStackTerminalTypeEnum::ToString(IfcStackTerminalTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "BIRDCAGE","COWL","RAINWATERHOPPER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalTypeEnum::FromString(const std::string& s) { + if(s=="BIRDCAGE" ) return IfcStackTerminalTypeEnum::BIRDCAGE; + if(s=="COWL" ) return IfcStackTerminalTypeEnum::COWL; + if(s=="RAINWATERHOPPER") return IfcStackTerminalTypeEnum::RAINWATERHOPPER; + if(s=="USERDEFINED" ) return IfcStackTerminalTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcStackTerminalTypeEnum::NOTDEFINED; + throw; +} std::string IfcStairFlightTypeEnum::ToString(IfcStairFlightTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "STRAIGHT","WINDER","SPIRAL","CURVED","FREEFORM","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightTypeEnum::FromString(const std::string& s) { + if(s=="STRAIGHT" ) return IfcStairFlightTypeEnum::STRAIGHT; + if(s=="WINDER" ) return IfcStairFlightTypeEnum::WINDER; + if(s=="SPIRAL" ) return IfcStairFlightTypeEnum::SPIRAL; + if(s=="CURVED" ) return IfcStairFlightTypeEnum::CURVED; + if(s=="FREEFORM" ) return IfcStairFlightTypeEnum::FREEFORM; + if(s=="USERDEFINED") return IfcStairFlightTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcStairFlightTypeEnum::NOTDEFINED; + throw; +} std::string IfcStairTypeEnum::ToString(IfcStairTypeEnum v) { - if (v < 0 || v >= 16) throw; + if ( v < 0 || v >= 16 ) throw; const char* names[] = { "STRAIGHT_RUN_STAIR","TWO_STRAIGHT_RUN_STAIR","QUARTER_WINDING_STAIR","QUARTER_TURN_STAIR","HALF_WINDING_STAIR","HALF_TURN_STAIR","TWO_QUARTER_WINDING_STAIR","TWO_QUARTER_TURN_STAIR","THREE_QUARTER_WINDING_STAIR","THREE_QUARTER_TURN_STAIR","SPIRAL_STAIR","DOUBLE_RETURN_STAIR","CURVED_RUN_STAIR","TWO_CURVED_RUN_STAIR","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcStairTypeEnum::IfcStairTypeEnum IfcStairTypeEnum::FromString(const std::string& s) { + if(s=="STRAIGHT_RUN_STAIR" ) return IfcStairTypeEnum::STRAIGHT_RUN_STAIR; + if(s=="TWO_STRAIGHT_RUN_STAIR" ) return IfcStairTypeEnum::TWO_STRAIGHT_RUN_STAIR; + if(s=="QUARTER_WINDING_STAIR" ) return IfcStairTypeEnum::QUARTER_WINDING_STAIR; + if(s=="QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::QUARTER_TURN_STAIR; + if(s=="HALF_WINDING_STAIR" ) return IfcStairTypeEnum::HALF_WINDING_STAIR; + if(s=="HALF_TURN_STAIR" ) return IfcStairTypeEnum::HALF_TURN_STAIR; + if(s=="TWO_QUARTER_WINDING_STAIR" ) return IfcStairTypeEnum::TWO_QUARTER_WINDING_STAIR; + if(s=="TWO_QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::TWO_QUARTER_TURN_STAIR; + if(s=="THREE_QUARTER_WINDING_STAIR") return IfcStairTypeEnum::THREE_QUARTER_WINDING_STAIR; + if(s=="THREE_QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::THREE_QUARTER_TURN_STAIR; + if(s=="SPIRAL_STAIR" ) return IfcStairTypeEnum::SPIRAL_STAIR; + if(s=="DOUBLE_RETURN_STAIR" ) return IfcStairTypeEnum::DOUBLE_RETURN_STAIR; + if(s=="CURVED_RUN_STAIR" ) return IfcStairTypeEnum::CURVED_RUN_STAIR; + if(s=="TWO_CURVED_RUN_STAIR" ) return IfcStairTypeEnum::TWO_CURVED_RUN_STAIR; + if(s=="USERDEFINED" ) return IfcStairTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcStairTypeEnum::NOTDEFINED; + throw; +} std::string IfcStateEnum::ToString(IfcStateEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "READWRITE","READONLY","LOCKED","READWRITELOCKED","READONLYLOCKED" }; return names[v]; } +IfcStateEnum::IfcStateEnum IfcStateEnum::FromString(const std::string& s) { + if(s=="READWRITE" ) return IfcStateEnum::READWRITE; + if(s=="READONLY" ) return IfcStateEnum::READONLY; + if(s=="LOCKED" ) return IfcStateEnum::LOCKED; + if(s=="READWRITELOCKED") return IfcStateEnum::READWRITELOCKED; + if(s=="READONLYLOCKED" ) return IfcStateEnum::READONLYLOCKED; + throw; +} std::string IfcStructuralCurveTypeEnum::ToString(IfcStructuralCurveTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "RIGID_JOINED_MEMBER","PIN_JOINED_MEMBER","CABLE","TENSION_MEMBER","COMPRESSION_MEMBER","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveTypeEnum::FromString(const std::string& s) { + if(s=="RIGID_JOINED_MEMBER") return IfcStructuralCurveTypeEnum::RIGID_JOINED_MEMBER; + if(s=="PIN_JOINED_MEMBER" ) return IfcStructuralCurveTypeEnum::PIN_JOINED_MEMBER; + if(s=="CABLE" ) return IfcStructuralCurveTypeEnum::CABLE; + if(s=="TENSION_MEMBER" ) return IfcStructuralCurveTypeEnum::TENSION_MEMBER; + if(s=="COMPRESSION_MEMBER" ) return IfcStructuralCurveTypeEnum::COMPRESSION_MEMBER; + if(s=="USERDEFINED" ) return IfcStructuralCurveTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcStructuralCurveTypeEnum::NOTDEFINED; + throw; +} std::string IfcStructuralSurfaceTypeEnum::ToString(IfcStructuralSurfaceTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "BENDING_ELEMENT","MEMBRANE_ELEMENT","SHELL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceTypeEnum::FromString(const std::string& s) { + if(s=="BENDING_ELEMENT" ) return IfcStructuralSurfaceTypeEnum::BENDING_ELEMENT; + if(s=="MEMBRANE_ELEMENT") return IfcStructuralSurfaceTypeEnum::MEMBRANE_ELEMENT; + if(s=="SHELL" ) return IfcStructuralSurfaceTypeEnum::SHELL; + if(s=="USERDEFINED" ) return IfcStructuralSurfaceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcStructuralSurfaceTypeEnum::NOTDEFINED; + throw; +} std::string IfcSurfaceSide::ToString(IfcSurfaceSide v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "POSITIVE","NEGATIVE","BOTH" }; return names[v]; } +IfcSurfaceSide::IfcSurfaceSide IfcSurfaceSide::FromString(const std::string& s) { + if(s=="POSITIVE") return IfcSurfaceSide::POSITIVE; + if(s=="NEGATIVE") return IfcSurfaceSide::NEGATIVE; + if(s=="BOTH" ) return IfcSurfaceSide::BOTH; + throw; +} std::string IfcSurfaceTextureEnum::ToString(IfcSurfaceTextureEnum v) { - if (v < 0 || v >= 9) throw; + if ( v < 0 || v >= 9 ) throw; const char* names[] = { "BUMP","OPACITY","REFLECTION","SELFILLUMINATION","SHININESS","SPECULAR","TEXTURE","TRANSPARENCYMAP","NOTDEFINED" }; return names[v]; } +IfcSurfaceTextureEnum::IfcSurfaceTextureEnum IfcSurfaceTextureEnum::FromString(const std::string& s) { + if(s=="BUMP" ) return IfcSurfaceTextureEnum::BUMP; + if(s=="OPACITY" ) return IfcSurfaceTextureEnum::OPACITY; + if(s=="REFLECTION" ) return IfcSurfaceTextureEnum::REFLECTION; + if(s=="SELFILLUMINATION") return IfcSurfaceTextureEnum::SELFILLUMINATION; + if(s=="SHININESS" ) return IfcSurfaceTextureEnum::SHININESS; + if(s=="SPECULAR" ) return IfcSurfaceTextureEnum::SPECULAR; + if(s=="TEXTURE" ) return IfcSurfaceTextureEnum::TEXTURE; + if(s=="TRANSPARENCYMAP" ) return IfcSurfaceTextureEnum::TRANSPARENCYMAP; + if(s=="NOTDEFINED" ) return IfcSurfaceTextureEnum::NOTDEFINED; + throw; +} std::string IfcSwitchingDeviceTypeEnum::ToString(IfcSwitchingDeviceTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "CONTACTOR","EMERGENCYSTOP","STARTER","SWITCHDISCONNECTOR","TOGGLESWITCH","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceTypeEnum::FromString(const std::string& s) { + if(s=="CONTACTOR" ) return IfcSwitchingDeviceTypeEnum::CONTACTOR; + if(s=="EMERGENCYSTOP" ) return IfcSwitchingDeviceTypeEnum::EMERGENCYSTOP; + if(s=="STARTER" ) return IfcSwitchingDeviceTypeEnum::STARTER; + if(s=="SWITCHDISCONNECTOR") return IfcSwitchingDeviceTypeEnum::SWITCHDISCONNECTOR; + if(s=="TOGGLESWITCH" ) return IfcSwitchingDeviceTypeEnum::TOGGLESWITCH; + if(s=="USERDEFINED" ) return IfcSwitchingDeviceTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcSwitchingDeviceTypeEnum::NOTDEFINED; + throw; +} std::string IfcTankTypeEnum::ToString(IfcTankTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "PREFORMED","SECTIONAL","EXPANSION","PRESSUREVESSEL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcTankTypeEnum::IfcTankTypeEnum IfcTankTypeEnum::FromString(const std::string& s) { + if(s=="PREFORMED" ) return IfcTankTypeEnum::PREFORMED; + if(s=="SECTIONAL" ) return IfcTankTypeEnum::SECTIONAL; + if(s=="EXPANSION" ) return IfcTankTypeEnum::EXPANSION; + if(s=="PRESSUREVESSEL") return IfcTankTypeEnum::PRESSUREVESSEL; + if(s=="USERDEFINED" ) return IfcTankTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcTankTypeEnum::NOTDEFINED; + throw; +} std::string IfcTendonTypeEnum::ToString(IfcTendonTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "STRAND","WIRE","BAR","COATED","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendonTypeEnum::FromString(const std::string& s) { + if(s=="STRAND" ) return IfcTendonTypeEnum::STRAND; + if(s=="WIRE" ) return IfcTendonTypeEnum::WIRE; + if(s=="BAR" ) return IfcTendonTypeEnum::BAR; + if(s=="COATED" ) return IfcTendonTypeEnum::COATED; + if(s=="USERDEFINED") return IfcTendonTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcTendonTypeEnum::NOTDEFINED; + throw; +} std::string IfcTextPath::ToString(IfcTextPath v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "LEFT","RIGHT","UP","DOWN" }; return names[v]; } +IfcTextPath::IfcTextPath IfcTextPath::FromString(const std::string& s) { + if(s=="LEFT" ) return IfcTextPath::LEFT; + if(s=="RIGHT") return IfcTextPath::RIGHT; + if(s=="UP" ) return IfcTextPath::UP; + if(s=="DOWN" ) return IfcTextPath::DOWN; + throw; +} std::string IfcThermalLoadSourceEnum::ToString(IfcThermalLoadSourceEnum v) { - if (v < 0 || v >= 13) throw; + if ( v < 0 || v >= 13 ) throw; const char* names[] = { "PEOPLE","LIGHTING","EQUIPMENT","VENTILATIONINDOORAIR","VENTILATIONOUTSIDEAIR","RECIRCULATEDAIR","EXHAUSTAIR","AIREXCHANGERATE","DRYBULBTEMPERATURE","RELATIVEHUMIDITY","INFILTRATION","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum IfcThermalLoadSourceEnum::FromString(const std::string& s) { + if(s=="PEOPLE" ) return IfcThermalLoadSourceEnum::PEOPLE; + if(s=="LIGHTING" ) return IfcThermalLoadSourceEnum::LIGHTING; + if(s=="EQUIPMENT" ) return IfcThermalLoadSourceEnum::EQUIPMENT; + if(s=="VENTILATIONINDOORAIR" ) return IfcThermalLoadSourceEnum::VENTILATIONINDOORAIR; + if(s=="VENTILATIONOUTSIDEAIR") return IfcThermalLoadSourceEnum::VENTILATIONOUTSIDEAIR; + if(s=="RECIRCULATEDAIR" ) return IfcThermalLoadSourceEnum::RECIRCULATEDAIR; + if(s=="EXHAUSTAIR" ) return IfcThermalLoadSourceEnum::EXHAUSTAIR; + if(s=="AIREXCHANGERATE" ) return IfcThermalLoadSourceEnum::AIREXCHANGERATE; + if(s=="DRYBULBTEMPERATURE" ) return IfcThermalLoadSourceEnum::DRYBULBTEMPERATURE; + if(s=="RELATIVEHUMIDITY" ) return IfcThermalLoadSourceEnum::RELATIVEHUMIDITY; + if(s=="INFILTRATION" ) return IfcThermalLoadSourceEnum::INFILTRATION; + if(s=="USERDEFINED" ) return IfcThermalLoadSourceEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcThermalLoadSourceEnum::NOTDEFINED; + throw; +} std::string IfcThermalLoadTypeEnum::ToString(IfcThermalLoadTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "SENSIBLE","LATENT","RADIANT","NOTDEFINED" }; return names[v]; } +IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcThermalLoadTypeEnum::FromString(const std::string& s) { + if(s=="SENSIBLE" ) return IfcThermalLoadTypeEnum::SENSIBLE; + if(s=="LATENT" ) return IfcThermalLoadTypeEnum::LATENT; + if(s=="RADIANT" ) return IfcThermalLoadTypeEnum::RADIANT; + if(s=="NOTDEFINED") return IfcThermalLoadTypeEnum::NOTDEFINED; + throw; +} std::string IfcTimeSeriesDataTypeEnum::ToString(IfcTimeSeriesDataTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "CONTINUOUS","DISCRETE","DISCRETEBINARY","PIECEWISEBINARY","PIECEWISECONSTANT","PIECEWISECONTINUOUS","NOTDEFINED" }; return names[v]; } +IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum IfcTimeSeriesDataTypeEnum::FromString(const std::string& s) { + if(s=="CONTINUOUS" ) return IfcTimeSeriesDataTypeEnum::CONTINUOUS; + if(s=="DISCRETE" ) return IfcTimeSeriesDataTypeEnum::DISCRETE; + if(s=="DISCRETEBINARY" ) return IfcTimeSeriesDataTypeEnum::DISCRETEBINARY; + if(s=="PIECEWISEBINARY" ) return IfcTimeSeriesDataTypeEnum::PIECEWISEBINARY; + if(s=="PIECEWISECONSTANT" ) return IfcTimeSeriesDataTypeEnum::PIECEWISECONSTANT; + if(s=="PIECEWISECONTINUOUS") return IfcTimeSeriesDataTypeEnum::PIECEWISECONTINUOUS; + if(s=="NOTDEFINED" ) return IfcTimeSeriesDataTypeEnum::NOTDEFINED; + throw; +} std::string IfcTimeSeriesScheduleTypeEnum::ToString(IfcTimeSeriesScheduleTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "ANNUAL","MONTHLY","WEEKLY","DAILY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum IfcTimeSeriesScheduleTypeEnum::FromString(const std::string& s) { + if(s=="ANNUAL" ) return IfcTimeSeriesScheduleTypeEnum::ANNUAL; + if(s=="MONTHLY" ) return IfcTimeSeriesScheduleTypeEnum::MONTHLY; + if(s=="WEEKLY" ) return IfcTimeSeriesScheduleTypeEnum::WEEKLY; + if(s=="DAILY" ) return IfcTimeSeriesScheduleTypeEnum::DAILY; + if(s=="USERDEFINED") return IfcTimeSeriesScheduleTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcTimeSeriesScheduleTypeEnum::NOTDEFINED; + throw; +} std::string IfcTransformerTypeEnum::ToString(IfcTransformerTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "CURRENT","FREQUENCY","VOLTAGE","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerTypeEnum::FromString(const std::string& s) { + if(s=="CURRENT" ) return IfcTransformerTypeEnum::CURRENT; + if(s=="FREQUENCY" ) return IfcTransformerTypeEnum::FREQUENCY; + if(s=="VOLTAGE" ) return IfcTransformerTypeEnum::VOLTAGE; + if(s=="USERDEFINED") return IfcTransformerTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcTransformerTypeEnum::NOTDEFINED; + throw; +} std::string IfcTransitionCode::ToString(IfcTransitionCode v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "DISCONTINUOUS","CONTINUOUS","CONTSAMEGRADIENT","CONTSAMEGRADIENTSAMECURVATURE" }; return names[v]; } +IfcTransitionCode::IfcTransitionCode IfcTransitionCode::FromString(const std::string& s) { + if(s=="DISCONTINUOUS" ) return IfcTransitionCode::DISCONTINUOUS; + if(s=="CONTINUOUS" ) return IfcTransitionCode::CONTINUOUS; + if(s=="CONTSAMEGRADIENT" ) return IfcTransitionCode::CONTSAMEGRADIENT; + if(s=="CONTSAMEGRADIENTSAMECURVATURE") return IfcTransitionCode::CONTSAMEGRADIENTSAMECURVATURE; + throw; +} std::string IfcTransportElementTypeEnum::ToString(IfcTransportElementTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "ELEVATOR","ESCALATOR","MOVINGWALKWAY","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementTypeEnum::FromString(const std::string& s) { + if(s=="ELEVATOR" ) return IfcTransportElementTypeEnum::ELEVATOR; + if(s=="ESCALATOR" ) return IfcTransportElementTypeEnum::ESCALATOR; + if(s=="MOVINGWALKWAY") return IfcTransportElementTypeEnum::MOVINGWALKWAY; + if(s=="USERDEFINED" ) return IfcTransportElementTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcTransportElementTypeEnum::NOTDEFINED; + throw; +} std::string IfcTrimmingPreference::ToString(IfcTrimmingPreference v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "CARTESIAN","PARAMETER","UNSPECIFIED" }; return names[v]; } +IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmingPreference::FromString(const std::string& s) { + if(s=="CARTESIAN" ) return IfcTrimmingPreference::CARTESIAN; + if(s=="PARAMETER" ) return IfcTrimmingPreference::PARAMETER; + if(s=="UNSPECIFIED") return IfcTrimmingPreference::UNSPECIFIED; + throw; +} std::string IfcTubeBundleTypeEnum::ToString(IfcTubeBundleTypeEnum v) { - if (v < 0 || v >= 3) throw; + if ( v < 0 || v >= 3 ) throw; const char* names[] = { "FINNED","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleTypeEnum::FromString(const std::string& s) { + if(s=="FINNED" ) return IfcTubeBundleTypeEnum::FINNED; + if(s=="USERDEFINED") return IfcTubeBundleTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcTubeBundleTypeEnum::NOTDEFINED; + throw; +} std::string IfcUnitEnum::ToString(IfcUnitEnum v) { - if (v < 0 || v >= 30) throw; + if ( v < 0 || v >= 30 ) throw; const char* names[] = { "ABSORBEDDOSEUNIT","AMOUNTOFSUBSTANCEUNIT","AREAUNIT","DOSEEQUIVALENTUNIT","ELECTRICCAPACITANCEUNIT","ELECTRICCHARGEUNIT","ELECTRICCONDUCTANCEUNIT","ELECTRICCURRENTUNIT","ELECTRICRESISTANCEUNIT","ELECTRICVOLTAGEUNIT","ENERGYUNIT","FORCEUNIT","FREQUENCYUNIT","ILLUMINANCEUNIT","INDUCTANCEUNIT","LENGTHUNIT","LUMINOUSFLUXUNIT","LUMINOUSINTENSITYUNIT","MAGNETICFLUXDENSITYUNIT","MAGNETICFLUXUNIT","MASSUNIT","PLANEANGLEUNIT","POWERUNIT","PRESSUREUNIT","RADIOACTIVITYUNIT","SOLIDANGLEUNIT","THERMODYNAMICTEMPERATUREUNIT","TIMEUNIT","VOLUMEUNIT","USERDEFINED" }; return names[v]; } +IfcUnitEnum::IfcUnitEnum IfcUnitEnum::FromString(const std::string& s) { + if(s=="ABSORBEDDOSEUNIT" ) return IfcUnitEnum::ABSORBEDDOSEUNIT; + if(s=="AMOUNTOFSUBSTANCEUNIT" ) return IfcUnitEnum::AMOUNTOFSUBSTANCEUNIT; + if(s=="AREAUNIT" ) return IfcUnitEnum::AREAUNIT; + if(s=="DOSEEQUIVALENTUNIT" ) return IfcUnitEnum::DOSEEQUIVALENTUNIT; + if(s=="ELECTRICCAPACITANCEUNIT" ) return IfcUnitEnum::ELECTRICCAPACITANCEUNIT; + if(s=="ELECTRICCHARGEUNIT" ) return IfcUnitEnum::ELECTRICCHARGEUNIT; + if(s=="ELECTRICCONDUCTANCEUNIT" ) return IfcUnitEnum::ELECTRICCONDUCTANCEUNIT; + if(s=="ELECTRICCURRENTUNIT" ) return IfcUnitEnum::ELECTRICCURRENTUNIT; + if(s=="ELECTRICRESISTANCEUNIT" ) return IfcUnitEnum::ELECTRICRESISTANCEUNIT; + if(s=="ELECTRICVOLTAGEUNIT" ) return IfcUnitEnum::ELECTRICVOLTAGEUNIT; + if(s=="ENERGYUNIT" ) return IfcUnitEnum::ENERGYUNIT; + if(s=="FORCEUNIT" ) return IfcUnitEnum::FORCEUNIT; + if(s=="FREQUENCYUNIT" ) return IfcUnitEnum::FREQUENCYUNIT; + if(s=="ILLUMINANCEUNIT" ) return IfcUnitEnum::ILLUMINANCEUNIT; + if(s=="INDUCTANCEUNIT" ) return IfcUnitEnum::INDUCTANCEUNIT; + if(s=="LENGTHUNIT" ) return IfcUnitEnum::LENGTHUNIT; + if(s=="LUMINOUSFLUXUNIT" ) return IfcUnitEnum::LUMINOUSFLUXUNIT; + if(s=="LUMINOUSINTENSITYUNIT" ) return IfcUnitEnum::LUMINOUSINTENSITYUNIT; + if(s=="MAGNETICFLUXDENSITYUNIT" ) return IfcUnitEnum::MAGNETICFLUXDENSITYUNIT; + if(s=="MAGNETICFLUXUNIT" ) return IfcUnitEnum::MAGNETICFLUXUNIT; + if(s=="MASSUNIT" ) return IfcUnitEnum::MASSUNIT; + if(s=="PLANEANGLEUNIT" ) return IfcUnitEnum::PLANEANGLEUNIT; + if(s=="POWERUNIT" ) return IfcUnitEnum::POWERUNIT; + if(s=="PRESSUREUNIT" ) return IfcUnitEnum::PRESSUREUNIT; + if(s=="RADIOACTIVITYUNIT" ) return IfcUnitEnum::RADIOACTIVITYUNIT; + if(s=="SOLIDANGLEUNIT" ) return IfcUnitEnum::SOLIDANGLEUNIT; + if(s=="THERMODYNAMICTEMPERATUREUNIT") return IfcUnitEnum::THERMODYNAMICTEMPERATUREUNIT; + if(s=="TIMEUNIT" ) return IfcUnitEnum::TIMEUNIT; + if(s=="VOLUMEUNIT" ) return IfcUnitEnum::VOLUMEUNIT; + if(s=="USERDEFINED" ) return IfcUnitEnum::USERDEFINED; + throw; +} std::string IfcUnitaryEquipmentTypeEnum::ToString(IfcUnitaryEquipmentTypeEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "AIRHANDLER","AIRCONDITIONINGUNIT","SPLITSYSTEM","ROOFTOPUNIT","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentTypeEnum::FromString(const std::string& s) { + if(s=="AIRHANDLER" ) return IfcUnitaryEquipmentTypeEnum::AIRHANDLER; + if(s=="AIRCONDITIONINGUNIT") return IfcUnitaryEquipmentTypeEnum::AIRCONDITIONINGUNIT; + if(s=="SPLITSYSTEM" ) return IfcUnitaryEquipmentTypeEnum::SPLITSYSTEM; + if(s=="ROOFTOPUNIT" ) return IfcUnitaryEquipmentTypeEnum::ROOFTOPUNIT; + if(s=="USERDEFINED" ) return IfcUnitaryEquipmentTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcUnitaryEquipmentTypeEnum::NOTDEFINED; + throw; +} std::string IfcValveTypeEnum::ToString(IfcValveTypeEnum v) { - if (v < 0 || v >= 23) throw; + if ( v < 0 || v >= 23 ) throw; const char* names[] = { "AIRRELEASE","ANTIVACUUM","CHANGEOVER","CHECK","COMMISSIONING","DIVERTING","DRAWOFFCOCK","DOUBLECHECK","DOUBLEREGULATING","FAUCET","FLUSHING","GASCOCK","GASTAP","ISOLATING","MIXING","PRESSUREREDUCING","PRESSURERELIEF","REGULATING","SAFETYCUTOFF","STEAMTRAP","STOPCOCK","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcValveTypeEnum::IfcValveTypeEnum IfcValveTypeEnum::FromString(const std::string& s) { + if(s=="AIRRELEASE" ) return IfcValveTypeEnum::AIRRELEASE; + if(s=="ANTIVACUUM" ) return IfcValveTypeEnum::ANTIVACUUM; + if(s=="CHANGEOVER" ) return IfcValveTypeEnum::CHANGEOVER; + if(s=="CHECK" ) return IfcValveTypeEnum::CHECK; + if(s=="COMMISSIONING" ) return IfcValveTypeEnum::COMMISSIONING; + if(s=="DIVERTING" ) return IfcValveTypeEnum::DIVERTING; + if(s=="DRAWOFFCOCK" ) return IfcValveTypeEnum::DRAWOFFCOCK; + if(s=="DOUBLECHECK" ) return IfcValveTypeEnum::DOUBLECHECK; + if(s=="DOUBLEREGULATING") return IfcValveTypeEnum::DOUBLEREGULATING; + if(s=="FAUCET" ) return IfcValveTypeEnum::FAUCET; + if(s=="FLUSHING" ) return IfcValveTypeEnum::FLUSHING; + if(s=="GASCOCK" ) return IfcValveTypeEnum::GASCOCK; + if(s=="GASTAP" ) return IfcValveTypeEnum::GASTAP; + if(s=="ISOLATING" ) return IfcValveTypeEnum::ISOLATING; + if(s=="MIXING" ) return IfcValveTypeEnum::MIXING; + if(s=="PRESSUREREDUCING") return IfcValveTypeEnum::PRESSUREREDUCING; + if(s=="PRESSURERELIEF" ) return IfcValveTypeEnum::PRESSURERELIEF; + if(s=="REGULATING" ) return IfcValveTypeEnum::REGULATING; + if(s=="SAFETYCUTOFF" ) return IfcValveTypeEnum::SAFETYCUTOFF; + if(s=="STEAMTRAP" ) return IfcValveTypeEnum::STEAMTRAP; + if(s=="STOPCOCK" ) return IfcValveTypeEnum::STOPCOCK; + if(s=="USERDEFINED" ) return IfcValveTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcValveTypeEnum::NOTDEFINED; + throw; +} std::string IfcVibrationIsolatorTypeEnum::ToString(IfcVibrationIsolatorTypeEnum v) { - if (v < 0 || v >= 4) throw; + if ( v < 0 || v >= 4 ) throw; const char* names[] = { "COMPRESSION","SPRING","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorTypeEnum::FromString(const std::string& s) { + if(s=="COMPRESSION") return IfcVibrationIsolatorTypeEnum::COMPRESSION; + if(s=="SPRING" ) return IfcVibrationIsolatorTypeEnum::SPRING; + if(s=="USERDEFINED") return IfcVibrationIsolatorTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcVibrationIsolatorTypeEnum::NOTDEFINED; + throw; +} std::string IfcWallTypeEnum::ToString(IfcWallTypeEnum v) { - if (v < 0 || v >= 7) throw; + if ( v < 0 || v >= 7 ) throw; const char* names[] = { "STANDARD","POLYGONAL","SHEAR","ELEMENTEDWALL","PLUMBINGWALL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcWallTypeEnum::IfcWallTypeEnum IfcWallTypeEnum::FromString(const std::string& s) { + if(s=="STANDARD" ) return IfcWallTypeEnum::STANDARD; + if(s=="POLYGONAL" ) return IfcWallTypeEnum::POLYGONAL; + if(s=="SHEAR" ) return IfcWallTypeEnum::SHEAR; + if(s=="ELEMENTEDWALL") return IfcWallTypeEnum::ELEMENTEDWALL; + if(s=="PLUMBINGWALL" ) return IfcWallTypeEnum::PLUMBINGWALL; + if(s=="USERDEFINED" ) return IfcWallTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcWallTypeEnum::NOTDEFINED; + throw; +} std::string IfcWasteTerminalTypeEnum::ToString(IfcWasteTerminalTypeEnum v) { - if (v < 0 || v >= 12) throw; + if ( v < 0 || v >= 12 ) throw; const char* names[] = { "FLOORTRAP","FLOORWASTE","GULLYSUMP","GULLYTRAP","GREASEINTERCEPTOR","OILINTERCEPTOR","PETROLINTERCEPTOR","ROOFDRAIN","WASTEDISPOSALUNIT","WASTETRAP","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalTypeEnum::FromString(const std::string& s) { + if(s=="FLOORTRAP" ) return IfcWasteTerminalTypeEnum::FLOORTRAP; + if(s=="FLOORWASTE" ) return IfcWasteTerminalTypeEnum::FLOORWASTE; + if(s=="GULLYSUMP" ) return IfcWasteTerminalTypeEnum::GULLYSUMP; + if(s=="GULLYTRAP" ) return IfcWasteTerminalTypeEnum::GULLYTRAP; + if(s=="GREASEINTERCEPTOR") return IfcWasteTerminalTypeEnum::GREASEINTERCEPTOR; + if(s=="OILINTERCEPTOR" ) return IfcWasteTerminalTypeEnum::OILINTERCEPTOR; + if(s=="PETROLINTERCEPTOR") return IfcWasteTerminalTypeEnum::PETROLINTERCEPTOR; + if(s=="ROOFDRAIN" ) return IfcWasteTerminalTypeEnum::ROOFDRAIN; + if(s=="WASTEDISPOSALUNIT") return IfcWasteTerminalTypeEnum::WASTEDISPOSALUNIT; + if(s=="WASTETRAP" ) return IfcWasteTerminalTypeEnum::WASTETRAP; + if(s=="USERDEFINED" ) return IfcWasteTerminalTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcWasteTerminalTypeEnum::NOTDEFINED; + throw; +} std::string IfcWindowPanelOperationEnum::ToString(IfcWindowPanelOperationEnum v) { - if (v < 0 || v >= 14) throw; + if ( v < 0 || v >= 14 ) throw; const char* names[] = { "SIDEHUNGRIGHTHAND","SIDEHUNGLEFTHAND","TILTANDTURNRIGHTHAND","TILTANDTURNLEFTHAND","TOPHUNG","BOTTOMHUNG","PIVOTHORIZONTAL","PIVOTVERTICAL","SLIDINGHORIZONTAL","SLIDINGVERTICAL","REMOVABLECASEMENT","FIXEDCASEMENT","OTHEROPERATION","NOTDEFINED" }; return names[v]; } +IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelOperationEnum::FromString(const std::string& s) { + if(s=="SIDEHUNGRIGHTHAND" ) return IfcWindowPanelOperationEnum::SIDEHUNGRIGHTHAND; + if(s=="SIDEHUNGLEFTHAND" ) return IfcWindowPanelOperationEnum::SIDEHUNGLEFTHAND; + if(s=="TILTANDTURNRIGHTHAND") return IfcWindowPanelOperationEnum::TILTANDTURNRIGHTHAND; + if(s=="TILTANDTURNLEFTHAND" ) return IfcWindowPanelOperationEnum::TILTANDTURNLEFTHAND; + if(s=="TOPHUNG" ) return IfcWindowPanelOperationEnum::TOPHUNG; + if(s=="BOTTOMHUNG" ) return IfcWindowPanelOperationEnum::BOTTOMHUNG; + if(s=="PIVOTHORIZONTAL" ) return IfcWindowPanelOperationEnum::PIVOTHORIZONTAL; + if(s=="PIVOTVERTICAL" ) return IfcWindowPanelOperationEnum::PIVOTVERTICAL; + if(s=="SLIDINGHORIZONTAL" ) return IfcWindowPanelOperationEnum::SLIDINGHORIZONTAL; + if(s=="SLIDINGVERTICAL" ) return IfcWindowPanelOperationEnum::SLIDINGVERTICAL; + if(s=="REMOVABLECASEMENT" ) return IfcWindowPanelOperationEnum::REMOVABLECASEMENT; + if(s=="FIXEDCASEMENT" ) return IfcWindowPanelOperationEnum::FIXEDCASEMENT; + if(s=="OTHEROPERATION" ) return IfcWindowPanelOperationEnum::OTHEROPERATION; + if(s=="NOTDEFINED" ) return IfcWindowPanelOperationEnum::NOTDEFINED; + throw; +} std::string IfcWindowPanelPositionEnum::ToString(IfcWindowPanelPositionEnum v) { - if (v < 0 || v >= 6) throw; + if ( v < 0 || v >= 6 ) throw; const char* names[] = { "LEFT","MIDDLE","RIGHT","BOTTOM","TOP","NOTDEFINED" }; return names[v]; } +IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelPositionEnum::FromString(const std::string& s) { + if(s=="LEFT" ) return IfcWindowPanelPositionEnum::LEFT; + if(s=="MIDDLE" ) return IfcWindowPanelPositionEnum::MIDDLE; + if(s=="RIGHT" ) return IfcWindowPanelPositionEnum::RIGHT; + if(s=="BOTTOM" ) return IfcWindowPanelPositionEnum::BOTTOM; + if(s=="TOP" ) return IfcWindowPanelPositionEnum::TOP; + if(s=="NOTDEFINED") return IfcWindowPanelPositionEnum::NOTDEFINED; + throw; +} std::string IfcWindowStyleConstructionEnum::ToString(IfcWindowStyleConstructionEnum v) { - if (v < 0 || v >= 8) throw; + if ( v < 0 || v >= 8 ) throw; const char* names[] = { "ALUMINIUM","HIGH_GRADE_STEEL","STEEL","WOOD","ALUMINIUM_WOOD","PLASTIC","OTHER_CONSTRUCTION","NOTDEFINED" }; return names[v]; } +IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyleConstructionEnum::FromString(const std::string& s) { + if(s=="ALUMINIUM" ) return IfcWindowStyleConstructionEnum::ALUMINIUM; + if(s=="HIGH_GRADE_STEEL" ) return IfcWindowStyleConstructionEnum::HIGH_GRADE_STEEL; + if(s=="STEEL" ) return IfcWindowStyleConstructionEnum::STEEL; + if(s=="WOOD" ) return IfcWindowStyleConstructionEnum::WOOD; + if(s=="ALUMINIUM_WOOD" ) return IfcWindowStyleConstructionEnum::ALUMINIUM_WOOD; + if(s=="PLASTIC" ) return IfcWindowStyleConstructionEnum::PLASTIC; + if(s=="OTHER_CONSTRUCTION") return IfcWindowStyleConstructionEnum::OTHER_CONSTRUCTION; + if(s=="NOTDEFINED" ) return IfcWindowStyleConstructionEnum::NOTDEFINED; + throw; +} std::string IfcWindowStyleOperationEnum::ToString(IfcWindowStyleOperationEnum v) { - if (v < 0 || v >= 11) throw; + if ( v < 0 || v >= 11 ) throw; const char* names[] = { "SINGLE_PANEL","DOUBLE_PANEL_VERTICAL","DOUBLE_PANEL_HORIZONTAL","TRIPLE_PANEL_VERTICAL","TRIPLE_PANEL_BOTTOM","TRIPLE_PANEL_TOP","TRIPLE_PANEL_LEFT","TRIPLE_PANEL_RIGHT","TRIPLE_PANEL_HORIZONTAL","USERDEFINED","NOTDEFINED" }; return names[v]; } +IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyleOperationEnum::FromString(const std::string& s) { + if(s=="SINGLE_PANEL" ) return IfcWindowStyleOperationEnum::SINGLE_PANEL; + if(s=="DOUBLE_PANEL_VERTICAL" ) return IfcWindowStyleOperationEnum::DOUBLE_PANEL_VERTICAL; + if(s=="DOUBLE_PANEL_HORIZONTAL") return IfcWindowStyleOperationEnum::DOUBLE_PANEL_HORIZONTAL; + if(s=="TRIPLE_PANEL_VERTICAL" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_VERTICAL; + if(s=="TRIPLE_PANEL_BOTTOM" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_BOTTOM; + if(s=="TRIPLE_PANEL_TOP" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_TOP; + if(s=="TRIPLE_PANEL_LEFT" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_LEFT; + if(s=="TRIPLE_PANEL_RIGHT" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_RIGHT; + if(s=="TRIPLE_PANEL_HORIZONTAL") return IfcWindowStyleOperationEnum::TRIPLE_PANEL_HORIZONTAL; + if(s=="USERDEFINED" ) return IfcWindowStyleOperationEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcWindowStyleOperationEnum::NOTDEFINED; + throw; +} std::string IfcWorkControlTypeEnum::ToString(IfcWorkControlTypeEnum v) { - if (v < 0 || v >= 5) throw; + if ( v < 0 || v >= 5 ) throw; const char* names[] = { "ACTUAL","BASELINE","PLANNED","USERDEFINED","NOTDEFINED" }; return names[v]; } -IfcActionSourceTypeEnum::IfcActionSourceTypeEnum IfcActionSourceTypeEnum::FromString(const std::string& s){ - if (s=="DEAD_LOAD_G" ) return IfcActionSourceTypeEnum::DEAD_LOAD_G; - else if(s=="COMPLETION_G1" ) return IfcActionSourceTypeEnum::COMPLETION_G1; - else if(s=="LIVE_LOAD_Q" ) return IfcActionSourceTypeEnum::LIVE_LOAD_Q; - else if(s=="SNOW_S" ) return IfcActionSourceTypeEnum::SNOW_S; - else if(s=="WIND_W" ) return IfcActionSourceTypeEnum::WIND_W; - else if(s=="PRESTRESSING_P" ) return IfcActionSourceTypeEnum::PRESTRESSING_P; - else if(s=="SETTLEMENT_U" ) return IfcActionSourceTypeEnum::SETTLEMENT_U; - else if(s=="TEMPERATURE_T" ) return IfcActionSourceTypeEnum::TEMPERATURE_T; - else if(s=="EARTHQUAKE_E" ) return IfcActionSourceTypeEnum::EARTHQUAKE_E; - else if(s=="FIRE" ) return IfcActionSourceTypeEnum::FIRE; - else if(s=="IMPULSE" ) return IfcActionSourceTypeEnum::IMPULSE; - else if(s=="IMPACT" ) return IfcActionSourceTypeEnum::IMPACT; - else if(s=="TRANSPORT" ) return IfcActionSourceTypeEnum::TRANSPORT; - else if(s=="ERECTION" ) return IfcActionSourceTypeEnum::ERECTION; - else if(s=="PROPPING" ) return IfcActionSourceTypeEnum::PROPPING; - else if(s=="SYSTEM_IMPERFECTION") return IfcActionSourceTypeEnum::SYSTEM_IMPERFECTION; - else if(s=="SHRINKAGE" ) return IfcActionSourceTypeEnum::SHRINKAGE; - else if(s=="CREEP" ) return IfcActionSourceTypeEnum::CREEP; - else if(s=="LACK_OF_FIT" ) return IfcActionSourceTypeEnum::LACK_OF_FIT; - else if(s=="BUOYANCY" ) return IfcActionSourceTypeEnum::BUOYANCY; - else if(s=="ICE" ) return IfcActionSourceTypeEnum::ICE; - else if(s=="CURRENT" ) return IfcActionSourceTypeEnum::CURRENT; - else if(s=="WAVE" ) return IfcActionSourceTypeEnum::WAVE; - else if(s=="RAIN" ) return IfcActionSourceTypeEnum::RAIN; - else if(s=="BRAKES" ) return IfcActionSourceTypeEnum::BRAKES; - else if(s=="USERDEFINED" ) return IfcActionSourceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcActionSourceTypeEnum::NOTDEFINED; - else throw; -} -IfcActionTypeEnum::IfcActionTypeEnum IfcActionTypeEnum::FromString(const std::string& s){ - if (s=="PERMANENT_G" ) return IfcActionTypeEnum::PERMANENT_G; - else if(s=="VARIABLE_Q" ) return IfcActionTypeEnum::VARIABLE_Q; - else if(s=="EXTRAORDINARY_A") return IfcActionTypeEnum::EXTRAORDINARY_A; - else if(s=="USERDEFINED" ) return IfcActionTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcActionTypeEnum::NOTDEFINED; - else throw; -} -IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorTypeEnum::FromString(const std::string& s){ - if (s=="ELECTRICACTUATOR" ) return IfcActuatorTypeEnum::ELECTRICACTUATOR; - else if(s=="HANDOPERATEDACTUATOR") return IfcActuatorTypeEnum::HANDOPERATEDACTUATOR; - else if(s=="HYDRAULICACTUATOR" ) return IfcActuatorTypeEnum::HYDRAULICACTUATOR; - else if(s=="PNEUMATICACTUATOR" ) return IfcActuatorTypeEnum::PNEUMATICACTUATOR; - else if(s=="THERMOSTATICACTUATOR") return IfcActuatorTypeEnum::THERMOSTATICACTUATOR; - else if(s=="USERDEFINED" ) return IfcActuatorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcActuatorTypeEnum::NOTDEFINED; - else throw; -} -IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddressTypeEnum::FromString(const std::string& s){ - if (s=="OFFICE" ) return IfcAddressTypeEnum::OFFICE; - else if(s=="SITE" ) return IfcAddressTypeEnum::SITE; - else if(s=="HOME" ) return IfcAddressTypeEnum::HOME; - else if(s=="DISTRIBUTIONPOINT") return IfcAddressTypeEnum::DISTRIBUTIONPOINT; - else if(s=="USERDEFINED" ) return IfcAddressTypeEnum::USERDEFINED; - else throw; -} -IfcAheadOrBehind::IfcAheadOrBehind IfcAheadOrBehind::FromString(const std::string& s){ - if (s=="AHEAD" ) return IfcAheadOrBehind::AHEAD; - else if(s=="BEHIND") return IfcAheadOrBehind::BEHIND; - else throw; -} -IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxTypeEnum::FromString(const std::string& s){ - if (s=="CONSTANTFLOW" ) return IfcAirTerminalBoxTypeEnum::CONSTANTFLOW; - else if(s=="VARIABLEFLOWPRESSUREDEPENDANT" ) return IfcAirTerminalBoxTypeEnum::VARIABLEFLOWPRESSUREDEPENDANT; - else if(s=="VARIABLEFLOWPRESSUREINDEPENDANT") return IfcAirTerminalBoxTypeEnum::VARIABLEFLOWPRESSUREINDEPENDANT; - else if(s=="USERDEFINED" ) return IfcAirTerminalBoxTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcAirTerminalBoxTypeEnum::NOTDEFINED; - else throw; -} -IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalTypeEnum::FromString(const std::string& s){ - if (s=="GRILLE" ) return IfcAirTerminalTypeEnum::GRILLE; - else if(s=="REGISTER" ) return IfcAirTerminalTypeEnum::REGISTER; - else if(s=="DIFFUSER" ) return IfcAirTerminalTypeEnum::DIFFUSER; - else if(s=="EYEBALL" ) return IfcAirTerminalTypeEnum::EYEBALL; - else if(s=="IRIS" ) return IfcAirTerminalTypeEnum::IRIS; - else if(s=="LINEARGRILLE" ) return IfcAirTerminalTypeEnum::LINEARGRILLE; - else if(s=="LINEARDIFFUSER") return IfcAirTerminalTypeEnum::LINEARDIFFUSER; - else if(s=="USERDEFINED" ) return IfcAirTerminalTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcAirTerminalTypeEnum::NOTDEFINED; - else throw; -} -IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryTypeEnum::FromString(const std::string& s){ - if (s=="FIXEDPLATECOUNTERFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATECOUNTERFLOWEXCHANGER; - else if(s=="FIXEDPLATECROSSFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATECROSSFLOWEXCHANGER; - else if(s=="FIXEDPLATEPARALLELFLOWEXCHANGER" ) return IfcAirToAirHeatRecoveryTypeEnum::FIXEDPLATEPARALLELFLOWEXCHANGER; - else if(s=="ROTARYWHEEL" ) return IfcAirToAirHeatRecoveryTypeEnum::ROTARYWHEEL; - else if(s=="RUNAROUNDCOILLOOP" ) return IfcAirToAirHeatRecoveryTypeEnum::RUNAROUNDCOILLOOP; - else if(s=="HEATPIPE" ) return IfcAirToAirHeatRecoveryTypeEnum::HEATPIPE; - else if(s=="TWINTOWERENTHALPYRECOVERYLOOPS" ) return IfcAirToAirHeatRecoveryTypeEnum::TWINTOWERENTHALPYRECOVERYLOOPS; - else if(s=="THERMOSIPHONSEALEDTUBEHEATEXCHANGERS") return IfcAirToAirHeatRecoveryTypeEnum::THERMOSIPHONSEALEDTUBEHEATEXCHANGERS; - else if(s=="THERMOSIPHONCOILTYPEHEATEXCHANGERS" ) return IfcAirToAirHeatRecoveryTypeEnum::THERMOSIPHONCOILTYPEHEATEXCHANGERS; - else if(s=="USERDEFINED" ) return IfcAirToAirHeatRecoveryTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcAirToAirHeatRecoveryTypeEnum::NOTDEFINED; - else throw; -} -IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmTypeEnum::FromString(const std::string& s){ - if (s=="BELL" ) return IfcAlarmTypeEnum::BELL; - else if(s=="BREAKGLASSBUTTON") return IfcAlarmTypeEnum::BREAKGLASSBUTTON; - else if(s=="LIGHT" ) return IfcAlarmTypeEnum::LIGHT; - else if(s=="MANUALPULLBOX" ) return IfcAlarmTypeEnum::MANUALPULLBOX; - else if(s=="SIREN" ) return IfcAlarmTypeEnum::SIREN; - else if(s=="WHISTLE" ) return IfcAlarmTypeEnum::WHISTLE; - else if(s=="USERDEFINED" ) return IfcAlarmTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcAlarmTypeEnum::NOTDEFINED; - else throw; -} -IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcAnalysisModelTypeEnum::FromString(const std::string& s){ - if (s=="IN_PLANE_LOADING_2D" ) return IfcAnalysisModelTypeEnum::IN_PLANE_LOADING_2D; - else if(s=="OUT_PLANE_LOADING_2D") return IfcAnalysisModelTypeEnum::OUT_PLANE_LOADING_2D; - else if(s=="LOADING_3D" ) return IfcAnalysisModelTypeEnum::LOADING_3D; - else if(s=="USERDEFINED" ) return IfcAnalysisModelTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcAnalysisModelTypeEnum::NOTDEFINED; - else throw; -} -IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcAnalysisTheoryTypeEnum::FromString(const std::string& s){ - if (s=="FIRST_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::FIRST_ORDER_THEORY; - else if(s=="SECOND_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::SECOND_ORDER_THEORY; - else if(s=="THIRD_ORDER_THEORY" ) return IfcAnalysisTheoryTypeEnum::THIRD_ORDER_THEORY; - else if(s=="FULL_NONLINEAR_THEORY") return IfcAnalysisTheoryTypeEnum::FULL_NONLINEAR_THEORY; - else if(s=="USERDEFINED" ) return IfcAnalysisTheoryTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcAnalysisTheoryTypeEnum::NOTDEFINED; - else throw; -} -IfcArithmeticOperatorEnum::IfcArithmeticOperatorEnum IfcArithmeticOperatorEnum::FromString(const std::string& s){ - if (s=="ADD" ) return IfcArithmeticOperatorEnum::ADD; - else if(s=="DIVIDE" ) return IfcArithmeticOperatorEnum::DIVIDE; - else if(s=="MULTIPLY") return IfcArithmeticOperatorEnum::MULTIPLY; - else if(s=="SUBTRACT") return IfcArithmeticOperatorEnum::SUBTRACT; - else throw; -} -IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcAssemblyPlaceEnum::FromString(const std::string& s){ - if (s=="SITE" ) return IfcAssemblyPlaceEnum::SITE; - else if(s=="FACTORY" ) return IfcAssemblyPlaceEnum::FACTORY; - else if(s=="NOTDEFINED") return IfcAssemblyPlaceEnum::NOTDEFINED; - else throw; -} -IfcBSplineCurveForm::IfcBSplineCurveForm IfcBSplineCurveForm::FromString(const std::string& s){ - if (s=="POLYLINE_FORM" ) return IfcBSplineCurveForm::POLYLINE_FORM; - else if(s=="CIRCULAR_ARC" ) return IfcBSplineCurveForm::CIRCULAR_ARC; - else if(s=="ELLIPTIC_ARC" ) return IfcBSplineCurveForm::ELLIPTIC_ARC; - else if(s=="PARABOLIC_ARC" ) return IfcBSplineCurveForm::PARABOLIC_ARC; - else if(s=="HYPERBOLIC_ARC") return IfcBSplineCurveForm::HYPERBOLIC_ARC; - else if(s=="UNSPECIFIED" ) return IfcBSplineCurveForm::UNSPECIFIED; - else throw; -} -IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamTypeEnum::FromString(const std::string& s){ - if (s=="BEAM" ) return IfcBeamTypeEnum::BEAM; - else if(s=="JOIST" ) return IfcBeamTypeEnum::JOIST; - else if(s=="LINTEL" ) return IfcBeamTypeEnum::LINTEL; - else if(s=="T_BEAM" ) return IfcBeamTypeEnum::T_BEAM; - else if(s=="USERDEFINED") return IfcBeamTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcBeamTypeEnum::NOTDEFINED; - else throw; -} -IfcBenchmarkEnum::IfcBenchmarkEnum IfcBenchmarkEnum::FromString(const std::string& s){ - if (s=="GREATERTHAN" ) return IfcBenchmarkEnum::GREATERTHAN; - else if(s=="GREATERTHANOREQUALTO") return IfcBenchmarkEnum::GREATERTHANOREQUALTO; - else if(s=="LESSTHAN" ) return IfcBenchmarkEnum::LESSTHAN; - else if(s=="LESSTHANOREQUALTO" ) return IfcBenchmarkEnum::LESSTHANOREQUALTO; - else if(s=="EQUALTO" ) return IfcBenchmarkEnum::EQUALTO; - else if(s=="NOTEQUALTO" ) return IfcBenchmarkEnum::NOTEQUALTO; - else throw; -} -IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerTypeEnum::FromString(const std::string& s){ - if (s=="WATER" ) return IfcBoilerTypeEnum::WATER; - else if(s=="STEAM" ) return IfcBoilerTypeEnum::STEAM; - else if(s=="USERDEFINED") return IfcBoilerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcBoilerTypeEnum::NOTDEFINED; - else throw; -} -IfcBooleanOperator::IfcBooleanOperator IfcBooleanOperator::FromString(const std::string& s){ - if (s=="UNION" ) return IfcBooleanOperator::UNION; - else if(s=="INTERSECTION") return IfcBooleanOperator::INTERSECTION; - else if(s=="DIFFERENCE" ) return IfcBooleanOperator::DIFFERENCE; - else throw; -} -IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyTypeEnum::FromString(const std::string& s){ - if (s=="USERDEFINED") return IfcBuildingElementProxyTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcBuildingElementProxyTypeEnum::NOTDEFINED; - else throw; -} -IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingTypeEnum::FromString(const std::string& s){ - if (s=="BEND" ) return IfcCableCarrierFittingTypeEnum::BEND; - else if(s=="CROSS" ) return IfcCableCarrierFittingTypeEnum::CROSS; - else if(s=="REDUCER" ) return IfcCableCarrierFittingTypeEnum::REDUCER; - else if(s=="TEE" ) return IfcCableCarrierFittingTypeEnum::TEE; - else if(s=="USERDEFINED") return IfcCableCarrierFittingTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCableCarrierFittingTypeEnum::NOTDEFINED; - else throw; -} -IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentTypeEnum::FromString(const std::string& s){ - if (s=="CABLELADDERSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CABLELADDERSEGMENT; - else if(s=="CABLETRAYSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CABLETRAYSEGMENT; - else if(s=="CABLETRUNKINGSEGMENT") return IfcCableCarrierSegmentTypeEnum::CABLETRUNKINGSEGMENT; - else if(s=="CONDUITSEGMENT" ) return IfcCableCarrierSegmentTypeEnum::CONDUITSEGMENT; - else if(s=="USERDEFINED" ) return IfcCableCarrierSegmentTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCableCarrierSegmentTypeEnum::NOTDEFINED; - else throw; -} -IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentTypeEnum::FromString(const std::string& s){ - if (s=="CABLESEGMENT" ) return IfcCableSegmentTypeEnum::CABLESEGMENT; - else if(s=="CONDUCTORSEGMENT") return IfcCableSegmentTypeEnum::CONDUCTORSEGMENT; - else if(s=="USERDEFINED" ) return IfcCableSegmentTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCableSegmentTypeEnum::NOTDEFINED; - else throw; -} -IfcChangeActionEnum::IfcChangeActionEnum IfcChangeActionEnum::FromString(const std::string& s){ - if (s=="NOCHANGE" ) return IfcChangeActionEnum::NOCHANGE; - else if(s=="MODIFIED" ) return IfcChangeActionEnum::MODIFIED; - else if(s=="ADDED" ) return IfcChangeActionEnum::ADDED; - else if(s=="DELETED" ) return IfcChangeActionEnum::DELETED; - else if(s=="MODIFIEDADDED" ) return IfcChangeActionEnum::MODIFIEDADDED; - else if(s=="MODIFIEDDELETED") return IfcChangeActionEnum::MODIFIEDDELETED; - else throw; -} -IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerTypeEnum::FromString(const std::string& s){ - if (s=="AIRCOOLED" ) return IfcChillerTypeEnum::AIRCOOLED; - else if(s=="WATERCOOLED" ) return IfcChillerTypeEnum::WATERCOOLED; - else if(s=="HEATRECOVERY") return IfcChillerTypeEnum::HEATRECOVERY; - else if(s=="USERDEFINED" ) return IfcChillerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcChillerTypeEnum::NOTDEFINED; - else throw; -} -IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilTypeEnum::FromString(const std::string& s){ - if (s=="DXCOOLINGCOIL" ) return IfcCoilTypeEnum::DXCOOLINGCOIL; - else if(s=="WATERCOOLINGCOIL" ) return IfcCoilTypeEnum::WATERCOOLINGCOIL; - else if(s=="STEAMHEATINGCOIL" ) return IfcCoilTypeEnum::STEAMHEATINGCOIL; - else if(s=="WATERHEATINGCOIL" ) return IfcCoilTypeEnum::WATERHEATINGCOIL; - else if(s=="ELECTRICHEATINGCOIL") return IfcCoilTypeEnum::ELECTRICHEATINGCOIL; - else if(s=="GASHEATINGCOIL" ) return IfcCoilTypeEnum::GASHEATINGCOIL; - else if(s=="USERDEFINED" ) return IfcCoilTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCoilTypeEnum::NOTDEFINED; - else throw; -} -IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnTypeEnum::FromString(const std::string& s){ - if (s=="COLUMN" ) return IfcColumnTypeEnum::COLUMN; - else if(s=="USERDEFINED") return IfcColumnTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcColumnTypeEnum::NOTDEFINED; - else throw; -} -IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorTypeEnum::FromString(const std::string& s){ - if (s=="DYNAMIC" ) return IfcCompressorTypeEnum::DYNAMIC; - else if(s=="RECIPROCATING" ) return IfcCompressorTypeEnum::RECIPROCATING; - else if(s=="ROTARY" ) return IfcCompressorTypeEnum::ROTARY; - else if(s=="SCROLL" ) return IfcCompressorTypeEnum::SCROLL; - else if(s=="TROCHOIDAL" ) return IfcCompressorTypeEnum::TROCHOIDAL; - else if(s=="SINGLESTAGE" ) return IfcCompressorTypeEnum::SINGLESTAGE; - else if(s=="BOOSTER" ) return IfcCompressorTypeEnum::BOOSTER; - else if(s=="OPENTYPE" ) return IfcCompressorTypeEnum::OPENTYPE; - else if(s=="HERMETIC" ) return IfcCompressorTypeEnum::HERMETIC; - else if(s=="SEMIHERMETIC" ) return IfcCompressorTypeEnum::SEMIHERMETIC; - else if(s=="WELDEDSHELLHERMETIC") return IfcCompressorTypeEnum::WELDEDSHELLHERMETIC; - else if(s=="ROLLINGPISTON" ) return IfcCompressorTypeEnum::ROLLINGPISTON; - else if(s=="ROTARYVANE" ) return IfcCompressorTypeEnum::ROTARYVANE; - else if(s=="SINGLESCREW" ) return IfcCompressorTypeEnum::SINGLESCREW; - else if(s=="TWINSCREW" ) return IfcCompressorTypeEnum::TWINSCREW; - else if(s=="USERDEFINED" ) return IfcCompressorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCompressorTypeEnum::NOTDEFINED; - else throw; -} -IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserTypeEnum::FromString(const std::string& s){ - if (s=="WATERCOOLEDSHELLTUBE" ) return IfcCondenserTypeEnum::WATERCOOLEDSHELLTUBE; - else if(s=="WATERCOOLEDSHELLCOIL" ) return IfcCondenserTypeEnum::WATERCOOLEDSHELLCOIL; - else if(s=="WATERCOOLEDTUBEINTUBE" ) return IfcCondenserTypeEnum::WATERCOOLEDTUBEINTUBE; - else if(s=="WATERCOOLEDBRAZEDPLATE") return IfcCondenserTypeEnum::WATERCOOLEDBRAZEDPLATE; - else if(s=="AIRCOOLED" ) return IfcCondenserTypeEnum::AIRCOOLED; - else if(s=="EVAPORATIVECOOLED" ) return IfcCondenserTypeEnum::EVAPORATIVECOOLED; - else if(s=="USERDEFINED" ) return IfcCondenserTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCondenserTypeEnum::NOTDEFINED; - else throw; -} -IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcConnectionTypeEnum::FromString(const std::string& s){ - if (s=="ATPATH" ) return IfcConnectionTypeEnum::ATPATH; - else if(s=="ATSTART" ) return IfcConnectionTypeEnum::ATSTART; - else if(s=="ATEND" ) return IfcConnectionTypeEnum::ATEND; - else if(s=="NOTDEFINED") return IfcConnectionTypeEnum::NOTDEFINED; - else throw; -} -IfcConstraintEnum::IfcConstraintEnum IfcConstraintEnum::FromString(const std::string& s){ - if (s=="HARD" ) return IfcConstraintEnum::HARD; - else if(s=="SOFT" ) return IfcConstraintEnum::SOFT; - else if(s=="ADVISORY" ) return IfcConstraintEnum::ADVISORY; - else if(s=="USERDEFINED") return IfcConstraintEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcConstraintEnum::NOTDEFINED; - else throw; -} -IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerTypeEnum::FromString(const std::string& s){ - if (s=="FLOATING" ) return IfcControllerTypeEnum::FLOATING; - else if(s=="PROPORTIONAL" ) return IfcControllerTypeEnum::PROPORTIONAL; - else if(s=="PROPORTIONALINTEGRAL" ) return IfcControllerTypeEnum::PROPORTIONALINTEGRAL; - else if(s=="PROPORTIONALINTEGRALDERIVATIVE") return IfcControllerTypeEnum::PROPORTIONALINTEGRALDERIVATIVE; - else if(s=="TIMEDTWOPOSITION" ) return IfcControllerTypeEnum::TIMEDTWOPOSITION; - else if(s=="TWOPOSITION" ) return IfcControllerTypeEnum::TWOPOSITION; - else if(s=="USERDEFINED" ) return IfcControllerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcControllerTypeEnum::NOTDEFINED; - else throw; -} -IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamTypeEnum::FromString(const std::string& s){ - if (s=="ACTIVE" ) return IfcCooledBeamTypeEnum::ACTIVE; - else if(s=="PASSIVE" ) return IfcCooledBeamTypeEnum::PASSIVE; - else if(s=="USERDEFINED") return IfcCooledBeamTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCooledBeamTypeEnum::NOTDEFINED; - else throw; -} -IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerTypeEnum::FromString(const std::string& s){ - if (s=="NATURALDRAFT" ) return IfcCoolingTowerTypeEnum::NATURALDRAFT; - else if(s=="MECHANICALINDUCEDDRAFT") return IfcCoolingTowerTypeEnum::MECHANICALINDUCEDDRAFT; - else if(s=="MECHANICALFORCEDDRAFT" ) return IfcCoolingTowerTypeEnum::MECHANICALFORCEDDRAFT; - else if(s=="USERDEFINED" ) return IfcCoolingTowerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCoolingTowerTypeEnum::NOTDEFINED; - else throw; -} -IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostScheduleTypeEnum::FromString(const std::string& s){ - if (s=="BUDGET" ) return IfcCostScheduleTypeEnum::BUDGET; - else if(s=="COSTPLAN" ) return IfcCostScheduleTypeEnum::COSTPLAN; - else if(s=="ESTIMATE" ) return IfcCostScheduleTypeEnum::ESTIMATE; - else if(s=="TENDER" ) return IfcCostScheduleTypeEnum::TENDER; - else if(s=="PRICEDBILLOFQUANTITIES" ) return IfcCostScheduleTypeEnum::PRICEDBILLOFQUANTITIES; - else if(s=="UNPRICEDBILLOFQUANTITIES") return IfcCostScheduleTypeEnum::UNPRICEDBILLOFQUANTITIES; - else if(s=="SCHEDULEOFRATES" ) return IfcCostScheduleTypeEnum::SCHEDULEOFRATES; - else if(s=="USERDEFINED" ) return IfcCostScheduleTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCostScheduleTypeEnum::NOTDEFINED; - else throw; -} -IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringTypeEnum::FromString(const std::string& s){ - if (s=="CEILING" ) return IfcCoveringTypeEnum::CEILING; - else if(s=="FLOORING" ) return IfcCoveringTypeEnum::FLOORING; - else if(s=="CLADDING" ) return IfcCoveringTypeEnum::CLADDING; - else if(s=="ROOFING" ) return IfcCoveringTypeEnum::ROOFING; - else if(s=="INSULATION" ) return IfcCoveringTypeEnum::INSULATION; - else if(s=="MEMBRANE" ) return IfcCoveringTypeEnum::MEMBRANE; - else if(s=="SLEEVING" ) return IfcCoveringTypeEnum::SLEEVING; - else if(s=="WRAPPING" ) return IfcCoveringTypeEnum::WRAPPING; - else if(s=="USERDEFINED") return IfcCoveringTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCoveringTypeEnum::NOTDEFINED; - else throw; -} -IfcCurrencyEnum::IfcCurrencyEnum IfcCurrencyEnum::FromString(const std::string& s){ - if (s=="AED") return IfcCurrencyEnum::AED; - else if(s=="AES") return IfcCurrencyEnum::AES; - else if(s=="ATS") return IfcCurrencyEnum::ATS; - else if(s=="AUD") return IfcCurrencyEnum::AUD; - else if(s=="BBD") return IfcCurrencyEnum::BBD; - else if(s=="BEG") return IfcCurrencyEnum::BEG; - else if(s=="BGL") return IfcCurrencyEnum::BGL; - else if(s=="BHD") return IfcCurrencyEnum::BHD; - else if(s=="BMD") return IfcCurrencyEnum::BMD; - else if(s=="BND") return IfcCurrencyEnum::BND; - else if(s=="BRL") return IfcCurrencyEnum::BRL; - else if(s=="BSD") return IfcCurrencyEnum::BSD; - else if(s=="BWP") return IfcCurrencyEnum::BWP; - else if(s=="BZD") return IfcCurrencyEnum::BZD; - else if(s=="CAD") return IfcCurrencyEnum::CAD; - else if(s=="CBD") return IfcCurrencyEnum::CBD; - else if(s=="CHF") return IfcCurrencyEnum::CHF; - else if(s=="CLP") return IfcCurrencyEnum::CLP; - else if(s=="CNY") return IfcCurrencyEnum::CNY; - else if(s=="CYS") return IfcCurrencyEnum::CYS; - else if(s=="CZK") return IfcCurrencyEnum::CZK; - else if(s=="DDP") return IfcCurrencyEnum::DDP; - else if(s=="DEM") return IfcCurrencyEnum::DEM; - else if(s=="DKK") return IfcCurrencyEnum::DKK; - else if(s=="EGL") return IfcCurrencyEnum::EGL; - else if(s=="EST") return IfcCurrencyEnum::EST; - else if(s=="EUR") return IfcCurrencyEnum::EUR; - else if(s=="FAK") return IfcCurrencyEnum::FAK; - else if(s=="FIM") return IfcCurrencyEnum::FIM; - else if(s=="FJD") return IfcCurrencyEnum::FJD; - else if(s=="FKP") return IfcCurrencyEnum::FKP; - else if(s=="FRF") return IfcCurrencyEnum::FRF; - else if(s=="GBP") return IfcCurrencyEnum::GBP; - else if(s=="GIP") return IfcCurrencyEnum::GIP; - else if(s=="GMD") return IfcCurrencyEnum::GMD; - else if(s=="GRX") return IfcCurrencyEnum::GRX; - else if(s=="HKD") return IfcCurrencyEnum::HKD; - else if(s=="HUF") return IfcCurrencyEnum::HUF; - else if(s=="ICK") return IfcCurrencyEnum::ICK; - else if(s=="IDR") return IfcCurrencyEnum::IDR; - else if(s=="ILS") return IfcCurrencyEnum::ILS; - else if(s=="INR") return IfcCurrencyEnum::INR; - else if(s=="IRP") return IfcCurrencyEnum::IRP; - else if(s=="ITL") return IfcCurrencyEnum::ITL; - else if(s=="JMD") return IfcCurrencyEnum::JMD; - else if(s=="JOD") return IfcCurrencyEnum::JOD; - else if(s=="JPY") return IfcCurrencyEnum::JPY; - else if(s=="KES") return IfcCurrencyEnum::KES; - else if(s=="KRW") return IfcCurrencyEnum::KRW; - else if(s=="KWD") return IfcCurrencyEnum::KWD; - else if(s=="KYD") return IfcCurrencyEnum::KYD; - else if(s=="LKR") return IfcCurrencyEnum::LKR; - else if(s=="LUF") return IfcCurrencyEnum::LUF; - else if(s=="MTL") return IfcCurrencyEnum::MTL; - else if(s=="MUR") return IfcCurrencyEnum::MUR; - else if(s=="MXN") return IfcCurrencyEnum::MXN; - else if(s=="MYR") return IfcCurrencyEnum::MYR; - else if(s=="NLG") return IfcCurrencyEnum::NLG; - else if(s=="NZD") return IfcCurrencyEnum::NZD; - else if(s=="OMR") return IfcCurrencyEnum::OMR; - else if(s=="PGK") return IfcCurrencyEnum::PGK; - else if(s=="PHP") return IfcCurrencyEnum::PHP; - else if(s=="PKR") return IfcCurrencyEnum::PKR; - else if(s=="PLN") return IfcCurrencyEnum::PLN; - else if(s=="PTN") return IfcCurrencyEnum::PTN; - else if(s=="QAR") return IfcCurrencyEnum::QAR; - else if(s=="RUR") return IfcCurrencyEnum::RUR; - else if(s=="SAR") return IfcCurrencyEnum::SAR; - else if(s=="SCR") return IfcCurrencyEnum::SCR; - else if(s=="SEK") return IfcCurrencyEnum::SEK; - else if(s=="SGD") return IfcCurrencyEnum::SGD; - else if(s=="SKP") return IfcCurrencyEnum::SKP; - else if(s=="THB") return IfcCurrencyEnum::THB; - else if(s=="TRL") return IfcCurrencyEnum::TRL; - else if(s=="TTD") return IfcCurrencyEnum::TTD; - else if(s=="TWD") return IfcCurrencyEnum::TWD; - else if(s=="USD") return IfcCurrencyEnum::USD; - else if(s=="VEB") return IfcCurrencyEnum::VEB; - else if(s=="VND") return IfcCurrencyEnum::VND; - else if(s=="XEU") return IfcCurrencyEnum::XEU; - else if(s=="ZAR") return IfcCurrencyEnum::ZAR; - else if(s=="ZWD") return IfcCurrencyEnum::ZWD; - else if(s=="NOK") return IfcCurrencyEnum::NOK; - else throw; -} -IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallTypeEnum::FromString(const std::string& s){ - if (s=="USERDEFINED") return IfcCurtainWallTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcCurtainWallTypeEnum::NOTDEFINED; - else throw; -} -IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperTypeEnum::FromString(const std::string& s){ - if (s=="CONTROLDAMPER" ) return IfcDamperTypeEnum::CONTROLDAMPER; - else if(s=="FIREDAMPER" ) return IfcDamperTypeEnum::FIREDAMPER; - else if(s=="SMOKEDAMPER" ) return IfcDamperTypeEnum::SMOKEDAMPER; - else if(s=="FIRESMOKEDAMPER" ) return IfcDamperTypeEnum::FIRESMOKEDAMPER; - else if(s=="BACKDRAFTDAMPER" ) return IfcDamperTypeEnum::BACKDRAFTDAMPER; - else if(s=="RELIEFDAMPER" ) return IfcDamperTypeEnum::RELIEFDAMPER; - else if(s=="BLASTDAMPER" ) return IfcDamperTypeEnum::BLASTDAMPER; - else if(s=="GRAVITYDAMPER" ) return IfcDamperTypeEnum::GRAVITYDAMPER; - else if(s=="GRAVITYRELIEFDAMPER") return IfcDamperTypeEnum::GRAVITYRELIEFDAMPER; - else if(s=="BALANCINGDAMPER" ) return IfcDamperTypeEnum::BALANCINGDAMPER; - else if(s=="FUMEHOODEXHAUST" ) return IfcDamperTypeEnum::FUMEHOODEXHAUST; - else if(s=="USERDEFINED" ) return IfcDamperTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDamperTypeEnum::NOTDEFINED; - else throw; -} -IfcDataOriginEnum::IfcDataOriginEnum IfcDataOriginEnum::FromString(const std::string& s){ - if (s=="MEASURED" ) return IfcDataOriginEnum::MEASURED; - else if(s=="PREDICTED" ) return IfcDataOriginEnum::PREDICTED; - else if(s=="SIMULATED" ) return IfcDataOriginEnum::SIMULATED; - else if(s=="USERDEFINED") return IfcDataOriginEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDataOriginEnum::NOTDEFINED; - else throw; -} -IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnitEnum::FromString(const std::string& s){ - if (s=="ANGULARVELOCITYUNIT" ) return IfcDerivedUnitEnum::ANGULARVELOCITYUNIT; - else if(s=="COMPOUNDPLANEANGLEUNIT" ) return IfcDerivedUnitEnum::COMPOUNDPLANEANGLEUNIT; - else if(s=="DYNAMICVISCOSITYUNIT" ) return IfcDerivedUnitEnum::DYNAMICVISCOSITYUNIT; - else if(s=="HEATFLUXDENSITYUNIT" ) return IfcDerivedUnitEnum::HEATFLUXDENSITYUNIT; - else if(s=="INTEGERCOUNTRATEUNIT" ) return IfcDerivedUnitEnum::INTEGERCOUNTRATEUNIT; - else if(s=="ISOTHERMALMOISTURECAPACITYUNIT" ) return IfcDerivedUnitEnum::ISOTHERMALMOISTURECAPACITYUNIT; - else if(s=="KINEMATICVISCOSITYUNIT" ) return IfcDerivedUnitEnum::KINEMATICVISCOSITYUNIT; - else if(s=="LINEARVELOCITYUNIT" ) return IfcDerivedUnitEnum::LINEARVELOCITYUNIT; - else if(s=="MASSDENSITYUNIT" ) return IfcDerivedUnitEnum::MASSDENSITYUNIT; - else if(s=="MASSFLOWRATEUNIT" ) return IfcDerivedUnitEnum::MASSFLOWRATEUNIT; - else if(s=="MOISTUREDIFFUSIVITYUNIT" ) return IfcDerivedUnitEnum::MOISTUREDIFFUSIVITYUNIT; - else if(s=="MOLECULARWEIGHTUNIT" ) return IfcDerivedUnitEnum::MOLECULARWEIGHTUNIT; - else if(s=="SPECIFICHEATCAPACITYUNIT" ) return IfcDerivedUnitEnum::SPECIFICHEATCAPACITYUNIT; - else if(s=="THERMALADMITTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALADMITTANCEUNIT; - else if(s=="THERMALCONDUCTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALCONDUCTANCEUNIT; - else if(s=="THERMALRESISTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALRESISTANCEUNIT; - else if(s=="THERMALTRANSMITTANCEUNIT" ) return IfcDerivedUnitEnum::THERMALTRANSMITTANCEUNIT; - else if(s=="VAPORPERMEABILITYUNIT" ) return IfcDerivedUnitEnum::VAPORPERMEABILITYUNIT; - else if(s=="VOLUMETRICFLOWRATEUNIT" ) return IfcDerivedUnitEnum::VOLUMETRICFLOWRATEUNIT; - else if(s=="ROTATIONALFREQUENCYUNIT" ) return IfcDerivedUnitEnum::ROTATIONALFREQUENCYUNIT; - else if(s=="TORQUEUNIT" ) return IfcDerivedUnitEnum::TORQUEUNIT; - else if(s=="MOMENTOFINERTIAUNIT" ) return IfcDerivedUnitEnum::MOMENTOFINERTIAUNIT; - else if(s=="LINEARMOMENTUNIT" ) return IfcDerivedUnitEnum::LINEARMOMENTUNIT; - else if(s=="LINEARFORCEUNIT" ) return IfcDerivedUnitEnum::LINEARFORCEUNIT; - else if(s=="PLANARFORCEUNIT" ) return IfcDerivedUnitEnum::PLANARFORCEUNIT; - else if(s=="MODULUSOFELASTICITYUNIT" ) return IfcDerivedUnitEnum::MODULUSOFELASTICITYUNIT; - else if(s=="SHEARMODULUSUNIT" ) return IfcDerivedUnitEnum::SHEARMODULUSUNIT; - else if(s=="LINEARSTIFFNESSUNIT" ) return IfcDerivedUnitEnum::LINEARSTIFFNESSUNIT; - else if(s=="ROTATIONALSTIFFNESSUNIT" ) return IfcDerivedUnitEnum::ROTATIONALSTIFFNESSUNIT; - else if(s=="MODULUSOFSUBGRADEREACTIONUNIT" ) return IfcDerivedUnitEnum::MODULUSOFSUBGRADEREACTIONUNIT; - else if(s=="ACCELERATIONUNIT" ) return IfcDerivedUnitEnum::ACCELERATIONUNIT; - else if(s=="CURVATUREUNIT" ) return IfcDerivedUnitEnum::CURVATUREUNIT; - else if(s=="HEATINGVALUEUNIT" ) return IfcDerivedUnitEnum::HEATINGVALUEUNIT; - else if(s=="IONCONCENTRATIONUNIT" ) return IfcDerivedUnitEnum::IONCONCENTRATIONUNIT; - else if(s=="LUMINOUSINTENSITYDISTRIBUTIONUNIT" ) return IfcDerivedUnitEnum::LUMINOUSINTENSITYDISTRIBUTIONUNIT; - else if(s=="MASSPERLENGTHUNIT" ) return IfcDerivedUnitEnum::MASSPERLENGTHUNIT; - else if(s=="MODULUSOFLINEARSUBGRADEREACTIONUNIT" ) return IfcDerivedUnitEnum::MODULUSOFLINEARSUBGRADEREACTIONUNIT; - else if(s=="MODULUSOFROTATIONALSUBGRADEREACTIONUNIT") return IfcDerivedUnitEnum::MODULUSOFROTATIONALSUBGRADEREACTIONUNIT; - else if(s=="PHUNIT" ) return IfcDerivedUnitEnum::PHUNIT; - else if(s=="ROTATIONALMASSUNIT" ) return IfcDerivedUnitEnum::ROTATIONALMASSUNIT; - else if(s=="SECTIONAREAINTEGRALUNIT" ) return IfcDerivedUnitEnum::SECTIONAREAINTEGRALUNIT; - else if(s=="SECTIONMODULUSUNIT" ) return IfcDerivedUnitEnum::SECTIONMODULUSUNIT; - else if(s=="SOUNDPOWERUNIT" ) return IfcDerivedUnitEnum::SOUNDPOWERUNIT; - else if(s=="SOUNDPRESSUREUNIT" ) return IfcDerivedUnitEnum::SOUNDPRESSUREUNIT; - else if(s=="TEMPERATUREGRADIENTUNIT" ) return IfcDerivedUnitEnum::TEMPERATUREGRADIENTUNIT; - else if(s=="THERMALEXPANSIONCOEFFICIENTUNIT" ) return IfcDerivedUnitEnum::THERMALEXPANSIONCOEFFICIENTUNIT; - else if(s=="WARPINGCONSTANTUNIT" ) return IfcDerivedUnitEnum::WARPINGCONSTANTUNIT; - else if(s=="WARPINGMOMENTUNIT" ) return IfcDerivedUnitEnum::WARPINGMOMENTUNIT; - else if(s=="USERDEFINED" ) return IfcDerivedUnitEnum::USERDEFINED; - else throw; -} -IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionExtentUsage::FromString(const std::string& s){ - if (s=="ORIGIN") return IfcDimensionExtentUsage::ORIGIN; - else if(s=="TARGET") return IfcDimensionExtentUsage::TARGET; - else throw; -} -IfcDirectionSenseEnum::IfcDirectionSenseEnum IfcDirectionSenseEnum::FromString(const std::string& s){ - if (s=="POSITIVE") return IfcDirectionSenseEnum::POSITIVE; - else if(s=="NEGATIVE") return IfcDirectionSenseEnum::NEGATIVE; - else throw; -} -IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementTypeEnum::FromString(const std::string& s){ - if (s=="FORMEDDUCT" ) return IfcDistributionChamberElementTypeEnum::FORMEDDUCT; - else if(s=="INSPECTIONCHAMBER") return IfcDistributionChamberElementTypeEnum::INSPECTIONCHAMBER; - else if(s=="INSPECTIONPIT" ) return IfcDistributionChamberElementTypeEnum::INSPECTIONPIT; - else if(s=="MANHOLE" ) return IfcDistributionChamberElementTypeEnum::MANHOLE; - else if(s=="METERCHAMBER" ) return IfcDistributionChamberElementTypeEnum::METERCHAMBER; - else if(s=="SUMP" ) return IfcDistributionChamberElementTypeEnum::SUMP; - else if(s=="TRENCH" ) return IfcDistributionChamberElementTypeEnum::TRENCH; - else if(s=="VALVECHAMBER" ) return IfcDistributionChamberElementTypeEnum::VALVECHAMBER; - else if(s=="USERDEFINED" ) return IfcDistributionChamberElementTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDistributionChamberElementTypeEnum::NOTDEFINED; - else throw; -} -IfcDocumentConfidentialityEnum::IfcDocumentConfidentialityEnum IfcDocumentConfidentialityEnum::FromString(const std::string& s){ - if (s=="PUBLIC" ) return IfcDocumentConfidentialityEnum::PUBLIC; - else if(s=="RESTRICTED" ) return IfcDocumentConfidentialityEnum::RESTRICTED; - else if(s=="CONFIDENTIAL") return IfcDocumentConfidentialityEnum::CONFIDENTIAL; - else if(s=="PERSONAL" ) return IfcDocumentConfidentialityEnum::PERSONAL; - else if(s=="USERDEFINED" ) return IfcDocumentConfidentialityEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDocumentConfidentialityEnum::NOTDEFINED; - else throw; -} -IfcDocumentStatusEnum::IfcDocumentStatusEnum IfcDocumentStatusEnum::FromString(const std::string& s){ - if (s=="DRAFT" ) return IfcDocumentStatusEnum::DRAFT; - else if(s=="FINALDRAFT") return IfcDocumentStatusEnum::FINALDRAFT; - else if(s=="FINAL" ) return IfcDocumentStatusEnum::FINAL; - else if(s=="REVISION" ) return IfcDocumentStatusEnum::REVISION; - else if(s=="NOTDEFINED") return IfcDocumentStatusEnum::NOTDEFINED; - else throw; -} -IfcDoorPanelOperationEnum::IfcDoorPanelOperationEnum IfcDoorPanelOperationEnum::FromString(const std::string& s){ - if (s=="SWINGING" ) return IfcDoorPanelOperationEnum::SWINGING; - else if(s=="DOUBLE_ACTING") return IfcDoorPanelOperationEnum::DOUBLE_ACTING; - else if(s=="SLIDING" ) return IfcDoorPanelOperationEnum::SLIDING; - else if(s=="FOLDING" ) return IfcDoorPanelOperationEnum::FOLDING; - else if(s=="REVOLVING" ) return IfcDoorPanelOperationEnum::REVOLVING; - else if(s=="ROLLINGUP" ) return IfcDoorPanelOperationEnum::ROLLINGUP; - else if(s=="USERDEFINED" ) return IfcDoorPanelOperationEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDoorPanelOperationEnum::NOTDEFINED; - else throw; -} -IfcDoorPanelPositionEnum::IfcDoorPanelPositionEnum IfcDoorPanelPositionEnum::FromString(const std::string& s){ - if (s=="LEFT" ) return IfcDoorPanelPositionEnum::LEFT; - else if(s=="MIDDLE" ) return IfcDoorPanelPositionEnum::MIDDLE; - else if(s=="RIGHT" ) return IfcDoorPanelPositionEnum::RIGHT; - else if(s=="NOTDEFINED") return IfcDoorPanelPositionEnum::NOTDEFINED; - else throw; -} -IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyleConstructionEnum::FromString(const std::string& s){ - if (s=="ALUMINIUM" ) return IfcDoorStyleConstructionEnum::ALUMINIUM; - else if(s=="HIGH_GRADE_STEEL" ) return IfcDoorStyleConstructionEnum::HIGH_GRADE_STEEL; - else if(s=="STEEL" ) return IfcDoorStyleConstructionEnum::STEEL; - else if(s=="WOOD" ) return IfcDoorStyleConstructionEnum::WOOD; - else if(s=="ALUMINIUM_WOOD" ) return IfcDoorStyleConstructionEnum::ALUMINIUM_WOOD; - else if(s=="ALUMINIUM_PLASTIC") return IfcDoorStyleConstructionEnum::ALUMINIUM_PLASTIC; - else if(s=="PLASTIC" ) return IfcDoorStyleConstructionEnum::PLASTIC; - else if(s=="USERDEFINED" ) return IfcDoorStyleConstructionEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDoorStyleConstructionEnum::NOTDEFINED; - else throw; -} -IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyleOperationEnum::FromString(const std::string& s){ - if (s=="SINGLE_SWING_LEFT" ) return IfcDoorStyleOperationEnum::SINGLE_SWING_LEFT; - else if(s=="SINGLE_SWING_RIGHT" ) return IfcDoorStyleOperationEnum::SINGLE_SWING_RIGHT; - else if(s=="DOUBLE_DOOR_SINGLE_SWING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING; - else if(s=="DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_LEFT; - else if(s=="DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT") return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SINGLE_SWING_OPPOSITE_RIGHT; - else if(s=="DOUBLE_SWING_LEFT" ) return IfcDoorStyleOperationEnum::DOUBLE_SWING_LEFT; - else if(s=="DOUBLE_SWING_RIGHT" ) return IfcDoorStyleOperationEnum::DOUBLE_SWING_RIGHT; - else if(s=="DOUBLE_DOOR_DOUBLE_SWING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_DOUBLE_SWING; - else if(s=="SLIDING_TO_LEFT" ) return IfcDoorStyleOperationEnum::SLIDING_TO_LEFT; - else if(s=="SLIDING_TO_RIGHT" ) return IfcDoorStyleOperationEnum::SLIDING_TO_RIGHT; - else if(s=="DOUBLE_DOOR_SLIDING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_SLIDING; - else if(s=="FOLDING_TO_LEFT" ) return IfcDoorStyleOperationEnum::FOLDING_TO_LEFT; - else if(s=="FOLDING_TO_RIGHT" ) return IfcDoorStyleOperationEnum::FOLDING_TO_RIGHT; - else if(s=="DOUBLE_DOOR_FOLDING" ) return IfcDoorStyleOperationEnum::DOUBLE_DOOR_FOLDING; - else if(s=="REVOLVING" ) return IfcDoorStyleOperationEnum::REVOLVING; - else if(s=="ROLLINGUP" ) return IfcDoorStyleOperationEnum::ROLLINGUP; - else if(s=="USERDEFINED" ) return IfcDoorStyleOperationEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDoorStyleOperationEnum::NOTDEFINED; - else throw; -} -IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingTypeEnum::FromString(const std::string& s){ - if (s=="BEND" ) return IfcDuctFittingTypeEnum::BEND; - else if(s=="CONNECTOR" ) return IfcDuctFittingTypeEnum::CONNECTOR; - else if(s=="ENTRY" ) return IfcDuctFittingTypeEnum::ENTRY; - else if(s=="EXIT" ) return IfcDuctFittingTypeEnum::EXIT; - else if(s=="JUNCTION" ) return IfcDuctFittingTypeEnum::JUNCTION; - else if(s=="OBSTRUCTION") return IfcDuctFittingTypeEnum::OBSTRUCTION; - else if(s=="TRANSITION" ) return IfcDuctFittingTypeEnum::TRANSITION; - else if(s=="USERDEFINED") return IfcDuctFittingTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDuctFittingTypeEnum::NOTDEFINED; - else throw; -} -IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentTypeEnum::FromString(const std::string& s){ - if (s=="RIGIDSEGMENT" ) return IfcDuctSegmentTypeEnum::RIGIDSEGMENT; - else if(s=="FLEXIBLESEGMENT") return IfcDuctSegmentTypeEnum::FLEXIBLESEGMENT; - else if(s=="USERDEFINED" ) return IfcDuctSegmentTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDuctSegmentTypeEnum::NOTDEFINED; - else throw; -} -IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerTypeEnum::FromString(const std::string& s){ - if (s=="FLATOVAL" ) return IfcDuctSilencerTypeEnum::FLATOVAL; - else if(s=="RECTANGULAR") return IfcDuctSilencerTypeEnum::RECTANGULAR; - else if(s=="ROUND" ) return IfcDuctSilencerTypeEnum::ROUND; - else if(s=="USERDEFINED") return IfcDuctSilencerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcDuctSilencerTypeEnum::NOTDEFINED; - else throw; -} -IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceTypeEnum::FromString(const std::string& s){ - if (s=="COMPUTER" ) return IfcElectricApplianceTypeEnum::COMPUTER; - else if(s=="DIRECTWATERHEATER" ) return IfcElectricApplianceTypeEnum::DIRECTWATERHEATER; - else if(s=="DISHWASHER" ) return IfcElectricApplianceTypeEnum::DISHWASHER; - else if(s=="ELECTRICCOOKER" ) return IfcElectricApplianceTypeEnum::ELECTRICCOOKER; - else if(s=="ELECTRICHEATER" ) return IfcElectricApplianceTypeEnum::ELECTRICHEATER; - else if(s=="FACSIMILE" ) return IfcElectricApplianceTypeEnum::FACSIMILE; - else if(s=="FREESTANDINGFAN" ) return IfcElectricApplianceTypeEnum::FREESTANDINGFAN; - else if(s=="FREEZER" ) return IfcElectricApplianceTypeEnum::FREEZER; - else if(s=="FRIDGE_FREEZER" ) return IfcElectricApplianceTypeEnum::FRIDGE_FREEZER; - else if(s=="HANDDRYER" ) return IfcElectricApplianceTypeEnum::HANDDRYER; - else if(s=="INDIRECTWATERHEATER") return IfcElectricApplianceTypeEnum::INDIRECTWATERHEATER; - else if(s=="MICROWAVE" ) return IfcElectricApplianceTypeEnum::MICROWAVE; - else if(s=="PHOTOCOPIER" ) return IfcElectricApplianceTypeEnum::PHOTOCOPIER; - else if(s=="PRINTER" ) return IfcElectricApplianceTypeEnum::PRINTER; - else if(s=="REFRIGERATOR" ) return IfcElectricApplianceTypeEnum::REFRIGERATOR; - else if(s=="RADIANTHEATER" ) return IfcElectricApplianceTypeEnum::RADIANTHEATER; - else if(s=="SCANNER" ) return IfcElectricApplianceTypeEnum::SCANNER; - else if(s=="TELEPHONE" ) return IfcElectricApplianceTypeEnum::TELEPHONE; - else if(s=="TUMBLEDRYER" ) return IfcElectricApplianceTypeEnum::TUMBLEDRYER; - else if(s=="TV" ) return IfcElectricApplianceTypeEnum::TV; - else if(s=="VENDINGMACHINE" ) return IfcElectricApplianceTypeEnum::VENDINGMACHINE; - else if(s=="WASHINGMACHINE" ) return IfcElectricApplianceTypeEnum::WASHINGMACHINE; - else if(s=="WATERHEATER" ) return IfcElectricApplianceTypeEnum::WATERHEATER; - else if(s=="WATERCOOLER" ) return IfcElectricApplianceTypeEnum::WATERCOOLER; - else if(s=="USERDEFINED" ) return IfcElectricApplianceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricApplianceTypeEnum::NOTDEFINED; - else throw; -} -IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricCurrentEnum::FromString(const std::string& s){ - if (s=="ALTERNATING") return IfcElectricCurrentEnum::ALTERNATING; - else if(s=="DIRECT" ) return IfcElectricCurrentEnum::DIRECT; - else if(s=="NOTDEFINED" ) return IfcElectricCurrentEnum::NOTDEFINED; - else throw; -} -IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPointFunctionEnum::FromString(const std::string& s){ - if (s=="ALARMPANEL" ) return IfcElectricDistributionPointFunctionEnum::ALARMPANEL; - else if(s=="CONSUMERUNIT" ) return IfcElectricDistributionPointFunctionEnum::CONSUMERUNIT; - else if(s=="CONTROLPANEL" ) return IfcElectricDistributionPointFunctionEnum::CONTROLPANEL; - else if(s=="DISTRIBUTIONBOARD" ) return IfcElectricDistributionPointFunctionEnum::DISTRIBUTIONBOARD; - else if(s=="GASDETECTORPANEL" ) return IfcElectricDistributionPointFunctionEnum::GASDETECTORPANEL; - else if(s=="INDICATORPANEL" ) return IfcElectricDistributionPointFunctionEnum::INDICATORPANEL; - else if(s=="MIMICPANEL" ) return IfcElectricDistributionPointFunctionEnum::MIMICPANEL; - else if(s=="MOTORCONTROLCENTRE") return IfcElectricDistributionPointFunctionEnum::MOTORCONTROLCENTRE; - else if(s=="SWITCHBOARD" ) return IfcElectricDistributionPointFunctionEnum::SWITCHBOARD; - else if(s=="USERDEFINED" ) return IfcElectricDistributionPointFunctionEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricDistributionPointFunctionEnum::NOTDEFINED; - else throw; -} -IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceTypeEnum::FromString(const std::string& s){ - if (s=="BATTERY" ) return IfcElectricFlowStorageDeviceTypeEnum::BATTERY; - else if(s=="CAPACITORBANK" ) return IfcElectricFlowStorageDeviceTypeEnum::CAPACITORBANK; - else if(s=="HARMONICFILTER") return IfcElectricFlowStorageDeviceTypeEnum::HARMONICFILTER; - else if(s=="INDUCTORBANK" ) return IfcElectricFlowStorageDeviceTypeEnum::INDUCTORBANK; - else if(s=="UPS" ) return IfcElectricFlowStorageDeviceTypeEnum::UPS; - else if(s=="USERDEFINED" ) return IfcElectricFlowStorageDeviceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricFlowStorageDeviceTypeEnum::NOTDEFINED; - else throw; -} -IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorTypeEnum::FromString(const std::string& s){ - if (s=="USERDEFINED") return IfcElectricGeneratorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricGeneratorTypeEnum::NOTDEFINED; - else throw; -} -IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterTypeEnum::FromString(const std::string& s){ - if (s=="ELECTRICPOINTHEATER") return IfcElectricHeaterTypeEnum::ELECTRICPOINTHEATER; - else if(s=="ELECTRICCABLEHEATER") return IfcElectricHeaterTypeEnum::ELECTRICCABLEHEATER; - else if(s=="ELECTRICMATHEATER" ) return IfcElectricHeaterTypeEnum::ELECTRICMATHEATER; - else if(s=="USERDEFINED" ) return IfcElectricHeaterTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricHeaterTypeEnum::NOTDEFINED; - else throw; -} -IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorTypeEnum::FromString(const std::string& s){ - if (s=="DC" ) return IfcElectricMotorTypeEnum::DC; - else if(s=="INDUCTION" ) return IfcElectricMotorTypeEnum::INDUCTION; - else if(s=="POLYPHASE" ) return IfcElectricMotorTypeEnum::POLYPHASE; - else if(s=="RELUCTANCESYNCHRONOUS") return IfcElectricMotorTypeEnum::RELUCTANCESYNCHRONOUS; - else if(s=="SYNCHRONOUS" ) return IfcElectricMotorTypeEnum::SYNCHRONOUS; - else if(s=="USERDEFINED" ) return IfcElectricMotorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricMotorTypeEnum::NOTDEFINED; - else throw; -} -IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlTypeEnum::FromString(const std::string& s){ - if (s=="TIMECLOCK" ) return IfcElectricTimeControlTypeEnum::TIMECLOCK; - else if(s=="TIMEDELAY" ) return IfcElectricTimeControlTypeEnum::TIMEDELAY; - else if(s=="RELAY" ) return IfcElectricTimeControlTypeEnum::RELAY; - else if(s=="USERDEFINED") return IfcElectricTimeControlTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElectricTimeControlTypeEnum::NOTDEFINED; - else throw; -} -IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssemblyTypeEnum::FromString(const std::string& s){ - if (s=="ACCESSORY_ASSEMBLY") return IfcElementAssemblyTypeEnum::ACCESSORY_ASSEMBLY; - else if(s=="ARCH" ) return IfcElementAssemblyTypeEnum::ARCH; - else if(s=="BEAM_GRID" ) return IfcElementAssemblyTypeEnum::BEAM_GRID; - else if(s=="BRACED_FRAME" ) return IfcElementAssemblyTypeEnum::BRACED_FRAME; - else if(s=="GIRDER" ) return IfcElementAssemblyTypeEnum::GIRDER; - else if(s=="REINFORCEMENT_UNIT") return IfcElementAssemblyTypeEnum::REINFORCEMENT_UNIT; - else if(s=="RIGID_FRAME" ) return IfcElementAssemblyTypeEnum::RIGID_FRAME; - else if(s=="SLAB_FIELD" ) return IfcElementAssemblyTypeEnum::SLAB_FIELD; - else if(s=="TRUSS" ) return IfcElementAssemblyTypeEnum::TRUSS; - else if(s=="USERDEFINED" ) return IfcElementAssemblyTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcElementAssemblyTypeEnum::NOTDEFINED; - else throw; -} -IfcElementCompositionEnum::IfcElementCompositionEnum IfcElementCompositionEnum::FromString(const std::string& s){ - if (s=="COMPLEX") return IfcElementCompositionEnum::COMPLEX; - else if(s=="ELEMENT") return IfcElementCompositionEnum::ELEMENT; - else if(s=="PARTIAL") return IfcElementCompositionEnum::PARTIAL; - else throw; -} -IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergySequenceEnum::FromString(const std::string& s){ - if (s=="PRIMARY" ) return IfcEnergySequenceEnum::PRIMARY; - else if(s=="SECONDARY" ) return IfcEnergySequenceEnum::SECONDARY; - else if(s=="TERTIARY" ) return IfcEnergySequenceEnum::TERTIARY; - else if(s=="AUXILIARY" ) return IfcEnergySequenceEnum::AUXILIARY; - else if(s=="USERDEFINED") return IfcEnergySequenceEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcEnergySequenceEnum::NOTDEFINED; - else throw; -} -IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactCategoryEnum::FromString(const std::string& s){ - if (s=="COMBINEDVALUE" ) return IfcEnvironmentalImpactCategoryEnum::COMBINEDVALUE; - else if(s=="DISPOSAL" ) return IfcEnvironmentalImpactCategoryEnum::DISPOSAL; - else if(s=="EXTRACTION" ) return IfcEnvironmentalImpactCategoryEnum::EXTRACTION; - else if(s=="INSTALLATION" ) return IfcEnvironmentalImpactCategoryEnum::INSTALLATION; - else if(s=="MANUFACTURE" ) return IfcEnvironmentalImpactCategoryEnum::MANUFACTURE; - else if(s=="TRANSPORTATION") return IfcEnvironmentalImpactCategoryEnum::TRANSPORTATION; - else if(s=="USERDEFINED" ) return IfcEnvironmentalImpactCategoryEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcEnvironmentalImpactCategoryEnum::NOTDEFINED; - else throw; -} -IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerTypeEnum::FromString(const std::string& s){ - if (s=="DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVERANDOMMEDIAAIRCOOLER; - else if(s=="DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVERIGIDMEDIAAIRCOOLER; - else if(s=="DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVESLINGERSPACKAGEDAIRCOOLER; - else if(s=="DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVEPACKAGEDROTARYAIRCOOLER; - else if(s=="DIRECTEVAPORATIVEAIRWASHER" ) return IfcEvaporativeCoolerTypeEnum::DIRECTEVAPORATIVEAIRWASHER; - else if(s=="INDIRECTEVAPORATIVEPACKAGEAIRCOOLER" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVEPACKAGEAIRCOOLER; - else if(s=="INDIRECTEVAPORATIVEWETCOIL" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVEWETCOIL; - else if(s=="INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER") return IfcEvaporativeCoolerTypeEnum::INDIRECTEVAPORATIVECOOLINGTOWERORCOILCOOLER; - else if(s=="INDIRECTDIRECTCOMBINATION" ) return IfcEvaporativeCoolerTypeEnum::INDIRECTDIRECTCOMBINATION; - else if(s=="USERDEFINED" ) return IfcEvaporativeCoolerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcEvaporativeCoolerTypeEnum::NOTDEFINED; - else throw; -} -IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorTypeEnum::FromString(const std::string& s){ - if (s=="DIRECTEXPANSIONSHELLANDTUBE") return IfcEvaporatorTypeEnum::DIRECTEXPANSIONSHELLANDTUBE; - else if(s=="DIRECTEXPANSIONTUBEINTUBE" ) return IfcEvaporatorTypeEnum::DIRECTEXPANSIONTUBEINTUBE; - else if(s=="DIRECTEXPANSIONBRAZEDPLATE" ) return IfcEvaporatorTypeEnum::DIRECTEXPANSIONBRAZEDPLATE; - else if(s=="FLOODEDSHELLANDTUBE" ) return IfcEvaporatorTypeEnum::FLOODEDSHELLANDTUBE; - else if(s=="SHELLANDCOIL" ) return IfcEvaporatorTypeEnum::SHELLANDCOIL; - else if(s=="USERDEFINED" ) return IfcEvaporatorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcEvaporatorTypeEnum::NOTDEFINED; - else throw; -} -IfcFanTypeEnum::IfcFanTypeEnum IfcFanTypeEnum::FromString(const std::string& s){ - if (s=="CENTRIFUGALFORWARDCURVED" ) return IfcFanTypeEnum::CENTRIFUGALFORWARDCURVED; - else if(s=="CENTRIFUGALRADIAL" ) return IfcFanTypeEnum::CENTRIFUGALRADIAL; - else if(s=="CENTRIFUGALBACKWARDINCLINEDCURVED") return IfcFanTypeEnum::CENTRIFUGALBACKWARDINCLINEDCURVED; - else if(s=="CENTRIFUGALAIRFOIL" ) return IfcFanTypeEnum::CENTRIFUGALAIRFOIL; - else if(s=="TUBEAXIAL" ) return IfcFanTypeEnum::TUBEAXIAL; - else if(s=="VANEAXIAL" ) return IfcFanTypeEnum::VANEAXIAL; - else if(s=="PROPELLORAXIAL" ) return IfcFanTypeEnum::PROPELLORAXIAL; - else if(s=="USERDEFINED" ) return IfcFanTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcFanTypeEnum::NOTDEFINED; - else throw; -} -IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterTypeEnum::FromString(const std::string& s){ - if (s=="AIRPARTICLEFILTER") return IfcFilterTypeEnum::AIRPARTICLEFILTER; - else if(s=="ODORFILTER" ) return IfcFilterTypeEnum::ODORFILTER; - else if(s=="OILFILTER" ) return IfcFilterTypeEnum::OILFILTER; - else if(s=="STRAINER" ) return IfcFilterTypeEnum::STRAINER; - else if(s=="WATERFILTER" ) return IfcFilterTypeEnum::WATERFILTER; - else if(s=="USERDEFINED" ) return IfcFilterTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcFilterTypeEnum::NOTDEFINED; - else throw; -} -IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalTypeEnum::FromString(const std::string& s){ - if (s=="BREECHINGINLET" ) return IfcFireSuppressionTerminalTypeEnum::BREECHINGINLET; - else if(s=="FIREHYDRANT" ) return IfcFireSuppressionTerminalTypeEnum::FIREHYDRANT; - else if(s=="HOSEREEL" ) return IfcFireSuppressionTerminalTypeEnum::HOSEREEL; - else if(s=="SPRINKLER" ) return IfcFireSuppressionTerminalTypeEnum::SPRINKLER; - else if(s=="SPRINKLERDEFLECTOR") return IfcFireSuppressionTerminalTypeEnum::SPRINKLERDEFLECTOR; - else if(s=="USERDEFINED" ) return IfcFireSuppressionTerminalTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcFireSuppressionTerminalTypeEnum::NOTDEFINED; - else throw; -} -IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcFlowDirectionEnum::FromString(const std::string& s){ - if (s=="SOURCE" ) return IfcFlowDirectionEnum::SOURCE; - else if(s=="SINK" ) return IfcFlowDirectionEnum::SINK; - else if(s=="SOURCEANDSINK") return IfcFlowDirectionEnum::SOURCEANDSINK; - else if(s=="NOTDEFINED" ) return IfcFlowDirectionEnum::NOTDEFINED; - else throw; -} -IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentTypeEnum::FromString(const std::string& s){ - if (s=="PRESSUREGAUGE" ) return IfcFlowInstrumentTypeEnum::PRESSUREGAUGE; - else if(s=="THERMOMETER" ) return IfcFlowInstrumentTypeEnum::THERMOMETER; - else if(s=="AMMETER" ) return IfcFlowInstrumentTypeEnum::AMMETER; - else if(s=="FREQUENCYMETER" ) return IfcFlowInstrumentTypeEnum::FREQUENCYMETER; - else if(s=="POWERFACTORMETER") return IfcFlowInstrumentTypeEnum::POWERFACTORMETER; - else if(s=="PHASEANGLEMETER" ) return IfcFlowInstrumentTypeEnum::PHASEANGLEMETER; - else if(s=="VOLTMETER_PEAK" ) return IfcFlowInstrumentTypeEnum::VOLTMETER_PEAK; - else if(s=="VOLTMETER_RMS" ) return IfcFlowInstrumentTypeEnum::VOLTMETER_RMS; - else if(s=="USERDEFINED" ) return IfcFlowInstrumentTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcFlowInstrumentTypeEnum::NOTDEFINED; - else throw; -} -IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterTypeEnum::FromString(const std::string& s){ - if (s=="ELECTRICMETER") return IfcFlowMeterTypeEnum::ELECTRICMETER; - else if(s=="ENERGYMETER" ) return IfcFlowMeterTypeEnum::ENERGYMETER; - else if(s=="FLOWMETER" ) return IfcFlowMeterTypeEnum::FLOWMETER; - else if(s=="GASMETER" ) return IfcFlowMeterTypeEnum::GASMETER; - else if(s=="OILMETER" ) return IfcFlowMeterTypeEnum::OILMETER; - else if(s=="WATERMETER" ) return IfcFlowMeterTypeEnum::WATERMETER; - else if(s=="USERDEFINED" ) return IfcFlowMeterTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcFlowMeterTypeEnum::NOTDEFINED; - else throw; -} -IfcFootingTypeEnum::IfcFootingTypeEnum IfcFootingTypeEnum::FromString(const std::string& s){ - if (s=="FOOTING_BEAM" ) return IfcFootingTypeEnum::FOOTING_BEAM; - else if(s=="PAD_FOOTING" ) return IfcFootingTypeEnum::PAD_FOOTING; - else if(s=="PILE_CAP" ) return IfcFootingTypeEnum::PILE_CAP; - else if(s=="STRIP_FOOTING") return IfcFootingTypeEnum::STRIP_FOOTING; - else if(s=="USERDEFINED" ) return IfcFootingTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcFootingTypeEnum::NOTDEFINED; - else throw; -} -IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalTypeEnum::FromString(const std::string& s){ - if (s=="GASAPPLIANCE") return IfcGasTerminalTypeEnum::GASAPPLIANCE; - else if(s=="GASBOOSTER" ) return IfcGasTerminalTypeEnum::GASBOOSTER; - else if(s=="GASBURNER" ) return IfcGasTerminalTypeEnum::GASBURNER; - else if(s=="USERDEFINED" ) return IfcGasTerminalTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcGasTerminalTypeEnum::NOTDEFINED; - else throw; -} -IfcGeometricProjectionEnum::IfcGeometricProjectionEnum IfcGeometricProjectionEnum::FromString(const std::string& s){ - if (s=="GRAPH_VIEW" ) return IfcGeometricProjectionEnum::GRAPH_VIEW; - else if(s=="SKETCH_VIEW" ) return IfcGeometricProjectionEnum::SKETCH_VIEW; - else if(s=="MODEL_VIEW" ) return IfcGeometricProjectionEnum::MODEL_VIEW; - else if(s=="PLAN_VIEW" ) return IfcGeometricProjectionEnum::PLAN_VIEW; - else if(s=="REFLECTED_PLAN_VIEW") return IfcGeometricProjectionEnum::REFLECTED_PLAN_VIEW; - else if(s=="SECTION_VIEW" ) return IfcGeometricProjectionEnum::SECTION_VIEW; - else if(s=="ELEVATION_VIEW" ) return IfcGeometricProjectionEnum::ELEVATION_VIEW; - else if(s=="USERDEFINED" ) return IfcGeometricProjectionEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcGeometricProjectionEnum::NOTDEFINED; - else throw; -} -IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcGlobalOrLocalEnum::FromString(const std::string& s){ - if (s=="GLOBAL_COORDS") return IfcGlobalOrLocalEnum::GLOBAL_COORDS; - else if(s=="LOCAL_COORDS" ) return IfcGlobalOrLocalEnum::LOCAL_COORDS; - else throw; -} -IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerTypeEnum::FromString(const std::string& s){ - if (s=="PLATE" ) return IfcHeatExchangerTypeEnum::PLATE; - else if(s=="SHELLANDTUBE") return IfcHeatExchangerTypeEnum::SHELLANDTUBE; - else if(s=="USERDEFINED" ) return IfcHeatExchangerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcHeatExchangerTypeEnum::NOTDEFINED; - else throw; -} -IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierTypeEnum::FromString(const std::string& s){ - if (s=="STEAMINJECTION" ) return IfcHumidifierTypeEnum::STEAMINJECTION; - else if(s=="ADIABATICAIRWASHER" ) return IfcHumidifierTypeEnum::ADIABATICAIRWASHER; - else if(s=="ADIABATICPAN" ) return IfcHumidifierTypeEnum::ADIABATICPAN; - else if(s=="ADIABATICWETTEDELEMENT" ) return IfcHumidifierTypeEnum::ADIABATICWETTEDELEMENT; - else if(s=="ADIABATICATOMIZING" ) return IfcHumidifierTypeEnum::ADIABATICATOMIZING; - else if(s=="ADIABATICULTRASONIC" ) return IfcHumidifierTypeEnum::ADIABATICULTRASONIC; - else if(s=="ADIABATICRIGIDMEDIA" ) return IfcHumidifierTypeEnum::ADIABATICRIGIDMEDIA; - else if(s=="ADIABATICCOMPRESSEDAIRNOZZLE") return IfcHumidifierTypeEnum::ADIABATICCOMPRESSEDAIRNOZZLE; - else if(s=="ASSISTEDELECTRIC" ) return IfcHumidifierTypeEnum::ASSISTEDELECTRIC; - else if(s=="ASSISTEDNATURALGAS" ) return IfcHumidifierTypeEnum::ASSISTEDNATURALGAS; - else if(s=="ASSISTEDPROPANE" ) return IfcHumidifierTypeEnum::ASSISTEDPROPANE; - else if(s=="ASSISTEDBUTANE" ) return IfcHumidifierTypeEnum::ASSISTEDBUTANE; - else if(s=="ASSISTEDSTEAM" ) return IfcHumidifierTypeEnum::ASSISTEDSTEAM; - else if(s=="USERDEFINED" ) return IfcHumidifierTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcHumidifierTypeEnum::NOTDEFINED; - else throw; -} -IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcInternalOrExternalEnum::FromString(const std::string& s){ - if (s=="INTERNAL" ) return IfcInternalOrExternalEnum::INTERNAL; - else if(s=="EXTERNAL" ) return IfcInternalOrExternalEnum::EXTERNAL; - else if(s=="NOTDEFINED") return IfcInternalOrExternalEnum::NOTDEFINED; - else throw; -} -IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventoryTypeEnum::FromString(const std::string& s){ - if (s=="ASSETINVENTORY" ) return IfcInventoryTypeEnum::ASSETINVENTORY; - else if(s=="SPACEINVENTORY" ) return IfcInventoryTypeEnum::SPACEINVENTORY; - else if(s=="FURNITUREINVENTORY") return IfcInventoryTypeEnum::FURNITUREINVENTORY; - else if(s=="USERDEFINED" ) return IfcInventoryTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcInventoryTypeEnum::NOTDEFINED; - else throw; -} -IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxTypeEnum::FromString(const std::string& s){ - if (s=="USERDEFINED") return IfcJunctionBoxTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcJunctionBoxTypeEnum::NOTDEFINED; - else throw; -} -IfcLampTypeEnum::IfcLampTypeEnum IfcLampTypeEnum::FromString(const std::string& s){ - if (s=="COMPACTFLUORESCENT" ) return IfcLampTypeEnum::COMPACTFLUORESCENT; - else if(s=="FLUORESCENT" ) return IfcLampTypeEnum::FLUORESCENT; - else if(s=="HIGHPRESSUREMERCURY") return IfcLampTypeEnum::HIGHPRESSUREMERCURY; - else if(s=="HIGHPRESSURESODIUM" ) return IfcLampTypeEnum::HIGHPRESSURESODIUM; - else if(s=="METALHALIDE" ) return IfcLampTypeEnum::METALHALIDE; - else if(s=="TUNGSTENFILAMENT" ) return IfcLampTypeEnum::TUNGSTENFILAMENT; - else if(s=="USERDEFINED" ) return IfcLampTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcLampTypeEnum::NOTDEFINED; - else throw; -} -IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcLayerSetDirectionEnum::FromString(const std::string& s){ - if (s=="AXIS1") return IfcLayerSetDirectionEnum::AXIS1; - else if(s=="AXIS2") return IfcLayerSetDirectionEnum::AXIS2; - else if(s=="AXIS3") return IfcLayerSetDirectionEnum::AXIS3; - else throw; -} -IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightDistributionCurveEnum::FromString(const std::string& s){ - if (s=="TYPE_A" ) return IfcLightDistributionCurveEnum::TYPE_A; - else if(s=="TYPE_B" ) return IfcLightDistributionCurveEnum::TYPE_B; - else if(s=="TYPE_C" ) return IfcLightDistributionCurveEnum::TYPE_C; - else if(s=="NOTDEFINED") return IfcLightDistributionCurveEnum::NOTDEFINED; - else throw; -} -IfcLightEmissionSourceEnum::IfcLightEmissionSourceEnum IfcLightEmissionSourceEnum::FromString(const std::string& s){ - if (s=="COMPACTFLUORESCENT" ) return IfcLightEmissionSourceEnum::COMPACTFLUORESCENT; - else if(s=="FLUORESCENT" ) return IfcLightEmissionSourceEnum::FLUORESCENT; - else if(s=="HIGHPRESSUREMERCURY") return IfcLightEmissionSourceEnum::HIGHPRESSUREMERCURY; - else if(s=="HIGHPRESSURESODIUM" ) return IfcLightEmissionSourceEnum::HIGHPRESSURESODIUM; - else if(s=="LIGHTEMITTINGDIODE" ) return IfcLightEmissionSourceEnum::LIGHTEMITTINGDIODE; - else if(s=="LOWPRESSURESODIUM" ) return IfcLightEmissionSourceEnum::LOWPRESSURESODIUM; - else if(s=="LOWVOLTAGEHALOGEN" ) return IfcLightEmissionSourceEnum::LOWVOLTAGEHALOGEN; - else if(s=="MAINVOLTAGEHALOGEN" ) return IfcLightEmissionSourceEnum::MAINVOLTAGEHALOGEN; - else if(s=="METALHALIDE" ) return IfcLightEmissionSourceEnum::METALHALIDE; - else if(s=="TUNGSTENFILAMENT" ) return IfcLightEmissionSourceEnum::TUNGSTENFILAMENT; - else if(s=="NOTDEFINED" ) return IfcLightEmissionSourceEnum::NOTDEFINED; - else throw; -} -IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureTypeEnum::FromString(const std::string& s){ - if (s=="POINTSOURCE" ) return IfcLightFixtureTypeEnum::POINTSOURCE; - else if(s=="DIRECTIONSOURCE") return IfcLightFixtureTypeEnum::DIRECTIONSOURCE; - else if(s=="USERDEFINED" ) return IfcLightFixtureTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcLightFixtureTypeEnum::NOTDEFINED; - else throw; -} -IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcLoadGroupTypeEnum::FromString(const std::string& s){ - if (s=="LOAD_GROUP" ) return IfcLoadGroupTypeEnum::LOAD_GROUP; - else if(s=="LOAD_CASE" ) return IfcLoadGroupTypeEnum::LOAD_CASE; - else if(s=="LOAD_COMBINATION_GROUP") return IfcLoadGroupTypeEnum::LOAD_COMBINATION_GROUP; - else if(s=="LOAD_COMBINATION" ) return IfcLoadGroupTypeEnum::LOAD_COMBINATION; - else if(s=="USERDEFINED" ) return IfcLoadGroupTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcLoadGroupTypeEnum::NOTDEFINED; - else throw; -} -IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcLogicalOperatorEnum::FromString(const std::string& s){ - if (s=="LOGICALAND") return IfcLogicalOperatorEnum::LOGICALAND; - else if(s=="LOGICALOR" ) return IfcLogicalOperatorEnum::LOGICALOR; - else throw; -} -IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberTypeEnum::FromString(const std::string& s){ - if (s=="BRACE" ) return IfcMemberTypeEnum::BRACE; - else if(s=="CHORD" ) return IfcMemberTypeEnum::CHORD; - else if(s=="COLLAR" ) return IfcMemberTypeEnum::COLLAR; - else if(s=="MEMBER" ) return IfcMemberTypeEnum::MEMBER; - else if(s=="MULLION" ) return IfcMemberTypeEnum::MULLION; - else if(s=="PLATE" ) return IfcMemberTypeEnum::PLATE; - else if(s=="POST" ) return IfcMemberTypeEnum::POST; - else if(s=="PURLIN" ) return IfcMemberTypeEnum::PURLIN; - else if(s=="RAFTER" ) return IfcMemberTypeEnum::RAFTER; - else if(s=="STRINGER" ) return IfcMemberTypeEnum::STRINGER; - else if(s=="STRUT" ) return IfcMemberTypeEnum::STRUT; - else if(s=="STUD" ) return IfcMemberTypeEnum::STUD; - else if(s=="USERDEFINED") return IfcMemberTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcMemberTypeEnum::NOTDEFINED; - else throw; -} -IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionTypeEnum::FromString(const std::string& s){ - if (s=="BELTDRIVE" ) return IfcMotorConnectionTypeEnum::BELTDRIVE; - else if(s=="COUPLING" ) return IfcMotorConnectionTypeEnum::COUPLING; - else if(s=="DIRECTDRIVE") return IfcMotorConnectionTypeEnum::DIRECTDRIVE; - else if(s=="USERDEFINED") return IfcMotorConnectionTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcMotorConnectionTypeEnum::NOTDEFINED; - else throw; -} -IfcNullStyle::IfcNullStyle IfcNullStyle::FromString(const std::string& s){ - if (s=="NULL") return IfcNullStyle::IFC_NULL; - else throw; -} -IfcObjectTypeEnum::IfcObjectTypeEnum IfcObjectTypeEnum::FromString(const std::string& s){ - if (s=="PRODUCT" ) return IfcObjectTypeEnum::PRODUCT; - else if(s=="PROCESS" ) return IfcObjectTypeEnum::PROCESS; - else if(s=="CONTROL" ) return IfcObjectTypeEnum::CONTROL; - else if(s=="RESOURCE" ) return IfcObjectTypeEnum::RESOURCE; - else if(s=="ACTOR" ) return IfcObjectTypeEnum::ACTOR; - else if(s=="GROUP" ) return IfcObjectTypeEnum::GROUP; - else if(s=="PROJECT" ) return IfcObjectTypeEnum::PROJECT; - else if(s=="NOTDEFINED") return IfcObjectTypeEnum::NOTDEFINED; - else throw; -} -IfcObjectiveEnum::IfcObjectiveEnum IfcObjectiveEnum::FromString(const std::string& s){ - if (s=="CODECOMPLIANCE" ) return IfcObjectiveEnum::CODECOMPLIANCE; - else if(s=="DESIGNINTENT" ) return IfcObjectiveEnum::DESIGNINTENT; - else if(s=="HEALTHANDSAFETY" ) return IfcObjectiveEnum::HEALTHANDSAFETY; - else if(s=="REQUIREMENT" ) return IfcObjectiveEnum::REQUIREMENT; - else if(s=="SPECIFICATION" ) return IfcObjectiveEnum::SPECIFICATION; - else if(s=="TRIGGERCONDITION") return IfcObjectiveEnum::TRIGGERCONDITION; - else if(s=="USERDEFINED" ) return IfcObjectiveEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcObjectiveEnum::NOTDEFINED; - else throw; -} -IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupantTypeEnum::FromString(const std::string& s){ - if (s=="ASSIGNEE" ) return IfcOccupantTypeEnum::ASSIGNEE; - else if(s=="ASSIGNOR" ) return IfcOccupantTypeEnum::ASSIGNOR; - else if(s=="LESSEE" ) return IfcOccupantTypeEnum::LESSEE; - else if(s=="LESSOR" ) return IfcOccupantTypeEnum::LESSOR; - else if(s=="LETTINGAGENT") return IfcOccupantTypeEnum::LETTINGAGENT; - else if(s=="OWNER" ) return IfcOccupantTypeEnum::OWNER; - else if(s=="TENANT" ) return IfcOccupantTypeEnum::TENANT; - else if(s=="USERDEFINED" ) return IfcOccupantTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcOccupantTypeEnum::NOTDEFINED; - else throw; -} -IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletTypeEnum::FromString(const std::string& s){ - if (s=="AUDIOVISUALOUTLET" ) return IfcOutletTypeEnum::AUDIOVISUALOUTLET; - else if(s=="COMMUNICATIONSOUTLET") return IfcOutletTypeEnum::COMMUNICATIONSOUTLET; - else if(s=="POWEROUTLET" ) return IfcOutletTypeEnum::POWEROUTLET; - else if(s=="USERDEFINED" ) return IfcOutletTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcOutletTypeEnum::NOTDEFINED; - else throw; -} -IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringOperationEnum::FromString(const std::string& s){ - if (s=="GRILL" ) return IfcPermeableCoveringOperationEnum::GRILL; - else if(s=="LOUVER" ) return IfcPermeableCoveringOperationEnum::LOUVER; - else if(s=="SCREEN" ) return IfcPermeableCoveringOperationEnum::SCREEN; - else if(s=="USERDEFINED") return IfcPermeableCoveringOperationEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPermeableCoveringOperationEnum::NOTDEFINED; - else throw; -} -IfcPhysicalOrVirtualEnum::IfcPhysicalOrVirtualEnum IfcPhysicalOrVirtualEnum::FromString(const std::string& s){ - if (s=="PHYSICAL" ) return IfcPhysicalOrVirtualEnum::PHYSICAL; - else if(s=="VIRTUAL" ) return IfcPhysicalOrVirtualEnum::VIRTUAL; - else if(s=="NOTDEFINED") return IfcPhysicalOrVirtualEnum::NOTDEFINED; - else throw; -} -IfcPileConstructionEnum::IfcPileConstructionEnum IfcPileConstructionEnum::FromString(const std::string& s){ - if (s=="CAST_IN_PLACE" ) return IfcPileConstructionEnum::CAST_IN_PLACE; - else if(s=="COMPOSITE" ) return IfcPileConstructionEnum::COMPOSITE; - else if(s=="PRECAST_CONCRETE") return IfcPileConstructionEnum::PRECAST_CONCRETE; - else if(s=="PREFAB_STEEL" ) return IfcPileConstructionEnum::PREFAB_STEEL; - else if(s=="USERDEFINED" ) return IfcPileConstructionEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPileConstructionEnum::NOTDEFINED; - else throw; -} -IfcPileTypeEnum::IfcPileTypeEnum IfcPileTypeEnum::FromString(const std::string& s){ - if (s=="COHESION" ) return IfcPileTypeEnum::COHESION; - else if(s=="FRICTION" ) return IfcPileTypeEnum::FRICTION; - else if(s=="SUPPORT" ) return IfcPileTypeEnum::SUPPORT; - else if(s=="USERDEFINED") return IfcPileTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPileTypeEnum::NOTDEFINED; - else throw; -} -IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingTypeEnum::FromString(const std::string& s){ - if (s=="BEND" ) return IfcPipeFittingTypeEnum::BEND; - else if(s=="CONNECTOR" ) return IfcPipeFittingTypeEnum::CONNECTOR; - else if(s=="ENTRY" ) return IfcPipeFittingTypeEnum::ENTRY; - else if(s=="EXIT" ) return IfcPipeFittingTypeEnum::EXIT; - else if(s=="JUNCTION" ) return IfcPipeFittingTypeEnum::JUNCTION; - else if(s=="OBSTRUCTION") return IfcPipeFittingTypeEnum::OBSTRUCTION; - else if(s=="TRANSITION" ) return IfcPipeFittingTypeEnum::TRANSITION; - else if(s=="USERDEFINED") return IfcPipeFittingTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPipeFittingTypeEnum::NOTDEFINED; - else throw; -} -IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentTypeEnum::FromString(const std::string& s){ - if (s=="FLEXIBLESEGMENT") return IfcPipeSegmentTypeEnum::FLEXIBLESEGMENT; - else if(s=="RIGIDSEGMENT" ) return IfcPipeSegmentTypeEnum::RIGIDSEGMENT; - else if(s=="GUTTER" ) return IfcPipeSegmentTypeEnum::GUTTER; - else if(s=="SPOOL" ) return IfcPipeSegmentTypeEnum::SPOOL; - else if(s=="USERDEFINED" ) return IfcPipeSegmentTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPipeSegmentTypeEnum::NOTDEFINED; - else throw; -} -IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateTypeEnum::FromString(const std::string& s){ - if (s=="CURTAIN_PANEL") return IfcPlateTypeEnum::CURTAIN_PANEL; - else if(s=="SHEET" ) return IfcPlateTypeEnum::SHEET; - else if(s=="USERDEFINED" ) return IfcPlateTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPlateTypeEnum::NOTDEFINED; - else throw; -} -IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedureTypeEnum::FromString(const std::string& s){ - if (s=="ADVICE_CAUTION") return IfcProcedureTypeEnum::ADVICE_CAUTION; - else if(s=="ADVICE_NOTE" ) return IfcProcedureTypeEnum::ADVICE_NOTE; - else if(s=="ADVICE_WARNING") return IfcProcedureTypeEnum::ADVICE_WARNING; - else if(s=="CALIBRATION" ) return IfcProcedureTypeEnum::CALIBRATION; - else if(s=="DIAGNOSTIC" ) return IfcProcedureTypeEnum::DIAGNOSTIC; - else if(s=="SHUTDOWN" ) return IfcProcedureTypeEnum::SHUTDOWN; - else if(s=="STARTUP" ) return IfcProcedureTypeEnum::STARTUP; - else if(s=="USERDEFINED" ) return IfcProcedureTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcProcedureTypeEnum::NOTDEFINED; - else throw; -} -IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileTypeEnum::FromString(const std::string& s){ - if (s=="CURVE") return IfcProfileTypeEnum::CURVE; - else if(s=="AREA" ) return IfcProfileTypeEnum::AREA; - else throw; -} -IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecordTypeEnum::FromString(const std::string& s){ - if (s=="CHANGE" ) return IfcProjectOrderRecordTypeEnum::CHANGE; - else if(s=="MAINTENANCE") return IfcProjectOrderRecordTypeEnum::MAINTENANCE; - else if(s=="MOVE" ) return IfcProjectOrderRecordTypeEnum::MOVE; - else if(s=="PURCHASE" ) return IfcProjectOrderRecordTypeEnum::PURCHASE; - else if(s=="WORK" ) return IfcProjectOrderRecordTypeEnum::WORK; - else if(s=="USERDEFINED") return IfcProjectOrderRecordTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcProjectOrderRecordTypeEnum::NOTDEFINED; - else throw; -} -IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrderTypeEnum::FromString(const std::string& s){ - if (s=="CHANGEORDER" ) return IfcProjectOrderTypeEnum::CHANGEORDER; - else if(s=="MAINTENANCEWORKORDER") return IfcProjectOrderTypeEnum::MAINTENANCEWORKORDER; - else if(s=="MOVEORDER" ) return IfcProjectOrderTypeEnum::MOVEORDER; - else if(s=="PURCHASEORDER" ) return IfcProjectOrderTypeEnum::PURCHASEORDER; - else if(s=="WORKORDER" ) return IfcProjectOrderTypeEnum::WORKORDER; - else if(s=="USERDEFINED" ) return IfcProjectOrderTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcProjectOrderTypeEnum::NOTDEFINED; - else throw; -} -IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcProjectedOrTrueLengthEnum::FromString(const std::string& s){ - if (s=="PROJECTED_LENGTH") return IfcProjectedOrTrueLengthEnum::PROJECTED_LENGTH; - else if(s=="TRUE_LENGTH" ) return IfcProjectedOrTrueLengthEnum::TRUE_LENGTH; - else throw; -} -IfcPropertySourceEnum::IfcPropertySourceEnum IfcPropertySourceEnum::FromString(const std::string& s){ - if (s=="DESIGN" ) return IfcPropertySourceEnum::DESIGN; - else if(s=="DESIGNMAXIMUM") return IfcPropertySourceEnum::DESIGNMAXIMUM; - else if(s=="DESIGNMINIMUM") return IfcPropertySourceEnum::DESIGNMINIMUM; - else if(s=="SIMULATED" ) return IfcPropertySourceEnum::SIMULATED; - else if(s=="ASBUILT" ) return IfcPropertySourceEnum::ASBUILT; - else if(s=="COMMISSIONING") return IfcPropertySourceEnum::COMMISSIONING; - else if(s=="MEASURED" ) return IfcPropertySourceEnum::MEASURED; - else if(s=="USERDEFINED" ) return IfcPropertySourceEnum::USERDEFINED; - else if(s=="NOTKNOWN" ) return IfcPropertySourceEnum::NOTKNOWN; - else throw; -} -IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceTypeEnum::FromString(const std::string& s){ - if (s=="FUSEDISCONNECTOR" ) return IfcProtectiveDeviceTypeEnum::FUSEDISCONNECTOR; - else if(s=="CIRCUITBREAKER" ) return IfcProtectiveDeviceTypeEnum::CIRCUITBREAKER; - else if(s=="EARTHFAILUREDEVICE" ) return IfcProtectiveDeviceTypeEnum::EARTHFAILUREDEVICE; - else if(s=="RESIDUALCURRENTCIRCUITBREAKER") return IfcProtectiveDeviceTypeEnum::RESIDUALCURRENTCIRCUITBREAKER; - else if(s=="RESIDUALCURRENTSWITCH" ) return IfcProtectiveDeviceTypeEnum::RESIDUALCURRENTSWITCH; - else if(s=="VARISTOR" ) return IfcProtectiveDeviceTypeEnum::VARISTOR; - else if(s=="USERDEFINED" ) return IfcProtectiveDeviceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcProtectiveDeviceTypeEnum::NOTDEFINED; - else throw; -} -IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpTypeEnum::FromString(const std::string& s){ - if (s=="CIRCULATOR" ) return IfcPumpTypeEnum::CIRCULATOR; - else if(s=="ENDSUCTION" ) return IfcPumpTypeEnum::ENDSUCTION; - else if(s=="SPLITCASE" ) return IfcPumpTypeEnum::SPLITCASE; - else if(s=="VERTICALINLINE" ) return IfcPumpTypeEnum::VERTICALINLINE; - else if(s=="VERTICALTURBINE") return IfcPumpTypeEnum::VERTICALTURBINE; - else if(s=="USERDEFINED" ) return IfcPumpTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcPumpTypeEnum::NOTDEFINED; - else throw; -} -IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingTypeEnum::FromString(const std::string& s){ - if (s=="HANDRAIL" ) return IfcRailingTypeEnum::HANDRAIL; - else if(s=="GUARDRAIL" ) return IfcRailingTypeEnum::GUARDRAIL; - else if(s=="BALUSTRADE" ) return IfcRailingTypeEnum::BALUSTRADE; - else if(s=="USERDEFINED") return IfcRailingTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcRailingTypeEnum::NOTDEFINED; - else throw; -} -IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightTypeEnum::FromString(const std::string& s){ - if (s=="STRAIGHT" ) return IfcRampFlightTypeEnum::STRAIGHT; - else if(s=="SPIRAL" ) return IfcRampFlightTypeEnum::SPIRAL; - else if(s=="USERDEFINED") return IfcRampFlightTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcRampFlightTypeEnum::NOTDEFINED; - else throw; -} -IfcRampTypeEnum::IfcRampTypeEnum IfcRampTypeEnum::FromString(const std::string& s){ - if (s=="STRAIGHT_RUN_RAMP" ) return IfcRampTypeEnum::STRAIGHT_RUN_RAMP; - else if(s=="TWO_STRAIGHT_RUN_RAMP") return IfcRampTypeEnum::TWO_STRAIGHT_RUN_RAMP; - else if(s=="QUARTER_TURN_RAMP" ) return IfcRampTypeEnum::QUARTER_TURN_RAMP; - else if(s=="TWO_QUARTER_TURN_RAMP") return IfcRampTypeEnum::TWO_QUARTER_TURN_RAMP; - else if(s=="HALF_TURN_RAMP" ) return IfcRampTypeEnum::HALF_TURN_RAMP; - else if(s=="SPIRAL_RAMP" ) return IfcRampTypeEnum::SPIRAL_RAMP; - else if(s=="USERDEFINED" ) return IfcRampTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcRampTypeEnum::NOTDEFINED; - else throw; -} -IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcReflectanceMethodEnum::FromString(const std::string& s){ - if (s=="BLINN" ) return IfcReflectanceMethodEnum::BLINN; - else if(s=="FLAT" ) return IfcReflectanceMethodEnum::FLAT; - else if(s=="GLASS" ) return IfcReflectanceMethodEnum::GLASS; - else if(s=="MATT" ) return IfcReflectanceMethodEnum::MATT; - else if(s=="METAL" ) return IfcReflectanceMethodEnum::METAL; - else if(s=="MIRROR" ) return IfcReflectanceMethodEnum::MIRROR; - else if(s=="PHONG" ) return IfcReflectanceMethodEnum::PHONG; - else if(s=="PLASTIC" ) return IfcReflectanceMethodEnum::PLASTIC; - else if(s=="STRAUSS" ) return IfcReflectanceMethodEnum::STRAUSS; - else if(s=="NOTDEFINED") return IfcReflectanceMethodEnum::NOTDEFINED; - else throw; -} -IfcReinforcingBarRoleEnum::IfcReinforcingBarRoleEnum IfcReinforcingBarRoleEnum::FromString(const std::string& s){ - if (s=="MAIN" ) return IfcReinforcingBarRoleEnum::MAIN; - else if(s=="SHEAR" ) return IfcReinforcingBarRoleEnum::SHEAR; - else if(s=="LIGATURE" ) return IfcReinforcingBarRoleEnum::LIGATURE; - else if(s=="STUD" ) return IfcReinforcingBarRoleEnum::STUD; - else if(s=="PUNCHING" ) return IfcReinforcingBarRoleEnum::PUNCHING; - else if(s=="EDGE" ) return IfcReinforcingBarRoleEnum::EDGE; - else if(s=="RING" ) return IfcReinforcingBarRoleEnum::RING; - else if(s=="USERDEFINED") return IfcReinforcingBarRoleEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcReinforcingBarRoleEnum::NOTDEFINED; - else throw; -} -IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBarSurfaceEnum::FromString(const std::string& s){ - if (s=="PLAIN" ) return IfcReinforcingBarSurfaceEnum::PLAIN; - else if(s=="TEXTURED") return IfcReinforcingBarSurfaceEnum::TEXTURED; - else throw; -} -IfcResourceConsumptionEnum::IfcResourceConsumptionEnum IfcResourceConsumptionEnum::FromString(const std::string& s){ - if (s=="CONSUMED" ) return IfcResourceConsumptionEnum::CONSUMED; - else if(s=="PARTIALLYCONSUMED") return IfcResourceConsumptionEnum::PARTIALLYCONSUMED; - else if(s=="NOTCONSUMED" ) return IfcResourceConsumptionEnum::NOTCONSUMED; - else if(s=="OCCUPIED" ) return IfcResourceConsumptionEnum::OCCUPIED; - else if(s=="PARTIALLYOCCUPIED") return IfcResourceConsumptionEnum::PARTIALLYOCCUPIED; - else if(s=="NOTOCCUPIED" ) return IfcResourceConsumptionEnum::NOTOCCUPIED; - else if(s=="USERDEFINED" ) return IfcResourceConsumptionEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcResourceConsumptionEnum::NOTDEFINED; - else throw; -} -IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateDirectionEnum::FromString(const std::string& s){ - if (s=="DIRECTION_X") return IfcRibPlateDirectionEnum::DIRECTION_X; - else if(s=="DIRECTION_Y") return IfcRibPlateDirectionEnum::DIRECTION_Y; - else throw; -} -IfcRoleEnum::IfcRoleEnum IfcRoleEnum::FromString(const std::string& s){ - if (s=="SUPPLIER" ) return IfcRoleEnum::SUPPLIER; - else if(s=="MANUFACTURER" ) return IfcRoleEnum::MANUFACTURER; - else if(s=="CONTRACTOR" ) return IfcRoleEnum::CONTRACTOR; - else if(s=="SUBCONTRACTOR" ) return IfcRoleEnum::SUBCONTRACTOR; - else if(s=="ARCHITECT" ) return IfcRoleEnum::ARCHITECT; - else if(s=="STRUCTURALENGINEER" ) return IfcRoleEnum::STRUCTURALENGINEER; - else if(s=="COSTENGINEER" ) return IfcRoleEnum::COSTENGINEER; - else if(s=="CLIENT" ) return IfcRoleEnum::CLIENT; - else if(s=="BUILDINGOWNER" ) return IfcRoleEnum::BUILDINGOWNER; - else if(s=="BUILDINGOPERATOR" ) return IfcRoleEnum::BUILDINGOPERATOR; - else if(s=="MECHANICALENGINEER" ) return IfcRoleEnum::MECHANICALENGINEER; - else if(s=="ELECTRICALENGINEER" ) return IfcRoleEnum::ELECTRICALENGINEER; - else if(s=="PROJECTMANAGER" ) return IfcRoleEnum::PROJECTMANAGER; - else if(s=="FACILITIESMANAGER" ) return IfcRoleEnum::FACILITIESMANAGER; - else if(s=="CIVILENGINEER" ) return IfcRoleEnum::CIVILENGINEER; - else if(s=="COMISSIONINGENGINEER" ) return IfcRoleEnum::COMISSIONINGENGINEER; - else if(s=="ENGINEER" ) return IfcRoleEnum::ENGINEER; - else if(s=="OWNER" ) return IfcRoleEnum::OWNER; - else if(s=="CONSULTANT" ) return IfcRoleEnum::CONSULTANT; - else if(s=="CONSTRUCTIONMANAGER" ) return IfcRoleEnum::CONSTRUCTIONMANAGER; - else if(s=="FIELDCONSTRUCTIONMANAGER") return IfcRoleEnum::FIELDCONSTRUCTIONMANAGER; - else if(s=="RESELLER" ) return IfcRoleEnum::RESELLER; - else if(s=="USERDEFINED" ) return IfcRoleEnum::USERDEFINED; - else throw; -} -IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoofTypeEnum::FromString(const std::string& s){ - if (s=="FLAT_ROOF" ) return IfcRoofTypeEnum::FLAT_ROOF; - else if(s=="SHED_ROOF" ) return IfcRoofTypeEnum::SHED_ROOF; - else if(s=="GABLE_ROOF" ) return IfcRoofTypeEnum::GABLE_ROOF; - else if(s=="HIP_ROOF" ) return IfcRoofTypeEnum::HIP_ROOF; - else if(s=="HIPPED_GABLE_ROOF") return IfcRoofTypeEnum::HIPPED_GABLE_ROOF; - else if(s=="GAMBREL_ROOF" ) return IfcRoofTypeEnum::GAMBREL_ROOF; - else if(s=="MANSARD_ROOF" ) return IfcRoofTypeEnum::MANSARD_ROOF; - else if(s=="BARREL_ROOF" ) return IfcRoofTypeEnum::BARREL_ROOF; - else if(s=="RAINBOW_ROOF" ) return IfcRoofTypeEnum::RAINBOW_ROOF; - else if(s=="BUTTERFLY_ROOF" ) return IfcRoofTypeEnum::BUTTERFLY_ROOF; - else if(s=="PAVILION_ROOF" ) return IfcRoofTypeEnum::PAVILION_ROOF; - else if(s=="DOME_ROOF" ) return IfcRoofTypeEnum::DOME_ROOF; - else if(s=="FREEFORM" ) return IfcRoofTypeEnum::FREEFORM; - else if(s=="NOTDEFINED" ) return IfcRoofTypeEnum::NOTDEFINED; - else throw; -} -IfcSIPrefix::IfcSIPrefix IfcSIPrefix::FromString(const std::string& s){ - if (s=="EXA" ) return IfcSIPrefix::EXA; - else if(s=="PETA" ) return IfcSIPrefix::PETA; - else if(s=="TERA" ) return IfcSIPrefix::TERA; - else if(s=="GIGA" ) return IfcSIPrefix::GIGA; - else if(s=="MEGA" ) return IfcSIPrefix::MEGA; - else if(s=="KILO" ) return IfcSIPrefix::KILO; - else if(s=="HECTO") return IfcSIPrefix::HECTO; - else if(s=="DECA" ) return IfcSIPrefix::DECA; - else if(s=="DECI" ) return IfcSIPrefix::DECI; - else if(s=="CENTI") return IfcSIPrefix::CENTI; - else if(s=="MILLI") return IfcSIPrefix::MILLI; - else if(s=="MICRO") return IfcSIPrefix::MICRO; - else if(s=="NANO" ) return IfcSIPrefix::NANO; - else if(s=="PICO" ) return IfcSIPrefix::PICO; - else if(s=="FEMTO") return IfcSIPrefix::FEMTO; - else if(s=="ATTO" ) return IfcSIPrefix::ATTO; - else throw; -} -IfcSIUnitName::IfcSIUnitName IfcSIUnitName::FromString(const std::string& s){ - if (s=="AMPERE" ) return IfcSIUnitName::AMPERE; - else if(s=="BECQUEREL" ) return IfcSIUnitName::BECQUEREL; - else if(s=="CANDELA" ) return IfcSIUnitName::CANDELA; - else if(s=="COULOMB" ) return IfcSIUnitName::COULOMB; - else if(s=="CUBIC_METRE" ) return IfcSIUnitName::CUBIC_METRE; - else if(s=="DEGREE_CELSIUS") return IfcSIUnitName::DEGREE_CELSIUS; - else if(s=="FARAD" ) return IfcSIUnitName::FARAD; - else if(s=="GRAM" ) return IfcSIUnitName::GRAM; - else if(s=="GRAY" ) return IfcSIUnitName::GRAY; - else if(s=="HENRY" ) return IfcSIUnitName::HENRY; - else if(s=="HERTZ" ) return IfcSIUnitName::HERTZ; - else if(s=="JOULE" ) return IfcSIUnitName::JOULE; - else if(s=="KELVIN" ) return IfcSIUnitName::KELVIN; - else if(s=="LUMEN" ) return IfcSIUnitName::LUMEN; - else if(s=="LUX" ) return IfcSIUnitName::LUX; - else if(s=="METRE" ) return IfcSIUnitName::METRE; - else if(s=="MOLE" ) return IfcSIUnitName::MOLE; - else if(s=="NEWTON" ) return IfcSIUnitName::NEWTON; - else if(s=="OHM" ) return IfcSIUnitName::OHM; - else if(s=="PASCAL" ) return IfcSIUnitName::PASCAL; - else if(s=="RADIAN" ) return IfcSIUnitName::RADIAN; - else if(s=="SECOND" ) return IfcSIUnitName::SECOND; - else if(s=="SIEMENS" ) return IfcSIUnitName::SIEMENS; - else if(s=="SIEVERT" ) return IfcSIUnitName::SIEVERT; - else if(s=="SQUARE_METRE" ) return IfcSIUnitName::SQUARE_METRE; - else if(s=="STERADIAN" ) return IfcSIUnitName::STERADIAN; - else if(s=="TESLA" ) return IfcSIUnitName::TESLA; - else if(s=="VOLT" ) return IfcSIUnitName::VOLT; - else if(s=="WATT" ) return IfcSIUnitName::WATT; - else if(s=="WEBER" ) return IfcSIUnitName::WEBER; - else throw; -} -IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalTypeEnum::FromString(const std::string& s){ - if (s=="BATH" ) return IfcSanitaryTerminalTypeEnum::BATH; - else if(s=="BIDET" ) return IfcSanitaryTerminalTypeEnum::BIDET; - else if(s=="CISTERN" ) return IfcSanitaryTerminalTypeEnum::CISTERN; - else if(s=="SHOWER" ) return IfcSanitaryTerminalTypeEnum::SHOWER; - else if(s=="SINK" ) return IfcSanitaryTerminalTypeEnum::SINK; - else if(s=="SANITARYFOUNTAIN") return IfcSanitaryTerminalTypeEnum::SANITARYFOUNTAIN; - else if(s=="TOILETPAN" ) return IfcSanitaryTerminalTypeEnum::TOILETPAN; - else if(s=="URINAL" ) return IfcSanitaryTerminalTypeEnum::URINAL; - else if(s=="WASHHANDBASIN" ) return IfcSanitaryTerminalTypeEnum::WASHHANDBASIN; - else if(s=="WCSEAT" ) return IfcSanitaryTerminalTypeEnum::WCSEAT; - else if(s=="USERDEFINED" ) return IfcSanitaryTerminalTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSanitaryTerminalTypeEnum::NOTDEFINED; - else throw; -} -IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionTypeEnum::FromString(const std::string& s){ - if (s=="UNIFORM") return IfcSectionTypeEnum::UNIFORM; - else if(s=="TAPERED") return IfcSectionTypeEnum::TAPERED; - else throw; -} -IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorTypeEnum::FromString(const std::string& s){ - if (s=="CO2SENSOR" ) return IfcSensorTypeEnum::CO2SENSOR; - else if(s=="FIRESENSOR" ) return IfcSensorTypeEnum::FIRESENSOR; - else if(s=="FLOWSENSOR" ) return IfcSensorTypeEnum::FLOWSENSOR; - else if(s=="GASSENSOR" ) return IfcSensorTypeEnum::GASSENSOR; - else if(s=="HEATSENSOR" ) return IfcSensorTypeEnum::HEATSENSOR; - else if(s=="HUMIDITYSENSOR" ) return IfcSensorTypeEnum::HUMIDITYSENSOR; - else if(s=="LIGHTSENSOR" ) return IfcSensorTypeEnum::LIGHTSENSOR; - else if(s=="MOISTURESENSOR" ) return IfcSensorTypeEnum::MOISTURESENSOR; - else if(s=="MOVEMENTSENSOR" ) return IfcSensorTypeEnum::MOVEMENTSENSOR; - else if(s=="PRESSURESENSOR" ) return IfcSensorTypeEnum::PRESSURESENSOR; - else if(s=="SMOKESENSOR" ) return IfcSensorTypeEnum::SMOKESENSOR; - else if(s=="SOUNDSENSOR" ) return IfcSensorTypeEnum::SOUNDSENSOR; - else if(s=="TEMPERATURESENSOR") return IfcSensorTypeEnum::TEMPERATURESENSOR; - else if(s=="USERDEFINED" ) return IfcSensorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSensorTypeEnum::NOTDEFINED; - else throw; -} -IfcSequenceEnum::IfcSequenceEnum IfcSequenceEnum::FromString(const std::string& s){ - if (s=="START_START" ) return IfcSequenceEnum::START_START; - else if(s=="START_FINISH" ) return IfcSequenceEnum::START_FINISH; - else if(s=="FINISH_START" ) return IfcSequenceEnum::FINISH_START; - else if(s=="FINISH_FINISH") return IfcSequenceEnum::FINISH_FINISH; - else if(s=="NOTDEFINED" ) return IfcSequenceEnum::NOTDEFINED; - else throw; -} -IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactorTypeEnum::FromString(const std::string& s){ - if (s=="A_QUALITYOFCOMPONENTS") return IfcServiceLifeFactorTypeEnum::A_QUALITYOFCOMPONENTS; - else if(s=="B_DESIGNLEVEL" ) return IfcServiceLifeFactorTypeEnum::B_DESIGNLEVEL; - else if(s=="C_WORKEXECUTIONLEVEL" ) return IfcServiceLifeFactorTypeEnum::C_WORKEXECUTIONLEVEL; - else if(s=="D_INDOORENVIRONMENT" ) return IfcServiceLifeFactorTypeEnum::D_INDOORENVIRONMENT; - else if(s=="E_OUTDOORENVIRONMENT" ) return IfcServiceLifeFactorTypeEnum::E_OUTDOORENVIRONMENT; - else if(s=="F_INUSECONDITIONS" ) return IfcServiceLifeFactorTypeEnum::F_INUSECONDITIONS; - else if(s=="G_MAINTENANCELEVEL" ) return IfcServiceLifeFactorTypeEnum::G_MAINTENANCELEVEL; - else if(s=="USERDEFINED" ) return IfcServiceLifeFactorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcServiceLifeFactorTypeEnum::NOTDEFINED; - else throw; -} -IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLifeTypeEnum::FromString(const std::string& s){ - if (s=="ACTUALSERVICELIFE" ) return IfcServiceLifeTypeEnum::ACTUALSERVICELIFE; - else if(s=="EXPECTEDSERVICELIFE" ) return IfcServiceLifeTypeEnum::EXPECTEDSERVICELIFE; - else if(s=="OPTIMISTICREFERENCESERVICELIFE" ) return IfcServiceLifeTypeEnum::OPTIMISTICREFERENCESERVICELIFE; - else if(s=="PESSIMISTICREFERENCESERVICELIFE") return IfcServiceLifeTypeEnum::PESSIMISTICREFERENCESERVICELIFE; - else if(s=="REFERENCESERVICELIFE" ) return IfcServiceLifeTypeEnum::REFERENCESERVICELIFE; - else throw; -} -IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabTypeEnum::FromString(const std::string& s){ - if (s=="FLOOR" ) return IfcSlabTypeEnum::FLOOR; - else if(s=="ROOF" ) return IfcSlabTypeEnum::ROOF; - else if(s=="LANDING" ) return IfcSlabTypeEnum::LANDING; - else if(s=="BASESLAB" ) return IfcSlabTypeEnum::BASESLAB; - else if(s=="USERDEFINED") return IfcSlabTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSlabTypeEnum::NOTDEFINED; - else throw; -} -IfcSoundScaleEnum::IfcSoundScaleEnum IfcSoundScaleEnum::FromString(const std::string& s){ - if (s=="DBA" ) return IfcSoundScaleEnum::DBA; - else if(s=="DBB" ) return IfcSoundScaleEnum::DBB; - else if(s=="DBC" ) return IfcSoundScaleEnum::DBC; - else if(s=="NC" ) return IfcSoundScaleEnum::NC; - else if(s=="NR" ) return IfcSoundScaleEnum::NR; - else if(s=="USERDEFINED") return IfcSoundScaleEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSoundScaleEnum::NOTDEFINED; - else throw; -} -IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterTypeEnum::FromString(const std::string& s){ - if (s=="SECTIONALRADIATOR") return IfcSpaceHeaterTypeEnum::SECTIONALRADIATOR; - else if(s=="PANELRADIATOR" ) return IfcSpaceHeaterTypeEnum::PANELRADIATOR; - else if(s=="TUBULARRADIATOR" ) return IfcSpaceHeaterTypeEnum::TUBULARRADIATOR; - else if(s=="CONVECTOR" ) return IfcSpaceHeaterTypeEnum::CONVECTOR; - else if(s=="BASEBOARDHEATER" ) return IfcSpaceHeaterTypeEnum::BASEBOARDHEATER; - else if(s=="FINNEDTUBEUNIT" ) return IfcSpaceHeaterTypeEnum::FINNEDTUBEUNIT; - else if(s=="UNITHEATER" ) return IfcSpaceHeaterTypeEnum::UNITHEATER; - else if(s=="USERDEFINED" ) return IfcSpaceHeaterTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSpaceHeaterTypeEnum::NOTDEFINED; - else throw; -} -IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceTypeEnum::FromString(const std::string& s){ - if (s=="USERDEFINED") return IfcSpaceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSpaceTypeEnum::NOTDEFINED; - else throw; -} -IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalTypeEnum::FromString(const std::string& s){ - if (s=="BIRDCAGE" ) return IfcStackTerminalTypeEnum::BIRDCAGE; - else if(s=="COWL" ) return IfcStackTerminalTypeEnum::COWL; - else if(s=="RAINWATERHOPPER") return IfcStackTerminalTypeEnum::RAINWATERHOPPER; - else if(s=="USERDEFINED" ) return IfcStackTerminalTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcStackTerminalTypeEnum::NOTDEFINED; - else throw; -} -IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightTypeEnum::FromString(const std::string& s){ - if (s=="STRAIGHT" ) return IfcStairFlightTypeEnum::STRAIGHT; - else if(s=="WINDER" ) return IfcStairFlightTypeEnum::WINDER; - else if(s=="SPIRAL" ) return IfcStairFlightTypeEnum::SPIRAL; - else if(s=="CURVED" ) return IfcStairFlightTypeEnum::CURVED; - else if(s=="FREEFORM" ) return IfcStairFlightTypeEnum::FREEFORM; - else if(s=="USERDEFINED") return IfcStairFlightTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcStairFlightTypeEnum::NOTDEFINED; - else throw; -} -IfcStairTypeEnum::IfcStairTypeEnum IfcStairTypeEnum::FromString(const std::string& s){ - if (s=="STRAIGHT_RUN_STAIR" ) return IfcStairTypeEnum::STRAIGHT_RUN_STAIR; - else if(s=="TWO_STRAIGHT_RUN_STAIR" ) return IfcStairTypeEnum::TWO_STRAIGHT_RUN_STAIR; - else if(s=="QUARTER_WINDING_STAIR" ) return IfcStairTypeEnum::QUARTER_WINDING_STAIR; - else if(s=="QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::QUARTER_TURN_STAIR; - else if(s=="HALF_WINDING_STAIR" ) return IfcStairTypeEnum::HALF_WINDING_STAIR; - else if(s=="HALF_TURN_STAIR" ) return IfcStairTypeEnum::HALF_TURN_STAIR; - else if(s=="TWO_QUARTER_WINDING_STAIR" ) return IfcStairTypeEnum::TWO_QUARTER_WINDING_STAIR; - else if(s=="TWO_QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::TWO_QUARTER_TURN_STAIR; - else if(s=="THREE_QUARTER_WINDING_STAIR") return IfcStairTypeEnum::THREE_QUARTER_WINDING_STAIR; - else if(s=="THREE_QUARTER_TURN_STAIR" ) return IfcStairTypeEnum::THREE_QUARTER_TURN_STAIR; - else if(s=="SPIRAL_STAIR" ) return IfcStairTypeEnum::SPIRAL_STAIR; - else if(s=="DOUBLE_RETURN_STAIR" ) return IfcStairTypeEnum::DOUBLE_RETURN_STAIR; - else if(s=="CURVED_RUN_STAIR" ) return IfcStairTypeEnum::CURVED_RUN_STAIR; - else if(s=="TWO_CURVED_RUN_STAIR" ) return IfcStairTypeEnum::TWO_CURVED_RUN_STAIR; - else if(s=="USERDEFINED" ) return IfcStairTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcStairTypeEnum::NOTDEFINED; - else throw; -} -IfcStateEnum::IfcStateEnum IfcStateEnum::FromString(const std::string& s){ - if (s=="READWRITE" ) return IfcStateEnum::READWRITE; - else if(s=="READONLY" ) return IfcStateEnum::READONLY; - else if(s=="LOCKED" ) return IfcStateEnum::LOCKED; - else if(s=="READWRITELOCKED") return IfcStateEnum::READWRITELOCKED; - else if(s=="READONLYLOCKED" ) return IfcStateEnum::READONLYLOCKED; - else throw; -} -IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveTypeEnum::FromString(const std::string& s){ - if (s=="RIGID_JOINED_MEMBER") return IfcStructuralCurveTypeEnum::RIGID_JOINED_MEMBER; - else if(s=="PIN_JOINED_MEMBER" ) return IfcStructuralCurveTypeEnum::PIN_JOINED_MEMBER; - else if(s=="CABLE" ) return IfcStructuralCurveTypeEnum::CABLE; - else if(s=="TENSION_MEMBER" ) return IfcStructuralCurveTypeEnum::TENSION_MEMBER; - else if(s=="COMPRESSION_MEMBER" ) return IfcStructuralCurveTypeEnum::COMPRESSION_MEMBER; - else if(s=="USERDEFINED" ) return IfcStructuralCurveTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcStructuralCurveTypeEnum::NOTDEFINED; - else throw; -} -IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceTypeEnum::FromString(const std::string& s){ - if (s=="BENDING_ELEMENT" ) return IfcStructuralSurfaceTypeEnum::BENDING_ELEMENT; - else if(s=="MEMBRANE_ELEMENT") return IfcStructuralSurfaceTypeEnum::MEMBRANE_ELEMENT; - else if(s=="SHELL" ) return IfcStructuralSurfaceTypeEnum::SHELL; - else if(s=="USERDEFINED" ) return IfcStructuralSurfaceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcStructuralSurfaceTypeEnum::NOTDEFINED; - else throw; -} -IfcSurfaceSide::IfcSurfaceSide IfcSurfaceSide::FromString(const std::string& s){ - if (s=="POSITIVE") return IfcSurfaceSide::POSITIVE; - else if(s=="NEGATIVE") return IfcSurfaceSide::NEGATIVE; - else if(s=="BOTH" ) return IfcSurfaceSide::BOTH; - else throw; -} -IfcSurfaceTextureEnum::IfcSurfaceTextureEnum IfcSurfaceTextureEnum::FromString(const std::string& s){ - if (s=="BUMP" ) return IfcSurfaceTextureEnum::BUMP; - else if(s=="OPACITY" ) return IfcSurfaceTextureEnum::OPACITY; - else if(s=="REFLECTION" ) return IfcSurfaceTextureEnum::REFLECTION; - else if(s=="SELFILLUMINATION") return IfcSurfaceTextureEnum::SELFILLUMINATION; - else if(s=="SHININESS" ) return IfcSurfaceTextureEnum::SHININESS; - else if(s=="SPECULAR" ) return IfcSurfaceTextureEnum::SPECULAR; - else if(s=="TEXTURE" ) return IfcSurfaceTextureEnum::TEXTURE; - else if(s=="TRANSPARENCYMAP" ) return IfcSurfaceTextureEnum::TRANSPARENCYMAP; - else if(s=="NOTDEFINED" ) return IfcSurfaceTextureEnum::NOTDEFINED; - else throw; -} -IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceTypeEnum::FromString(const std::string& s){ - if (s=="CONTACTOR" ) return IfcSwitchingDeviceTypeEnum::CONTACTOR; - else if(s=="EMERGENCYSTOP" ) return IfcSwitchingDeviceTypeEnum::EMERGENCYSTOP; - else if(s=="STARTER" ) return IfcSwitchingDeviceTypeEnum::STARTER; - else if(s=="SWITCHDISCONNECTOR") return IfcSwitchingDeviceTypeEnum::SWITCHDISCONNECTOR; - else if(s=="TOGGLESWITCH" ) return IfcSwitchingDeviceTypeEnum::TOGGLESWITCH; - else if(s=="USERDEFINED" ) return IfcSwitchingDeviceTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcSwitchingDeviceTypeEnum::NOTDEFINED; - else throw; -} -IfcTankTypeEnum::IfcTankTypeEnum IfcTankTypeEnum::FromString(const std::string& s){ - if (s=="PREFORMED" ) return IfcTankTypeEnum::PREFORMED; - else if(s=="SECTIONAL" ) return IfcTankTypeEnum::SECTIONAL; - else if(s=="EXPANSION" ) return IfcTankTypeEnum::EXPANSION; - else if(s=="PRESSUREVESSEL") return IfcTankTypeEnum::PRESSUREVESSEL; - else if(s=="USERDEFINED" ) return IfcTankTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcTankTypeEnum::NOTDEFINED; - else throw; -} -IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendonTypeEnum::FromString(const std::string& s){ - if (s=="STRAND" ) return IfcTendonTypeEnum::STRAND; - else if(s=="WIRE" ) return IfcTendonTypeEnum::WIRE; - else if(s=="BAR" ) return IfcTendonTypeEnum::BAR; - else if(s=="COATED" ) return IfcTendonTypeEnum::COATED; - else if(s=="USERDEFINED") return IfcTendonTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcTendonTypeEnum::NOTDEFINED; - else throw; -} -IfcTextPath::IfcTextPath IfcTextPath::FromString(const std::string& s){ - if (s=="LEFT" ) return IfcTextPath::LEFT; - else if(s=="RIGHT") return IfcTextPath::RIGHT; - else if(s=="UP" ) return IfcTextPath::UP; - else if(s=="DOWN" ) return IfcTextPath::DOWN; - else throw; -} -IfcThermalLoadSourceEnum::IfcThermalLoadSourceEnum IfcThermalLoadSourceEnum::FromString(const std::string& s){ - if (s=="PEOPLE" ) return IfcThermalLoadSourceEnum::PEOPLE; - else if(s=="LIGHTING" ) return IfcThermalLoadSourceEnum::LIGHTING; - else if(s=="EQUIPMENT" ) return IfcThermalLoadSourceEnum::EQUIPMENT; - else if(s=="VENTILATIONINDOORAIR" ) return IfcThermalLoadSourceEnum::VENTILATIONINDOORAIR; - else if(s=="VENTILATIONOUTSIDEAIR") return IfcThermalLoadSourceEnum::VENTILATIONOUTSIDEAIR; - else if(s=="RECIRCULATEDAIR" ) return IfcThermalLoadSourceEnum::RECIRCULATEDAIR; - else if(s=="EXHAUSTAIR" ) return IfcThermalLoadSourceEnum::EXHAUSTAIR; - else if(s=="AIREXCHANGERATE" ) return IfcThermalLoadSourceEnum::AIREXCHANGERATE; - else if(s=="DRYBULBTEMPERATURE" ) return IfcThermalLoadSourceEnum::DRYBULBTEMPERATURE; - else if(s=="RELATIVEHUMIDITY" ) return IfcThermalLoadSourceEnum::RELATIVEHUMIDITY; - else if(s=="INFILTRATION" ) return IfcThermalLoadSourceEnum::INFILTRATION; - else if(s=="USERDEFINED" ) return IfcThermalLoadSourceEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcThermalLoadSourceEnum::NOTDEFINED; - else throw; -} -IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcThermalLoadTypeEnum::FromString(const std::string& s){ - if (s=="SENSIBLE" ) return IfcThermalLoadTypeEnum::SENSIBLE; - else if(s=="LATENT" ) return IfcThermalLoadTypeEnum::LATENT; - else if(s=="RADIANT" ) return IfcThermalLoadTypeEnum::RADIANT; - else if(s=="NOTDEFINED") return IfcThermalLoadTypeEnum::NOTDEFINED; - else throw; -} -IfcTimeSeriesDataTypeEnum::IfcTimeSeriesDataTypeEnum IfcTimeSeriesDataTypeEnum::FromString(const std::string& s){ - if (s=="CONTINUOUS" ) return IfcTimeSeriesDataTypeEnum::CONTINUOUS; - else if(s=="DISCRETE" ) return IfcTimeSeriesDataTypeEnum::DISCRETE; - else if(s=="DISCRETEBINARY" ) return IfcTimeSeriesDataTypeEnum::DISCRETEBINARY; - else if(s=="PIECEWISEBINARY" ) return IfcTimeSeriesDataTypeEnum::PIECEWISEBINARY; - else if(s=="PIECEWISECONSTANT" ) return IfcTimeSeriesDataTypeEnum::PIECEWISECONSTANT; - else if(s=="PIECEWISECONTINUOUS") return IfcTimeSeriesDataTypeEnum::PIECEWISECONTINUOUS; - else if(s=="NOTDEFINED" ) return IfcTimeSeriesDataTypeEnum::NOTDEFINED; - else throw; -} -IfcTimeSeriesScheduleTypeEnum::IfcTimeSeriesScheduleTypeEnum IfcTimeSeriesScheduleTypeEnum::FromString(const std::string& s){ - if (s=="ANNUAL" ) return IfcTimeSeriesScheduleTypeEnum::ANNUAL; - else if(s=="MONTHLY" ) return IfcTimeSeriesScheduleTypeEnum::MONTHLY; - else if(s=="WEEKLY" ) return IfcTimeSeriesScheduleTypeEnum::WEEKLY; - else if(s=="DAILY" ) return IfcTimeSeriesScheduleTypeEnum::DAILY; - else if(s=="USERDEFINED") return IfcTimeSeriesScheduleTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcTimeSeriesScheduleTypeEnum::NOTDEFINED; - else throw; -} -IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerTypeEnum::FromString(const std::string& s){ - if (s=="CURRENT" ) return IfcTransformerTypeEnum::CURRENT; - else if(s=="FREQUENCY" ) return IfcTransformerTypeEnum::FREQUENCY; - else if(s=="VOLTAGE" ) return IfcTransformerTypeEnum::VOLTAGE; - else if(s=="USERDEFINED") return IfcTransformerTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcTransformerTypeEnum::NOTDEFINED; - else throw; -} -IfcTransitionCode::IfcTransitionCode IfcTransitionCode::FromString(const std::string& s){ - if (s=="DISCONTINUOUS" ) return IfcTransitionCode::DISCONTINUOUS; - else if(s=="CONTINUOUS" ) return IfcTransitionCode::CONTINUOUS; - else if(s=="CONTSAMEGRADIENT" ) return IfcTransitionCode::CONTSAMEGRADIENT; - else if(s=="CONTSAMEGRADIENTSAMECURVATURE") return IfcTransitionCode::CONTSAMEGRADIENTSAMECURVATURE; - else throw; -} -IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementTypeEnum::FromString(const std::string& s){ - if (s=="ELEVATOR" ) return IfcTransportElementTypeEnum::ELEVATOR; - else if(s=="ESCALATOR" ) return IfcTransportElementTypeEnum::ESCALATOR; - else if(s=="MOVINGWALKWAY") return IfcTransportElementTypeEnum::MOVINGWALKWAY; - else if(s=="USERDEFINED" ) return IfcTransportElementTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcTransportElementTypeEnum::NOTDEFINED; - else throw; -} -IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmingPreference::FromString(const std::string& s){ - if (s=="CARTESIAN" ) return IfcTrimmingPreference::CARTESIAN; - else if(s=="PARAMETER" ) return IfcTrimmingPreference::PARAMETER; - else if(s=="UNSPECIFIED") return IfcTrimmingPreference::UNSPECIFIED; - else throw; -} -IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleTypeEnum::FromString(const std::string& s){ - if (s=="FINNED" ) return IfcTubeBundleTypeEnum::FINNED; - else if(s=="USERDEFINED") return IfcTubeBundleTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcTubeBundleTypeEnum::NOTDEFINED; - else throw; -} -IfcUnitEnum::IfcUnitEnum IfcUnitEnum::FromString(const std::string& s){ - if (s=="ABSORBEDDOSEUNIT" ) return IfcUnitEnum::ABSORBEDDOSEUNIT; - else if(s=="AMOUNTOFSUBSTANCEUNIT" ) return IfcUnitEnum::AMOUNTOFSUBSTANCEUNIT; - else if(s=="AREAUNIT" ) return IfcUnitEnum::AREAUNIT; - else if(s=="DOSEEQUIVALENTUNIT" ) return IfcUnitEnum::DOSEEQUIVALENTUNIT; - else if(s=="ELECTRICCAPACITANCEUNIT" ) return IfcUnitEnum::ELECTRICCAPACITANCEUNIT; - else if(s=="ELECTRICCHARGEUNIT" ) return IfcUnitEnum::ELECTRICCHARGEUNIT; - else if(s=="ELECTRICCONDUCTANCEUNIT" ) return IfcUnitEnum::ELECTRICCONDUCTANCEUNIT; - else if(s=="ELECTRICCURRENTUNIT" ) return IfcUnitEnum::ELECTRICCURRENTUNIT; - else if(s=="ELECTRICRESISTANCEUNIT" ) return IfcUnitEnum::ELECTRICRESISTANCEUNIT; - else if(s=="ELECTRICVOLTAGEUNIT" ) return IfcUnitEnum::ELECTRICVOLTAGEUNIT; - else if(s=="ENERGYUNIT" ) return IfcUnitEnum::ENERGYUNIT; - else if(s=="FORCEUNIT" ) return IfcUnitEnum::FORCEUNIT; - else if(s=="FREQUENCYUNIT" ) return IfcUnitEnum::FREQUENCYUNIT; - else if(s=="ILLUMINANCEUNIT" ) return IfcUnitEnum::ILLUMINANCEUNIT; - else if(s=="INDUCTANCEUNIT" ) return IfcUnitEnum::INDUCTANCEUNIT; - else if(s=="LENGTHUNIT" ) return IfcUnitEnum::LENGTHUNIT; - else if(s=="LUMINOUSFLUXUNIT" ) return IfcUnitEnum::LUMINOUSFLUXUNIT; - else if(s=="LUMINOUSINTENSITYUNIT" ) return IfcUnitEnum::LUMINOUSINTENSITYUNIT; - else if(s=="MAGNETICFLUXDENSITYUNIT" ) return IfcUnitEnum::MAGNETICFLUXDENSITYUNIT; - else if(s=="MAGNETICFLUXUNIT" ) return IfcUnitEnum::MAGNETICFLUXUNIT; - else if(s=="MASSUNIT" ) return IfcUnitEnum::MASSUNIT; - else if(s=="PLANEANGLEUNIT" ) return IfcUnitEnum::PLANEANGLEUNIT; - else if(s=="POWERUNIT" ) return IfcUnitEnum::POWERUNIT; - else if(s=="PRESSUREUNIT" ) return IfcUnitEnum::PRESSUREUNIT; - else if(s=="RADIOACTIVITYUNIT" ) return IfcUnitEnum::RADIOACTIVITYUNIT; - else if(s=="SOLIDANGLEUNIT" ) return IfcUnitEnum::SOLIDANGLEUNIT; - else if(s=="THERMODYNAMICTEMPERATUREUNIT") return IfcUnitEnum::THERMODYNAMICTEMPERATUREUNIT; - else if(s=="TIMEUNIT" ) return IfcUnitEnum::TIMEUNIT; - else if(s=="VOLUMEUNIT" ) return IfcUnitEnum::VOLUMEUNIT; - else if(s=="USERDEFINED" ) return IfcUnitEnum::USERDEFINED; - else throw; -} -IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentTypeEnum::FromString(const std::string& s){ - if (s=="AIRHANDLER" ) return IfcUnitaryEquipmentTypeEnum::AIRHANDLER; - else if(s=="AIRCONDITIONINGUNIT") return IfcUnitaryEquipmentTypeEnum::AIRCONDITIONINGUNIT; - else if(s=="SPLITSYSTEM" ) return IfcUnitaryEquipmentTypeEnum::SPLITSYSTEM; - else if(s=="ROOFTOPUNIT" ) return IfcUnitaryEquipmentTypeEnum::ROOFTOPUNIT; - else if(s=="USERDEFINED" ) return IfcUnitaryEquipmentTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcUnitaryEquipmentTypeEnum::NOTDEFINED; - else throw; -} -IfcValveTypeEnum::IfcValveTypeEnum IfcValveTypeEnum::FromString(const std::string& s){ - if (s=="AIRRELEASE" ) return IfcValveTypeEnum::AIRRELEASE; - else if(s=="ANTIVACUUM" ) return IfcValveTypeEnum::ANTIVACUUM; - else if(s=="CHANGEOVER" ) return IfcValveTypeEnum::CHANGEOVER; - else if(s=="CHECK" ) return IfcValveTypeEnum::CHECK; - else if(s=="COMMISSIONING" ) return IfcValveTypeEnum::COMMISSIONING; - else if(s=="DIVERTING" ) return IfcValveTypeEnum::DIVERTING; - else if(s=="DRAWOFFCOCK" ) return IfcValveTypeEnum::DRAWOFFCOCK; - else if(s=="DOUBLECHECK" ) return IfcValveTypeEnum::DOUBLECHECK; - else if(s=="DOUBLEREGULATING") return IfcValveTypeEnum::DOUBLEREGULATING; - else if(s=="FAUCET" ) return IfcValveTypeEnum::FAUCET; - else if(s=="FLUSHING" ) return IfcValveTypeEnum::FLUSHING; - else if(s=="GASCOCK" ) return IfcValveTypeEnum::GASCOCK; - else if(s=="GASTAP" ) return IfcValveTypeEnum::GASTAP; - else if(s=="ISOLATING" ) return IfcValveTypeEnum::ISOLATING; - else if(s=="MIXING" ) return IfcValveTypeEnum::MIXING; - else if(s=="PRESSUREREDUCING") return IfcValveTypeEnum::PRESSUREREDUCING; - else if(s=="PRESSURERELIEF" ) return IfcValveTypeEnum::PRESSURERELIEF; - else if(s=="REGULATING" ) return IfcValveTypeEnum::REGULATING; - else if(s=="SAFETYCUTOFF" ) return IfcValveTypeEnum::SAFETYCUTOFF; - else if(s=="STEAMTRAP" ) return IfcValveTypeEnum::STEAMTRAP; - else if(s=="STOPCOCK" ) return IfcValveTypeEnum::STOPCOCK; - else if(s=="USERDEFINED" ) return IfcValveTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcValveTypeEnum::NOTDEFINED; - else throw; -} -IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorTypeEnum::FromString(const std::string& s){ - if (s=="COMPRESSION") return IfcVibrationIsolatorTypeEnum::COMPRESSION; - else if(s=="SPRING" ) return IfcVibrationIsolatorTypeEnum::SPRING; - else if(s=="USERDEFINED") return IfcVibrationIsolatorTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcVibrationIsolatorTypeEnum::NOTDEFINED; - else throw; -} -IfcWallTypeEnum::IfcWallTypeEnum IfcWallTypeEnum::FromString(const std::string& s){ - if (s=="STANDARD" ) return IfcWallTypeEnum::STANDARD; - else if(s=="POLYGONAL" ) return IfcWallTypeEnum::POLYGONAL; - else if(s=="SHEAR" ) return IfcWallTypeEnum::SHEAR; - else if(s=="ELEMENTEDWALL") return IfcWallTypeEnum::ELEMENTEDWALL; - else if(s=="PLUMBINGWALL" ) return IfcWallTypeEnum::PLUMBINGWALL; - else if(s=="USERDEFINED" ) return IfcWallTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcWallTypeEnum::NOTDEFINED; - else throw; -} -IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalTypeEnum::FromString(const std::string& s){ - if (s=="FLOORTRAP" ) return IfcWasteTerminalTypeEnum::FLOORTRAP; - else if(s=="FLOORWASTE" ) return IfcWasteTerminalTypeEnum::FLOORWASTE; - else if(s=="GULLYSUMP" ) return IfcWasteTerminalTypeEnum::GULLYSUMP; - else if(s=="GULLYTRAP" ) return IfcWasteTerminalTypeEnum::GULLYTRAP; - else if(s=="GREASEINTERCEPTOR") return IfcWasteTerminalTypeEnum::GREASEINTERCEPTOR; - else if(s=="OILINTERCEPTOR" ) return IfcWasteTerminalTypeEnum::OILINTERCEPTOR; - else if(s=="PETROLINTERCEPTOR") return IfcWasteTerminalTypeEnum::PETROLINTERCEPTOR; - else if(s=="ROOFDRAIN" ) return IfcWasteTerminalTypeEnum::ROOFDRAIN; - else if(s=="WASTEDISPOSALUNIT") return IfcWasteTerminalTypeEnum::WASTEDISPOSALUNIT; - else if(s=="WASTETRAP" ) return IfcWasteTerminalTypeEnum::WASTETRAP; - else if(s=="USERDEFINED" ) return IfcWasteTerminalTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcWasteTerminalTypeEnum::NOTDEFINED; - else throw; -} -IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelOperationEnum::FromString(const std::string& s){ - if (s=="SIDEHUNGRIGHTHAND" ) return IfcWindowPanelOperationEnum::SIDEHUNGRIGHTHAND; - else if(s=="SIDEHUNGLEFTHAND" ) return IfcWindowPanelOperationEnum::SIDEHUNGLEFTHAND; - else if(s=="TILTANDTURNRIGHTHAND") return IfcWindowPanelOperationEnum::TILTANDTURNRIGHTHAND; - else if(s=="TILTANDTURNLEFTHAND" ) return IfcWindowPanelOperationEnum::TILTANDTURNLEFTHAND; - else if(s=="TOPHUNG" ) return IfcWindowPanelOperationEnum::TOPHUNG; - else if(s=="BOTTOMHUNG" ) return IfcWindowPanelOperationEnum::BOTTOMHUNG; - else if(s=="PIVOTHORIZONTAL" ) return IfcWindowPanelOperationEnum::PIVOTHORIZONTAL; - else if(s=="PIVOTVERTICAL" ) return IfcWindowPanelOperationEnum::PIVOTVERTICAL; - else if(s=="SLIDINGHORIZONTAL" ) return IfcWindowPanelOperationEnum::SLIDINGHORIZONTAL; - else if(s=="SLIDINGVERTICAL" ) return IfcWindowPanelOperationEnum::SLIDINGVERTICAL; - else if(s=="REMOVABLECASEMENT" ) return IfcWindowPanelOperationEnum::REMOVABLECASEMENT; - else if(s=="FIXEDCASEMENT" ) return IfcWindowPanelOperationEnum::FIXEDCASEMENT; - else if(s=="OTHEROPERATION" ) return IfcWindowPanelOperationEnum::OTHEROPERATION; - else if(s=="NOTDEFINED" ) return IfcWindowPanelOperationEnum::NOTDEFINED; - else throw; -} -IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelPositionEnum::FromString(const std::string& s){ - if (s=="LEFT" ) return IfcWindowPanelPositionEnum::LEFT; - else if(s=="MIDDLE" ) return IfcWindowPanelPositionEnum::MIDDLE; - else if(s=="RIGHT" ) return IfcWindowPanelPositionEnum::RIGHT; - else if(s=="BOTTOM" ) return IfcWindowPanelPositionEnum::BOTTOM; - else if(s=="TOP" ) return IfcWindowPanelPositionEnum::TOP; - else if(s=="NOTDEFINED") return IfcWindowPanelPositionEnum::NOTDEFINED; - else throw; -} -IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyleConstructionEnum::FromString(const std::string& s){ - if (s=="ALUMINIUM" ) return IfcWindowStyleConstructionEnum::ALUMINIUM; - else if(s=="HIGH_GRADE_STEEL" ) return IfcWindowStyleConstructionEnum::HIGH_GRADE_STEEL; - else if(s=="STEEL" ) return IfcWindowStyleConstructionEnum::STEEL; - else if(s=="WOOD" ) return IfcWindowStyleConstructionEnum::WOOD; - else if(s=="ALUMINIUM_WOOD" ) return IfcWindowStyleConstructionEnum::ALUMINIUM_WOOD; - else if(s=="PLASTIC" ) return IfcWindowStyleConstructionEnum::PLASTIC; - else if(s=="OTHER_CONSTRUCTION") return IfcWindowStyleConstructionEnum::OTHER_CONSTRUCTION; - else if(s=="NOTDEFINED" ) return IfcWindowStyleConstructionEnum::NOTDEFINED; - else throw; -} -IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyleOperationEnum::FromString(const std::string& s){ - if (s=="SINGLE_PANEL" ) return IfcWindowStyleOperationEnum::SINGLE_PANEL; - else if(s=="DOUBLE_PANEL_VERTICAL" ) return IfcWindowStyleOperationEnum::DOUBLE_PANEL_VERTICAL; - else if(s=="DOUBLE_PANEL_HORIZONTAL") return IfcWindowStyleOperationEnum::DOUBLE_PANEL_HORIZONTAL; - else if(s=="TRIPLE_PANEL_VERTICAL" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_VERTICAL; - else if(s=="TRIPLE_PANEL_BOTTOM" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_BOTTOM; - else if(s=="TRIPLE_PANEL_TOP" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_TOP; - else if(s=="TRIPLE_PANEL_LEFT" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_LEFT; - else if(s=="TRIPLE_PANEL_RIGHT" ) return IfcWindowStyleOperationEnum::TRIPLE_PANEL_RIGHT; - else if(s=="TRIPLE_PANEL_HORIZONTAL") return IfcWindowStyleOperationEnum::TRIPLE_PANEL_HORIZONTAL; - else if(s=="USERDEFINED" ) return IfcWindowStyleOperationEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcWindowStyleOperationEnum::NOTDEFINED; - else throw; -} -IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControlTypeEnum::FromString(const std::string& s){ - if (s=="ACTUAL" ) return IfcWorkControlTypeEnum::ACTUAL; - else if(s=="BASELINE" ) return IfcWorkControlTypeEnum::BASELINE; - else if(s=="PLANNED" ) return IfcWorkControlTypeEnum::PLANNED; - else if(s=="USERDEFINED") return IfcWorkControlTypeEnum::USERDEFINED; - else if(s=="NOTDEFINED" ) return IfcWorkControlTypeEnum::NOTDEFINED; - else throw; -} +IfcWorkControlTypeEnum::IfcWorkControlTypeEnum IfcWorkControlTypeEnum::FromString(const std::string& s) { + if(s=="ACTUAL" ) return IfcWorkControlTypeEnum::ACTUAL; + if(s=="BASELINE" ) return IfcWorkControlTypeEnum::BASELINE; + if(s=="PLANNED" ) return IfcWorkControlTypeEnum::PLANNED; + if(s=="USERDEFINED") return IfcWorkControlTypeEnum::USERDEFINED; + if(s=="NOTDEFINED" ) return IfcWorkControlTypeEnum::NOTDEFINED; + throw; +} + // Ifc2DCompositeCurve bool Ifc2DCompositeCurve::is(Type::Enum v) { return v == Type::Ifc2DCompositeCurve || IfcCompositeCurve::is(v); } Type::Enum Ifc2DCompositeCurve::type() { return Type::Ifc2DCompositeCurve; } Type::Enum Ifc2DCompositeCurve::Class() { return Type::Ifc2DCompositeCurve; } -Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcAbstractEntityPtr e) { if (!is(Type::Ifc2DCompositeCurve)) throw; entity = e; } +Ifc2DCompositeCurve::Ifc2DCompositeCurve(IfcAbstractEntityPtr e) { if (!is(Type::Ifc2DCompositeCurve)) throw; entity = e; } // IfcActionRequest IfcIdentifier IfcActionRequest::RequestID() { return *entity->getArgument(5); } bool IfcActionRequest::is(Type::Enum v) { return v == Type::IfcActionRequest || IfcControl::is(v); } Type::Enum IfcActionRequest::type() { return Type::IfcActionRequest; } Type::Enum IfcActionRequest::Class() { return Type::IfcActionRequest; } -IfcActionRequest::IfcActionRequest(IfcAbstractEntityPtr e) { if (!is(Type::IfcActionRequest)) throw; entity = e; } +IfcActionRequest::IfcActionRequest(IfcAbstractEntityPtr e) { if (!is(Type::IfcActionRequest)) throw; entity = e; } // IfcActor IfcActorSelect IfcActor::TheActor() { return *entity->getArgument(5); } IfcRelAssignsToActor::list IfcActor::IsActingUpon() { RETURN_INVERSE(IfcRelAssignsToActor) } bool IfcActor::is(Type::Enum v) { return v == Type::IfcActor || IfcObject::is(v); } Type::Enum IfcActor::type() { return Type::IfcActor; } Type::Enum IfcActor::Class() { return Type::IfcActor; } -IfcActor::IfcActor(IfcAbstractEntityPtr e) { if (!is(Type::IfcActor)) throw; entity = e; } +IfcActor::IfcActor(IfcAbstractEntityPtr e) { if (!is(Type::IfcActor)) throw; entity = e; } // IfcActorRole IfcRoleEnum::IfcRoleEnum IfcActorRole::Role() { return IfcRoleEnum::FromString(*entity->getArgument(0)); } bool IfcActorRole::hasUserDefinedRole() { return !entity->getArgument(1)->isNull(); } @@ -4208,13 +4207,13 @@ IfcText IfcActorRole::Description() { return *entity->getArgument(2); } bool IfcActorRole::is(Type::Enum v) { return v == Type::IfcActorRole; } Type::Enum IfcActorRole::type() { return Type::IfcActorRole; } Type::Enum IfcActorRole::Class() { return Type::IfcActorRole; } -IfcActorRole::IfcActorRole(IfcAbstractEntityPtr e) { if (!is(Type::IfcActorRole)) throw; entity = e; } +IfcActorRole::IfcActorRole(IfcAbstractEntityPtr e) { if (!is(Type::IfcActorRole)) throw; entity = e; } // IfcActuatorType IfcActuatorTypeEnum::IfcActuatorTypeEnum IfcActuatorType::PredefinedType() { return IfcActuatorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcActuatorType::is(Type::Enum v) { return v == Type::IfcActuatorType || IfcDistributionControlElementType::is(v); } Type::Enum IfcActuatorType::type() { return Type::IfcActuatorType; } Type::Enum IfcActuatorType::Class() { return Type::IfcActuatorType; } -IfcActuatorType::IfcActuatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcActuatorType)) throw; entity = e; } +IfcActuatorType::IfcActuatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcActuatorType)) throw; entity = e; } // IfcAddress bool IfcAddress::hasPurpose() { return !entity->getArgument(0)->isNull(); } IfcAddressTypeEnum::IfcAddressTypeEnum IfcAddress::Purpose() { return IfcAddressTypeEnum::FromString(*entity->getArgument(0)); } @@ -4227,47 +4226,47 @@ IfcOrganization::list IfcAddress::OfOrganization() { RETURN_INVERSE(IfcOrganizat bool IfcAddress::is(Type::Enum v) { return v == Type::IfcAddress; } Type::Enum IfcAddress::type() { return Type::IfcAddress; } Type::Enum IfcAddress::Class() { return Type::IfcAddress; } -IfcAddress::IfcAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcAddress)) throw; entity = e; } +IfcAddress::IfcAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcAddress)) throw; entity = e; } // IfcAirTerminalBoxType IfcAirTerminalBoxTypeEnum::IfcAirTerminalBoxTypeEnum IfcAirTerminalBoxType::PredefinedType() { return IfcAirTerminalBoxTypeEnum::FromString(*entity->getArgument(9)); } bool IfcAirTerminalBoxType::is(Type::Enum v) { return v == Type::IfcAirTerminalBoxType || IfcFlowControllerType::is(v); } Type::Enum IfcAirTerminalBoxType::type() { return Type::IfcAirTerminalBoxType; } Type::Enum IfcAirTerminalBoxType::Class() { return Type::IfcAirTerminalBoxType; } -IfcAirTerminalBoxType::IfcAirTerminalBoxType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirTerminalBoxType)) throw; entity = e; } +IfcAirTerminalBoxType::IfcAirTerminalBoxType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirTerminalBoxType)) throw; entity = e; } // IfcAirTerminalType IfcAirTerminalTypeEnum::IfcAirTerminalTypeEnum IfcAirTerminalType::PredefinedType() { return IfcAirTerminalTypeEnum::FromString(*entity->getArgument(9)); } bool IfcAirTerminalType::is(Type::Enum v) { return v == Type::IfcAirTerminalType || IfcFlowTerminalType::is(v); } Type::Enum IfcAirTerminalType::type() { return Type::IfcAirTerminalType; } Type::Enum IfcAirTerminalType::Class() { return Type::IfcAirTerminalType; } -IfcAirTerminalType::IfcAirTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirTerminalType)) throw; entity = e; } +IfcAirTerminalType::IfcAirTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirTerminalType)) throw; entity = e; } // IfcAirToAirHeatRecoveryType IfcAirToAirHeatRecoveryTypeEnum::IfcAirToAirHeatRecoveryTypeEnum IfcAirToAirHeatRecoveryType::PredefinedType() { return IfcAirToAirHeatRecoveryTypeEnum::FromString(*entity->getArgument(9)); } bool IfcAirToAirHeatRecoveryType::is(Type::Enum v) { return v == Type::IfcAirToAirHeatRecoveryType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcAirToAirHeatRecoveryType::type() { return Type::IfcAirToAirHeatRecoveryType; } Type::Enum IfcAirToAirHeatRecoveryType::Class() { return Type::IfcAirToAirHeatRecoveryType; } -IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirToAirHeatRecoveryType)) throw; entity = e; } +IfcAirToAirHeatRecoveryType::IfcAirToAirHeatRecoveryType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAirToAirHeatRecoveryType)) throw; entity = e; } // IfcAlarmType IfcAlarmTypeEnum::IfcAlarmTypeEnum IfcAlarmType::PredefinedType() { return IfcAlarmTypeEnum::FromString(*entity->getArgument(9)); } bool IfcAlarmType::is(Type::Enum v) { return v == Type::IfcAlarmType || IfcDistributionControlElementType::is(v); } Type::Enum IfcAlarmType::type() { return Type::IfcAlarmType; } Type::Enum IfcAlarmType::Class() { return Type::IfcAlarmType; } -IfcAlarmType::IfcAlarmType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAlarmType)) throw; entity = e; } +IfcAlarmType::IfcAlarmType(IfcAbstractEntityPtr e) { if (!is(Type::IfcAlarmType)) throw; entity = e; } // IfcAngularDimension bool IfcAngularDimension::is(Type::Enum v) { return v == Type::IfcAngularDimension || IfcDimensionCurveDirectedCallout::is(v); } Type::Enum IfcAngularDimension::type() { return Type::IfcAngularDimension; } Type::Enum IfcAngularDimension::Class() { return Type::IfcAngularDimension; } -IfcAngularDimension::IfcAngularDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcAngularDimension)) throw; entity = e; } +IfcAngularDimension::IfcAngularDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcAngularDimension)) throw; entity = e; } // IfcAnnotation IfcRelContainedInSpatialStructure::list IfcAnnotation::ContainedInStructure() { RETURN_INVERSE(IfcRelContainedInSpatialStructure) } bool IfcAnnotation::is(Type::Enum v) { return v == Type::IfcAnnotation || IfcProduct::is(v); } Type::Enum IfcAnnotation::type() { return Type::IfcAnnotation; } Type::Enum IfcAnnotation::Class() { return Type::IfcAnnotation; } -IfcAnnotation::IfcAnnotation(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotation)) throw; entity = e; } +IfcAnnotation::IfcAnnotation(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotation)) throw; entity = e; } // IfcAnnotationCurveOccurrence bool IfcAnnotationCurveOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationCurveOccurrence || IfcAnnotationOccurrence::is(v); } Type::Enum IfcAnnotationCurveOccurrence::type() { return Type::IfcAnnotationCurveOccurrence; } Type::Enum IfcAnnotationCurveOccurrence::Class() { return Type::IfcAnnotationCurveOccurrence; } -IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationCurveOccurrence)) throw; entity = e; } +IfcAnnotationCurveOccurrence::IfcAnnotationCurveOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationCurveOccurrence)) throw; entity = e; } // IfcAnnotationFillArea SHARED_PTR IfcAnnotationFillArea::OuterBoundary() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcAnnotationFillArea::hasInnerBoundaries() { return !entity->getArgument(1)->isNull(); } @@ -4275,7 +4274,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcAnnotationFillArea::InnerBound bool IfcAnnotationFillArea::is(Type::Enum v) { return v == Type::IfcAnnotationFillArea || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcAnnotationFillArea::type() { return Type::IfcAnnotationFillArea; } Type::Enum IfcAnnotationFillArea::Class() { return Type::IfcAnnotationFillArea; } -IfcAnnotationFillArea::IfcAnnotationFillArea(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationFillArea)) throw; entity = e; } +IfcAnnotationFillArea::IfcAnnotationFillArea(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationFillArea)) throw; entity = e; } // IfcAnnotationFillAreaOccurrence bool IfcAnnotationFillAreaOccurrence::hasFillStyleTarget() { return !entity->getArgument(3)->isNull(); } SHARED_PTR IfcAnnotationFillAreaOccurrence::FillStyleTarget() { return reinterpret_pointer_cast(*entity->getArgument(3)); } @@ -4284,12 +4283,12 @@ IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcAnnotationFillAreaOccurrence::Glob bool IfcAnnotationFillAreaOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationFillAreaOccurrence || IfcAnnotationOccurrence::is(v); } Type::Enum IfcAnnotationFillAreaOccurrence::type() { return Type::IfcAnnotationFillAreaOccurrence; } Type::Enum IfcAnnotationFillAreaOccurrence::Class() { return Type::IfcAnnotationFillAreaOccurrence; } -IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationFillAreaOccurrence)) throw; entity = e; } +IfcAnnotationFillAreaOccurrence::IfcAnnotationFillAreaOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationFillAreaOccurrence)) throw; entity = e; } // IfcAnnotationOccurrence bool IfcAnnotationOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationOccurrence || IfcStyledItem::is(v); } Type::Enum IfcAnnotationOccurrence::type() { return Type::IfcAnnotationOccurrence; } Type::Enum IfcAnnotationOccurrence::Class() { return Type::IfcAnnotationOccurrence; } -IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationOccurrence)) throw; entity = e; } +IfcAnnotationOccurrence::IfcAnnotationOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationOccurrence)) throw; entity = e; } // IfcAnnotationSurface SHARED_PTR IfcAnnotationSurface::Item() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcAnnotationSurface::hasTextureCoordinates() { return !entity->getArgument(1)->isNull(); } @@ -4297,22 +4296,22 @@ SHARED_PTR IfcAnnotationSurface::TextureCoordinates() { re bool IfcAnnotationSurface::is(Type::Enum v) { return v == Type::IfcAnnotationSurface || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcAnnotationSurface::type() { return Type::IfcAnnotationSurface; } Type::Enum IfcAnnotationSurface::Class() { return Type::IfcAnnotationSurface; } -IfcAnnotationSurface::IfcAnnotationSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSurface)) throw; entity = e; } +IfcAnnotationSurface::IfcAnnotationSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSurface)) throw; entity = e; } // IfcAnnotationSurfaceOccurrence bool IfcAnnotationSurfaceOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationSurfaceOccurrence || IfcAnnotationOccurrence::is(v); } Type::Enum IfcAnnotationSurfaceOccurrence::type() { return Type::IfcAnnotationSurfaceOccurrence; } Type::Enum IfcAnnotationSurfaceOccurrence::Class() { return Type::IfcAnnotationSurfaceOccurrence; } -IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSurfaceOccurrence)) throw; entity = e; } +IfcAnnotationSurfaceOccurrence::IfcAnnotationSurfaceOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSurfaceOccurrence)) throw; entity = e; } // IfcAnnotationSymbolOccurrence bool IfcAnnotationSymbolOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationSymbolOccurrence || IfcAnnotationOccurrence::is(v); } Type::Enum IfcAnnotationSymbolOccurrence::type() { return Type::IfcAnnotationSymbolOccurrence; } Type::Enum IfcAnnotationSymbolOccurrence::Class() { return Type::IfcAnnotationSymbolOccurrence; } -IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSymbolOccurrence)) throw; entity = e; } +IfcAnnotationSymbolOccurrence::IfcAnnotationSymbolOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationSymbolOccurrence)) throw; entity = e; } // IfcAnnotationTextOccurrence bool IfcAnnotationTextOccurrence::is(Type::Enum v) { return v == Type::IfcAnnotationTextOccurrence || IfcAnnotationOccurrence::is(v); } Type::Enum IfcAnnotationTextOccurrence::type() { return Type::IfcAnnotationTextOccurrence; } Type::Enum IfcAnnotationTextOccurrence::Class() { return Type::IfcAnnotationTextOccurrence; } -IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationTextOccurrence)) throw; entity = e; } +IfcAnnotationTextOccurrence::IfcAnnotationTextOccurrence(IfcAbstractEntityPtr e) { if (!is(Type::IfcAnnotationTextOccurrence)) throw; entity = e; } // IfcApplication SHARED_PTR IfcApplication::ApplicationDeveloper() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcLabel IfcApplication::Version() { return *entity->getArgument(1); } @@ -4321,7 +4320,7 @@ IfcIdentifier IfcApplication::ApplicationIdentifier() { return *entity->getArgum bool IfcApplication::is(Type::Enum v) { return v == Type::IfcApplication; } Type::Enum IfcApplication::type() { return Type::IfcApplication; } Type::Enum IfcApplication::Class() { return Type::IfcApplication; } -IfcApplication::IfcApplication(IfcAbstractEntityPtr e) { if (!is(Type::IfcApplication)) throw; entity = e; } +IfcApplication::IfcApplication(IfcAbstractEntityPtr e) { if (!is(Type::IfcApplication)) throw; entity = e; } // IfcAppliedValue bool IfcAppliedValue::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcAppliedValue::Name() { return *entity->getArgument(0); } @@ -4341,7 +4340,7 @@ IfcAppliedValueRelationship::list IfcAppliedValue::IsComponentIn() { RETURN_INVE bool IfcAppliedValue::is(Type::Enum v) { return v == Type::IfcAppliedValue; } Type::Enum IfcAppliedValue::type() { return Type::IfcAppliedValue; } Type::Enum IfcAppliedValue::Class() { return Type::IfcAppliedValue; } -IfcAppliedValue::IfcAppliedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcAppliedValue)) throw; entity = e; } +IfcAppliedValue::IfcAppliedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcAppliedValue)) throw; entity = e; } // IfcAppliedValueRelationship SHARED_PTR IfcAppliedValueRelationship::ComponentOfTotal() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcAppliedValueRelationship::Components() { RETURN_AS_LIST(IfcAppliedValue,1) } @@ -4353,7 +4352,7 @@ IfcText IfcAppliedValueRelationship::Description() { return *entity->getArgument bool IfcAppliedValueRelationship::is(Type::Enum v) { return v == Type::IfcAppliedValueRelationship; } Type::Enum IfcAppliedValueRelationship::type() { return Type::IfcAppliedValueRelationship; } Type::Enum IfcAppliedValueRelationship::Class() { return Type::IfcAppliedValueRelationship; } -IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcAppliedValueRelationship)) throw; entity = e; } +IfcAppliedValueRelationship::IfcAppliedValueRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcAppliedValueRelationship)) throw; entity = e; } // IfcApproval bool IfcApproval::hasDescription() { return !entity->getArgument(0)->isNull(); } IfcText IfcApproval::Description() { return *entity->getArgument(0); } @@ -4372,7 +4371,7 @@ IfcApprovalRelationship::list IfcApproval::Relates() { RETURN_INVERSE(IfcApprova bool IfcApproval::is(Type::Enum v) { return v == Type::IfcApproval; } Type::Enum IfcApproval::type() { return Type::IfcApproval; } Type::Enum IfcApproval::Class() { return Type::IfcApproval; } -IfcApproval::IfcApproval(IfcAbstractEntityPtr e) { if (!is(Type::IfcApproval)) throw; entity = e; } +IfcApproval::IfcApproval(IfcAbstractEntityPtr e) { if (!is(Type::IfcApproval)) throw; entity = e; } // IfcApprovalActorRelationship IfcActorSelect IfcApprovalActorRelationship::Actor() { return *entity->getArgument(0); } SHARED_PTR IfcApprovalActorRelationship::Approval() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -4380,14 +4379,14 @@ SHARED_PTR IfcApprovalActorRelationship::Role() { return reinterpr bool IfcApprovalActorRelationship::is(Type::Enum v) { return v == Type::IfcApprovalActorRelationship; } Type::Enum IfcApprovalActorRelationship::type() { return Type::IfcApprovalActorRelationship; } Type::Enum IfcApprovalActorRelationship::Class() { return Type::IfcApprovalActorRelationship; } -IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalActorRelationship)) throw; entity = e; } +IfcApprovalActorRelationship::IfcApprovalActorRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalActorRelationship)) throw; entity = e; } // IfcApprovalPropertyRelationship SHARED_PTR< IfcTemplatedEntityList > IfcApprovalPropertyRelationship::ApprovedProperties() { RETURN_AS_LIST(IfcProperty,0) } SHARED_PTR IfcApprovalPropertyRelationship::Approval() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcApprovalPropertyRelationship::is(Type::Enum v) { return v == Type::IfcApprovalPropertyRelationship; } Type::Enum IfcApprovalPropertyRelationship::type() { return Type::IfcApprovalPropertyRelationship; } Type::Enum IfcApprovalPropertyRelationship::Class() { return Type::IfcApprovalPropertyRelationship; } -IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalPropertyRelationship)) throw; entity = e; } +IfcApprovalPropertyRelationship::IfcApprovalPropertyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalPropertyRelationship)) throw; entity = e; } // IfcApprovalRelationship SHARED_PTR IfcApprovalRelationship::RelatedApproval() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcApprovalRelationship::RelatingApproval() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -4397,25 +4396,25 @@ IfcLabel IfcApprovalRelationship::Name() { return *entity->getArgument(3); } bool IfcApprovalRelationship::is(Type::Enum v) { return v == Type::IfcApprovalRelationship; } Type::Enum IfcApprovalRelationship::type() { return Type::IfcApprovalRelationship; } Type::Enum IfcApprovalRelationship::Class() { return Type::IfcApprovalRelationship; } -IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalRelationship)) throw; entity = e; } +IfcApprovalRelationship::IfcApprovalRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcApprovalRelationship)) throw; entity = e; } // IfcArbitraryClosedProfileDef SHARED_PTR IfcArbitraryClosedProfileDef::OuterCurve() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcArbitraryClosedProfileDef::is(Type::Enum v) { return v == Type::IfcArbitraryClosedProfileDef || IfcProfileDef::is(v); } Type::Enum IfcArbitraryClosedProfileDef::type() { return Type::IfcArbitraryClosedProfileDef; } Type::Enum IfcArbitraryClosedProfileDef::Class() { return Type::IfcArbitraryClosedProfileDef; } -IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryClosedProfileDef)) throw; entity = e; } +IfcArbitraryClosedProfileDef::IfcArbitraryClosedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryClosedProfileDef)) throw; entity = e; } // IfcArbitraryOpenProfileDef SHARED_PTR IfcArbitraryOpenProfileDef::Curve() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcArbitraryOpenProfileDef::is(Type::Enum v) { return v == Type::IfcArbitraryOpenProfileDef || IfcProfileDef::is(v); } Type::Enum IfcArbitraryOpenProfileDef::type() { return Type::IfcArbitraryOpenProfileDef; } Type::Enum IfcArbitraryOpenProfileDef::Class() { return Type::IfcArbitraryOpenProfileDef; } -IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryOpenProfileDef)) throw; entity = e; } +IfcArbitraryOpenProfileDef::IfcArbitraryOpenProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryOpenProfileDef)) throw; entity = e; } // IfcArbitraryProfileDefWithVoids SHARED_PTR< IfcTemplatedEntityList > IfcArbitraryProfileDefWithVoids::InnerCurves() { RETURN_AS_LIST(IfcCurve,3) } bool IfcArbitraryProfileDefWithVoids::is(Type::Enum v) { return v == Type::IfcArbitraryProfileDefWithVoids || IfcArbitraryClosedProfileDef::is(v); } Type::Enum IfcArbitraryProfileDefWithVoids::type() { return Type::IfcArbitraryProfileDefWithVoids; } Type::Enum IfcArbitraryProfileDefWithVoids::Class() { return Type::IfcArbitraryProfileDefWithVoids; } -IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryProfileDefWithVoids)) throw; entity = e; } +IfcArbitraryProfileDefWithVoids::IfcArbitraryProfileDefWithVoids(IfcAbstractEntityPtr e) { if (!is(Type::IfcArbitraryProfileDefWithVoids)) throw; entity = e; } // IfcAsset IfcIdentifier IfcAsset::AssetID() { return *entity->getArgument(5); } SHARED_PTR IfcAsset::OriginalValue() { return reinterpret_pointer_cast(*entity->getArgument(6)); } @@ -4429,7 +4428,7 @@ SHARED_PTR IfcAsset::DepreciatedValue() { return reinterpret_point bool IfcAsset::is(Type::Enum v) { return v == Type::IfcAsset || IfcGroup::is(v); } Type::Enum IfcAsset::type() { return Type::IfcAsset; } Type::Enum IfcAsset::Class() { return Type::IfcAsset; } -IfcAsset::IfcAsset(IfcAbstractEntityPtr e) { if (!is(Type::IfcAsset)) throw; entity = e; } +IfcAsset::IfcAsset(IfcAbstractEntityPtr e) { if (!is(Type::IfcAsset)) throw; entity = e; } // IfcAsymmetricIShapeProfileDef IfcPositiveLengthMeasure IfcAsymmetricIShapeProfileDef::TopFlangeWidth() { return *entity->getArgument(8); } bool IfcAsymmetricIShapeProfileDef::hasTopFlangeThickness() { return !entity->getArgument(9)->isNull(); } @@ -4441,21 +4440,21 @@ IfcPositiveLengthMeasure IfcAsymmetricIShapeProfileDef::CentreOfGravityInY() { r bool IfcAsymmetricIShapeProfileDef::is(Type::Enum v) { return v == Type::IfcAsymmetricIShapeProfileDef || IfcIShapeProfileDef::is(v); } Type::Enum IfcAsymmetricIShapeProfileDef::type() { return Type::IfcAsymmetricIShapeProfileDef; } Type::Enum IfcAsymmetricIShapeProfileDef::Class() { return Type::IfcAsymmetricIShapeProfileDef; } -IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcAsymmetricIShapeProfileDef)) throw; entity = e; } +IfcAsymmetricIShapeProfileDef::IfcAsymmetricIShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcAsymmetricIShapeProfileDef)) throw; entity = e; } // IfcAxis1Placement bool IfcAxis1Placement::hasAxis() { return !entity->getArgument(1)->isNull(); } SHARED_PTR IfcAxis1Placement::Axis() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcAxis1Placement::is(Type::Enum v) { return v == Type::IfcAxis1Placement || IfcPlacement::is(v); } Type::Enum IfcAxis1Placement::type() { return Type::IfcAxis1Placement; } Type::Enum IfcAxis1Placement::Class() { return Type::IfcAxis1Placement; } -IfcAxis1Placement::IfcAxis1Placement(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis1Placement)) throw; entity = e; } +IfcAxis1Placement::IfcAxis1Placement(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis1Placement)) throw; entity = e; } // IfcAxis2Placement2D bool IfcAxis2Placement2D::hasRefDirection() { return !entity->getArgument(1)->isNull(); } SHARED_PTR IfcAxis2Placement2D::RefDirection() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcAxis2Placement2D::is(Type::Enum v) { return v == Type::IfcAxis2Placement2D || IfcPlacement::is(v); } Type::Enum IfcAxis2Placement2D::type() { return Type::IfcAxis2Placement2D; } Type::Enum IfcAxis2Placement2D::Class() { return Type::IfcAxis2Placement2D; } -IfcAxis2Placement2D::IfcAxis2Placement2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis2Placement2D)) throw; entity = e; } +IfcAxis2Placement2D::IfcAxis2Placement2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis2Placement2D)) throw; entity = e; } // IfcAxis2Placement3D bool IfcAxis2Placement3D::hasAxis() { return !entity->getArgument(1)->isNull(); } SHARED_PTR IfcAxis2Placement3D::Axis() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -4464,7 +4463,7 @@ SHARED_PTR IfcAxis2Placement3D::RefDirection() { return reinterpre bool IfcAxis2Placement3D::is(Type::Enum v) { return v == Type::IfcAxis2Placement3D || IfcPlacement::is(v); } Type::Enum IfcAxis2Placement3D::type() { return Type::IfcAxis2Placement3D; } Type::Enum IfcAxis2Placement3D::Class() { return Type::IfcAxis2Placement3D; } -IfcAxis2Placement3D::IfcAxis2Placement3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis2Placement3D)) throw; entity = e; } +IfcAxis2Placement3D::IfcAxis2Placement3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcAxis2Placement3D)) throw; entity = e; } // IfcBSplineCurve int IfcBSplineCurve::Degree() { return *entity->getArgument(0); } SHARED_PTR< IfcTemplatedEntityList > IfcBSplineCurve::ControlPointsList() { RETURN_AS_LIST(IfcCartesianPoint,1) } @@ -4474,30 +4473,30 @@ bool IfcBSplineCurve::SelfIntersect() { return *entity->getArgument(4); } bool IfcBSplineCurve::is(Type::Enum v) { return v == Type::IfcBSplineCurve || IfcBoundedCurve::is(v); } Type::Enum IfcBSplineCurve::type() { return Type::IfcBSplineCurve; } Type::Enum IfcBSplineCurve::Class() { return Type::IfcBSplineCurve; } -IfcBSplineCurve::IfcBSplineCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBSplineCurve)) throw; entity = e; } +IfcBSplineCurve::IfcBSplineCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBSplineCurve)) throw; entity = e; } // IfcBeam bool IfcBeam::is(Type::Enum v) { return v == Type::IfcBeam || IfcBuildingElement::is(v); } Type::Enum IfcBeam::type() { return Type::IfcBeam; } Type::Enum IfcBeam::Class() { return Type::IfcBeam; } -IfcBeam::IfcBeam(IfcAbstractEntityPtr e) { if (!is(Type::IfcBeam)) throw; entity = e; } +IfcBeam::IfcBeam(IfcAbstractEntityPtr e) { if (!is(Type::IfcBeam)) throw; entity = e; } // IfcBeamType IfcBeamTypeEnum::IfcBeamTypeEnum IfcBeamType::PredefinedType() { return IfcBeamTypeEnum::FromString(*entity->getArgument(9)); } bool IfcBeamType::is(Type::Enum v) { return v == Type::IfcBeamType || IfcBuildingElementType::is(v); } Type::Enum IfcBeamType::type() { return Type::IfcBeamType; } Type::Enum IfcBeamType::Class() { return Type::IfcBeamType; } -IfcBeamType::IfcBeamType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBeamType)) throw; entity = e; } +IfcBeamType::IfcBeamType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBeamType)) throw; entity = e; } // IfcBezierCurve bool IfcBezierCurve::is(Type::Enum v) { return v == Type::IfcBezierCurve || IfcBSplineCurve::is(v); } Type::Enum IfcBezierCurve::type() { return Type::IfcBezierCurve; } Type::Enum IfcBezierCurve::Class() { return Type::IfcBezierCurve; } -IfcBezierCurve::IfcBezierCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBezierCurve)) throw; entity = e; } +IfcBezierCurve::IfcBezierCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBezierCurve)) throw; entity = e; } // IfcBlobTexture IfcIdentifier IfcBlobTexture::RasterFormat() { return *entity->getArgument(4); } bool IfcBlobTexture::RasterCode() { return *entity->getArgument(5); } bool IfcBlobTexture::is(Type::Enum v) { return v == Type::IfcBlobTexture || IfcSurfaceTexture::is(v); } Type::Enum IfcBlobTexture::type() { return Type::IfcBlobTexture; } Type::Enum IfcBlobTexture::Class() { return Type::IfcBlobTexture; } -IfcBlobTexture::IfcBlobTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcBlobTexture)) throw; entity = e; } +IfcBlobTexture::IfcBlobTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcBlobTexture)) throw; entity = e; } // IfcBlock IfcPositiveLengthMeasure IfcBlock::XLength() { return *entity->getArgument(1); } IfcPositiveLengthMeasure IfcBlock::YLength() { return *entity->getArgument(2); } @@ -4505,18 +4504,18 @@ IfcPositiveLengthMeasure IfcBlock::ZLength() { return *entity->getArgument(3); } bool IfcBlock::is(Type::Enum v) { return v == Type::IfcBlock || IfcCsgPrimitive3D::is(v); } Type::Enum IfcBlock::type() { return Type::IfcBlock; } Type::Enum IfcBlock::Class() { return Type::IfcBlock; } -IfcBlock::IfcBlock(IfcAbstractEntityPtr e) { if (!is(Type::IfcBlock)) throw; entity = e; } +IfcBlock::IfcBlock(IfcAbstractEntityPtr e) { if (!is(Type::IfcBlock)) throw; entity = e; } // IfcBoilerType IfcBoilerTypeEnum::IfcBoilerTypeEnum IfcBoilerType::PredefinedType() { return IfcBoilerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcBoilerType::is(Type::Enum v) { return v == Type::IfcBoilerType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcBoilerType::type() { return Type::IfcBoilerType; } Type::Enum IfcBoilerType::Class() { return Type::IfcBoilerType; } -IfcBoilerType::IfcBoilerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoilerType)) throw; entity = e; } +IfcBoilerType::IfcBoilerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoilerType)) throw; entity = e; } // IfcBooleanClippingResult bool IfcBooleanClippingResult::is(Type::Enum v) { return v == Type::IfcBooleanClippingResult || IfcBooleanResult::is(v); } Type::Enum IfcBooleanClippingResult::type() { return Type::IfcBooleanClippingResult; } Type::Enum IfcBooleanClippingResult::Class() { return Type::IfcBooleanClippingResult; } -IfcBooleanClippingResult::IfcBooleanClippingResult(IfcAbstractEntityPtr e) { if (!is(Type::IfcBooleanClippingResult)) throw; entity = e; } +IfcBooleanClippingResult::IfcBooleanClippingResult(IfcAbstractEntityPtr e) { if (!is(Type::IfcBooleanClippingResult)) throw; entity = e; } // IfcBooleanResult IfcBooleanOperator::IfcBooleanOperator IfcBooleanResult::Operator() { return IfcBooleanOperator::FromString(*entity->getArgument(0)); } IfcBooleanOperand IfcBooleanResult::FirstOperand() { return *entity->getArgument(1); } @@ -4524,14 +4523,14 @@ IfcBooleanOperand IfcBooleanResult::SecondOperand() { return *entity->getArgumen bool IfcBooleanResult::is(Type::Enum v) { return v == Type::IfcBooleanResult || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcBooleanResult::type() { return Type::IfcBooleanResult; } Type::Enum IfcBooleanResult::Class() { return Type::IfcBooleanResult; } -IfcBooleanResult::IfcBooleanResult(IfcAbstractEntityPtr e) { if (!is(Type::IfcBooleanResult)) throw; entity = e; } +IfcBooleanResult::IfcBooleanResult(IfcAbstractEntityPtr e) { if (!is(Type::IfcBooleanResult)) throw; entity = e; } // IfcBoundaryCondition bool IfcBoundaryCondition::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcBoundaryCondition::Name() { return *entity->getArgument(0); } bool IfcBoundaryCondition::is(Type::Enum v) { return v == Type::IfcBoundaryCondition; } Type::Enum IfcBoundaryCondition::type() { return Type::IfcBoundaryCondition; } Type::Enum IfcBoundaryCondition::Class() { return Type::IfcBoundaryCondition; } -IfcBoundaryCondition::IfcBoundaryCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryCondition)) throw; entity = e; } +IfcBoundaryCondition::IfcBoundaryCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryCondition)) throw; entity = e; } // IfcBoundaryEdgeCondition bool IfcBoundaryEdgeCondition::hasLinearStiffnessByLengthX() { return !entity->getArgument(1)->isNull(); } IfcModulusOfLinearSubgradeReactionMeasure IfcBoundaryEdgeCondition::LinearStiffnessByLengthX() { return *entity->getArgument(1); } @@ -4548,7 +4547,7 @@ IfcModulusOfRotationalSubgradeReactionMeasure IfcBoundaryEdgeCondition::Rotation bool IfcBoundaryEdgeCondition::is(Type::Enum v) { return v == Type::IfcBoundaryEdgeCondition || IfcBoundaryCondition::is(v); } Type::Enum IfcBoundaryEdgeCondition::type() { return Type::IfcBoundaryEdgeCondition; } Type::Enum IfcBoundaryEdgeCondition::Class() { return Type::IfcBoundaryEdgeCondition; } -IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryEdgeCondition)) throw; entity = e; } +IfcBoundaryEdgeCondition::IfcBoundaryEdgeCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryEdgeCondition)) throw; entity = e; } // IfcBoundaryFaceCondition bool IfcBoundaryFaceCondition::hasLinearStiffnessByAreaX() { return !entity->getArgument(1)->isNull(); } IfcModulusOfSubgradeReactionMeasure IfcBoundaryFaceCondition::LinearStiffnessByAreaX() { return *entity->getArgument(1); } @@ -4559,7 +4558,7 @@ IfcModulusOfSubgradeReactionMeasure IfcBoundaryFaceCondition::LinearStiffnessByA bool IfcBoundaryFaceCondition::is(Type::Enum v) { return v == Type::IfcBoundaryFaceCondition || IfcBoundaryCondition::is(v); } Type::Enum IfcBoundaryFaceCondition::type() { return Type::IfcBoundaryFaceCondition; } Type::Enum IfcBoundaryFaceCondition::Class() { return Type::IfcBoundaryFaceCondition; } -IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryFaceCondition)) throw; entity = e; } +IfcBoundaryFaceCondition::IfcBoundaryFaceCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryFaceCondition)) throw; entity = e; } // IfcBoundaryNodeCondition bool IfcBoundaryNodeCondition::hasLinearStiffnessX() { return !entity->getArgument(1)->isNull(); } IfcLinearStiffnessMeasure IfcBoundaryNodeCondition::LinearStiffnessX() { return *entity->getArgument(1); } @@ -4576,24 +4575,24 @@ IfcRotationalStiffnessMeasure IfcBoundaryNodeCondition::RotationalStiffnessZ() { bool IfcBoundaryNodeCondition::is(Type::Enum v) { return v == Type::IfcBoundaryNodeCondition || IfcBoundaryCondition::is(v); } Type::Enum IfcBoundaryNodeCondition::type() { return Type::IfcBoundaryNodeCondition; } Type::Enum IfcBoundaryNodeCondition::Class() { return Type::IfcBoundaryNodeCondition; } -IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryNodeCondition)) throw; entity = e; } +IfcBoundaryNodeCondition::IfcBoundaryNodeCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryNodeCondition)) throw; entity = e; } // IfcBoundaryNodeConditionWarping bool IfcBoundaryNodeConditionWarping::hasWarpingStiffness() { return !entity->getArgument(7)->isNull(); } IfcWarpingMomentMeasure IfcBoundaryNodeConditionWarping::WarpingStiffness() { return *entity->getArgument(7); } bool IfcBoundaryNodeConditionWarping::is(Type::Enum v) { return v == Type::IfcBoundaryNodeConditionWarping || IfcBoundaryNodeCondition::is(v); } Type::Enum IfcBoundaryNodeConditionWarping::type() { return Type::IfcBoundaryNodeConditionWarping; } Type::Enum IfcBoundaryNodeConditionWarping::Class() { return Type::IfcBoundaryNodeConditionWarping; } -IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryNodeConditionWarping)) throw; entity = e; } +IfcBoundaryNodeConditionWarping::IfcBoundaryNodeConditionWarping(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundaryNodeConditionWarping)) throw; entity = e; } // IfcBoundedCurve bool IfcBoundedCurve::is(Type::Enum v) { return v == Type::IfcBoundedCurve || IfcCurve::is(v); } Type::Enum IfcBoundedCurve::type() { return Type::IfcBoundedCurve; } Type::Enum IfcBoundedCurve::Class() { return Type::IfcBoundedCurve; } -IfcBoundedCurve::IfcBoundedCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundedCurve)) throw; entity = e; } +IfcBoundedCurve::IfcBoundedCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundedCurve)) throw; entity = e; } // IfcBoundedSurface bool IfcBoundedSurface::is(Type::Enum v) { return v == Type::IfcBoundedSurface || IfcSurface::is(v); } Type::Enum IfcBoundedSurface::type() { return Type::IfcBoundedSurface; } Type::Enum IfcBoundedSurface::Class() { return Type::IfcBoundedSurface; } -IfcBoundedSurface::IfcBoundedSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundedSurface)) throw; entity = e; } +IfcBoundedSurface::IfcBoundedSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundedSurface)) throw; entity = e; } // IfcBoundingBox SHARED_PTR IfcBoundingBox::Corner() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcPositiveLengthMeasure IfcBoundingBox::XDim() { return *entity->getArgument(1); } @@ -4602,13 +4601,13 @@ IfcPositiveLengthMeasure IfcBoundingBox::ZDim() { return *entity->getArgument(3) bool IfcBoundingBox::is(Type::Enum v) { return v == Type::IfcBoundingBox || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcBoundingBox::type() { return Type::IfcBoundingBox; } Type::Enum IfcBoundingBox::Class() { return Type::IfcBoundingBox; } -IfcBoundingBox::IfcBoundingBox(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundingBox)) throw; entity = e; } +IfcBoundingBox::IfcBoundingBox(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoundingBox)) throw; entity = e; } // IfcBoxedHalfSpace SHARED_PTR IfcBoxedHalfSpace::Enclosure() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcBoxedHalfSpace::is(Type::Enum v) { return v == Type::IfcBoxedHalfSpace || IfcHalfSpaceSolid::is(v); } Type::Enum IfcBoxedHalfSpace::type() { return Type::IfcBoxedHalfSpace; } Type::Enum IfcBoxedHalfSpace::Class() { return Type::IfcBoxedHalfSpace; } -IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoxedHalfSpace)) throw; entity = e; } +IfcBoxedHalfSpace::IfcBoxedHalfSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcBoxedHalfSpace)) throw; entity = e; } // IfcBuilding bool IfcBuilding::hasElevationOfRefHeight() { return !entity->getArgument(9)->isNull(); } IfcLengthMeasure IfcBuilding::ElevationOfRefHeight() { return *entity->getArgument(9); } @@ -4619,47 +4618,47 @@ SHARED_PTR IfcBuilding::BuildingAddress() { return reinterpret bool IfcBuilding::is(Type::Enum v) { return v == Type::IfcBuilding || IfcSpatialStructureElement::is(v); } Type::Enum IfcBuilding::type() { return Type::IfcBuilding; } Type::Enum IfcBuilding::Class() { return Type::IfcBuilding; } -IfcBuilding::IfcBuilding(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuilding)) throw; entity = e; } +IfcBuilding::IfcBuilding(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuilding)) throw; entity = e; } // IfcBuildingElement bool IfcBuildingElement::is(Type::Enum v) { return v == Type::IfcBuildingElement || IfcElement::is(v); } Type::Enum IfcBuildingElement::type() { return Type::IfcBuildingElement; } Type::Enum IfcBuildingElement::Class() { return Type::IfcBuildingElement; } -IfcBuildingElement::IfcBuildingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElement)) throw; entity = e; } +IfcBuildingElement::IfcBuildingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElement)) throw; entity = e; } // IfcBuildingElementComponent bool IfcBuildingElementComponent::is(Type::Enum v) { return v == Type::IfcBuildingElementComponent || IfcBuildingElement::is(v); } Type::Enum IfcBuildingElementComponent::type() { return Type::IfcBuildingElementComponent; } Type::Enum IfcBuildingElementComponent::Class() { return Type::IfcBuildingElementComponent; } -IfcBuildingElementComponent::IfcBuildingElementComponent(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementComponent)) throw; entity = e; } +IfcBuildingElementComponent::IfcBuildingElementComponent(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementComponent)) throw; entity = e; } // IfcBuildingElementPart bool IfcBuildingElementPart::is(Type::Enum v) { return v == Type::IfcBuildingElementPart || IfcBuildingElementComponent::is(v); } Type::Enum IfcBuildingElementPart::type() { return Type::IfcBuildingElementPart; } Type::Enum IfcBuildingElementPart::Class() { return Type::IfcBuildingElementPart; } -IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementPart)) throw; entity = e; } +IfcBuildingElementPart::IfcBuildingElementPart(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementPart)) throw; entity = e; } // IfcBuildingElementProxy bool IfcBuildingElementProxy::hasCompositionType() { return !entity->getArgument(8)->isNull(); } IfcElementCompositionEnum::IfcElementCompositionEnum IfcBuildingElementProxy::CompositionType() { return IfcElementCompositionEnum::FromString(*entity->getArgument(8)); } bool IfcBuildingElementProxy::is(Type::Enum v) { return v == Type::IfcBuildingElementProxy || IfcBuildingElement::is(v); } Type::Enum IfcBuildingElementProxy::type() { return Type::IfcBuildingElementProxy; } Type::Enum IfcBuildingElementProxy::Class() { return Type::IfcBuildingElementProxy; } -IfcBuildingElementProxy::IfcBuildingElementProxy(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementProxy)) throw; entity = e; } +IfcBuildingElementProxy::IfcBuildingElementProxy(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementProxy)) throw; entity = e; } // IfcBuildingElementProxyType IfcBuildingElementProxyTypeEnum::IfcBuildingElementProxyTypeEnum IfcBuildingElementProxyType::PredefinedType() { return IfcBuildingElementProxyTypeEnum::FromString(*entity->getArgument(9)); } bool IfcBuildingElementProxyType::is(Type::Enum v) { return v == Type::IfcBuildingElementProxyType || IfcBuildingElementType::is(v); } Type::Enum IfcBuildingElementProxyType::type() { return Type::IfcBuildingElementProxyType; } Type::Enum IfcBuildingElementProxyType::Class() { return Type::IfcBuildingElementProxyType; } -IfcBuildingElementProxyType::IfcBuildingElementProxyType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementProxyType)) throw; entity = e; } +IfcBuildingElementProxyType::IfcBuildingElementProxyType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementProxyType)) throw; entity = e; } // IfcBuildingElementType bool IfcBuildingElementType::is(Type::Enum v) { return v == Type::IfcBuildingElementType || IfcElementType::is(v); } Type::Enum IfcBuildingElementType::type() { return Type::IfcBuildingElementType; } Type::Enum IfcBuildingElementType::Class() { return Type::IfcBuildingElementType; } -IfcBuildingElementType::IfcBuildingElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementType)) throw; entity = e; } +IfcBuildingElementType::IfcBuildingElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingElementType)) throw; entity = e; } // IfcBuildingStorey bool IfcBuildingStorey::hasElevation() { return !entity->getArgument(9)->isNull(); } IfcLengthMeasure IfcBuildingStorey::Elevation() { return *entity->getArgument(9); } bool IfcBuildingStorey::is(Type::Enum v) { return v == Type::IfcBuildingStorey || IfcSpatialStructureElement::is(v); } Type::Enum IfcBuildingStorey::type() { return Type::IfcBuildingStorey; } Type::Enum IfcBuildingStorey::Class() { return Type::IfcBuildingStorey; } -IfcBuildingStorey::IfcBuildingStorey(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingStorey)) throw; entity = e; } +IfcBuildingStorey::IfcBuildingStorey(IfcAbstractEntityPtr e) { if (!is(Type::IfcBuildingStorey)) throw; entity = e; } // IfcCShapeProfileDef IfcPositiveLengthMeasure IfcCShapeProfileDef::Depth() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcCShapeProfileDef::Width() { return *entity->getArgument(4); } @@ -4672,25 +4671,25 @@ IfcPositiveLengthMeasure IfcCShapeProfileDef::CentreOfGravityInX() { return *ent bool IfcCShapeProfileDef::is(Type::Enum v) { return v == Type::IfcCShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcCShapeProfileDef::type() { return Type::IfcCShapeProfileDef; } Type::Enum IfcCShapeProfileDef::Class() { return Type::IfcCShapeProfileDef; } -IfcCShapeProfileDef::IfcCShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCShapeProfileDef)) throw; entity = e; } +IfcCShapeProfileDef::IfcCShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCShapeProfileDef)) throw; entity = e; } // IfcCableCarrierFittingType IfcCableCarrierFittingTypeEnum::IfcCableCarrierFittingTypeEnum IfcCableCarrierFittingType::PredefinedType() { return IfcCableCarrierFittingTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCableCarrierFittingType::is(Type::Enum v) { return v == Type::IfcCableCarrierFittingType || IfcFlowFittingType::is(v); } Type::Enum IfcCableCarrierFittingType::type() { return Type::IfcCableCarrierFittingType; } Type::Enum IfcCableCarrierFittingType::Class() { return Type::IfcCableCarrierFittingType; } -IfcCableCarrierFittingType::IfcCableCarrierFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableCarrierFittingType)) throw; entity = e; } +IfcCableCarrierFittingType::IfcCableCarrierFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableCarrierFittingType)) throw; entity = e; } // IfcCableCarrierSegmentType IfcCableCarrierSegmentTypeEnum::IfcCableCarrierSegmentTypeEnum IfcCableCarrierSegmentType::PredefinedType() { return IfcCableCarrierSegmentTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCableCarrierSegmentType::is(Type::Enum v) { return v == Type::IfcCableCarrierSegmentType || IfcFlowSegmentType::is(v); } Type::Enum IfcCableCarrierSegmentType::type() { return Type::IfcCableCarrierSegmentType; } Type::Enum IfcCableCarrierSegmentType::Class() { return Type::IfcCableCarrierSegmentType; } -IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableCarrierSegmentType)) throw; entity = e; } +IfcCableCarrierSegmentType::IfcCableCarrierSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableCarrierSegmentType)) throw; entity = e; } // IfcCableSegmentType IfcCableSegmentTypeEnum::IfcCableSegmentTypeEnum IfcCableSegmentType::PredefinedType() { return IfcCableSegmentTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCableSegmentType::is(Type::Enum v) { return v == Type::IfcCableSegmentType || IfcFlowSegmentType::is(v); } Type::Enum IfcCableSegmentType::type() { return Type::IfcCableSegmentType; } Type::Enum IfcCableSegmentType::Class() { return Type::IfcCableSegmentType; } -IfcCableSegmentType::IfcCableSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableSegmentType)) throw; entity = e; } +IfcCableSegmentType::IfcCableSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCableSegmentType)) throw; entity = e; } // IfcCalendarDate IfcDayInMonthNumber IfcCalendarDate::DayComponent() { return *entity->getArgument(0); } IfcMonthInYearNumber IfcCalendarDate::MonthComponent() { return *entity->getArgument(1); } @@ -4698,13 +4697,13 @@ IfcYearNumber IfcCalendarDate::YearComponent() { return *entity->getArgument(2); bool IfcCalendarDate::is(Type::Enum v) { return v == Type::IfcCalendarDate; } Type::Enum IfcCalendarDate::type() { return Type::IfcCalendarDate; } Type::Enum IfcCalendarDate::Class() { return Type::IfcCalendarDate; } -IfcCalendarDate::IfcCalendarDate(IfcAbstractEntityPtr e) { if (!is(Type::IfcCalendarDate)) throw; entity = e; } +IfcCalendarDate::IfcCalendarDate(IfcAbstractEntityPtr e) { if (!is(Type::IfcCalendarDate)) throw; entity = e; } // IfcCartesianPoint -std::vector IfcCartesianPoint::Coordinates() { return *entity->getArgument(0); } +std::vector /*[1:3]*/ IfcCartesianPoint::Coordinates() { return *entity->getArgument(0); } bool IfcCartesianPoint::is(Type::Enum v) { return v == Type::IfcCartesianPoint || IfcPoint::is(v); } Type::Enum IfcCartesianPoint::type() { return Type::IfcCartesianPoint; } Type::Enum IfcCartesianPoint::Class() { return Type::IfcCartesianPoint; } -IfcCartesianPoint::IfcCartesianPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianPoint)) throw; entity = e; } +IfcCartesianPoint::IfcCartesianPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianPoint)) throw; entity = e; } // IfcCartesianTransformationOperator bool IfcCartesianTransformationOperator::hasAxis1() { return !entity->getArgument(0)->isNull(); } SHARED_PTR IfcCartesianTransformationOperator::Axis1() { return reinterpret_pointer_cast(*entity->getArgument(0)); } @@ -4716,26 +4715,26 @@ float IfcCartesianTransformationOperator::Scale() { return *entity->getArgument( bool IfcCartesianTransformationOperator::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcCartesianTransformationOperator::type() { return Type::IfcCartesianTransformationOperator; } Type::Enum IfcCartesianTransformationOperator::Class() { return Type::IfcCartesianTransformationOperator; } -IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator)) throw; entity = e; } +IfcCartesianTransformationOperator::IfcCartesianTransformationOperator(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator)) throw; entity = e; } // IfcCartesianTransformationOperator2D bool IfcCartesianTransformationOperator2D::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator2D || IfcCartesianTransformationOperator::is(v); } Type::Enum IfcCartesianTransformationOperator2D::type() { return Type::IfcCartesianTransformationOperator2D; } Type::Enum IfcCartesianTransformationOperator2D::Class() { return Type::IfcCartesianTransformationOperator2D; } -IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator2D)) throw; entity = e; } +IfcCartesianTransformationOperator2D::IfcCartesianTransformationOperator2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator2D)) throw; entity = e; } // IfcCartesianTransformationOperator2DnonUniform bool IfcCartesianTransformationOperator2DnonUniform::hasScale2() { return !entity->getArgument(4)->isNull(); } float IfcCartesianTransformationOperator2DnonUniform::Scale2() { return *entity->getArgument(4); } bool IfcCartesianTransformationOperator2DnonUniform::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator2DnonUniform || IfcCartesianTransformationOperator2D::is(v); } Type::Enum IfcCartesianTransformationOperator2DnonUniform::type() { return Type::IfcCartesianTransformationOperator2DnonUniform; } Type::Enum IfcCartesianTransformationOperator2DnonUniform::Class() { return Type::IfcCartesianTransformationOperator2DnonUniform; } -IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator2DnonUniform)) throw; entity = e; } +IfcCartesianTransformationOperator2DnonUniform::IfcCartesianTransformationOperator2DnonUniform(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator2DnonUniform)) throw; entity = e; } // IfcCartesianTransformationOperator3D bool IfcCartesianTransformationOperator3D::hasAxis3() { return !entity->getArgument(4)->isNull(); } SHARED_PTR IfcCartesianTransformationOperator3D::Axis3() { return reinterpret_pointer_cast(*entity->getArgument(4)); } bool IfcCartesianTransformationOperator3D::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator3D || IfcCartesianTransformationOperator::is(v); } Type::Enum IfcCartesianTransformationOperator3D::type() { return Type::IfcCartesianTransformationOperator3D; } Type::Enum IfcCartesianTransformationOperator3D::Class() { return Type::IfcCartesianTransformationOperator3D; } -IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator3D)) throw; entity = e; } +IfcCartesianTransformationOperator3D::IfcCartesianTransformationOperator3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator3D)) throw; entity = e; } // IfcCartesianTransformationOperator3DnonUniform bool IfcCartesianTransformationOperator3DnonUniform::hasScale2() { return !entity->getArgument(5)->isNull(); } float IfcCartesianTransformationOperator3DnonUniform::Scale2() { return *entity->getArgument(5); } @@ -4744,13 +4743,13 @@ float IfcCartesianTransformationOperator3DnonUniform::Scale3() { return *entity- bool IfcCartesianTransformationOperator3DnonUniform::is(Type::Enum v) { return v == Type::IfcCartesianTransformationOperator3DnonUniform || IfcCartesianTransformationOperator3D::is(v); } Type::Enum IfcCartesianTransformationOperator3DnonUniform::type() { return Type::IfcCartesianTransformationOperator3DnonUniform; } Type::Enum IfcCartesianTransformationOperator3DnonUniform::Class() { return Type::IfcCartesianTransformationOperator3DnonUniform; } -IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator3DnonUniform)) throw; entity = e; } +IfcCartesianTransformationOperator3DnonUniform::IfcCartesianTransformationOperator3DnonUniform(IfcAbstractEntityPtr e) { if (!is(Type::IfcCartesianTransformationOperator3DnonUniform)) throw; entity = e; } // IfcCenterLineProfileDef IfcPositiveLengthMeasure IfcCenterLineProfileDef::Thickness() { return *entity->getArgument(3); } bool IfcCenterLineProfileDef::is(Type::Enum v) { return v == Type::IfcCenterLineProfileDef || IfcArbitraryOpenProfileDef::is(v); } Type::Enum IfcCenterLineProfileDef::type() { return Type::IfcCenterLineProfileDef; } Type::Enum IfcCenterLineProfileDef::Class() { return Type::IfcCenterLineProfileDef; } -IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCenterLineProfileDef)) throw; entity = e; } +IfcCenterLineProfileDef::IfcCenterLineProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCenterLineProfileDef)) throw; entity = e; } // IfcChamferEdgeFeature bool IfcChamferEdgeFeature::hasWidth() { return !entity->getArgument(9)->isNull(); } IfcPositiveLengthMeasure IfcChamferEdgeFeature::Width() { return *entity->getArgument(9); } @@ -4759,31 +4758,31 @@ IfcPositiveLengthMeasure IfcChamferEdgeFeature::Height() { return *entity->getAr bool IfcChamferEdgeFeature::is(Type::Enum v) { return v == Type::IfcChamferEdgeFeature || IfcEdgeFeature::is(v); } Type::Enum IfcChamferEdgeFeature::type() { return Type::IfcChamferEdgeFeature; } Type::Enum IfcChamferEdgeFeature::Class() { return Type::IfcChamferEdgeFeature; } -IfcChamferEdgeFeature::IfcChamferEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcChamferEdgeFeature)) throw; entity = e; } +IfcChamferEdgeFeature::IfcChamferEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcChamferEdgeFeature)) throw; entity = e; } // IfcChillerType IfcChillerTypeEnum::IfcChillerTypeEnum IfcChillerType::PredefinedType() { return IfcChillerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcChillerType::is(Type::Enum v) { return v == Type::IfcChillerType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcChillerType::type() { return Type::IfcChillerType; } Type::Enum IfcChillerType::Class() { return Type::IfcChillerType; } -IfcChillerType::IfcChillerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcChillerType)) throw; entity = e; } +IfcChillerType::IfcChillerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcChillerType)) throw; entity = e; } // IfcCircle IfcPositiveLengthMeasure IfcCircle::Radius() { return *entity->getArgument(1); } bool IfcCircle::is(Type::Enum v) { return v == Type::IfcCircle || IfcConic::is(v); } Type::Enum IfcCircle::type() { return Type::IfcCircle; } Type::Enum IfcCircle::Class() { return Type::IfcCircle; } -IfcCircle::IfcCircle(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircle)) throw; entity = e; } +IfcCircle::IfcCircle(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircle)) throw; entity = e; } // IfcCircleHollowProfileDef IfcPositiveLengthMeasure IfcCircleHollowProfileDef::WallThickness() { return *entity->getArgument(4); } bool IfcCircleHollowProfileDef::is(Type::Enum v) { return v == Type::IfcCircleHollowProfileDef || IfcCircleProfileDef::is(v); } Type::Enum IfcCircleHollowProfileDef::type() { return Type::IfcCircleHollowProfileDef; } Type::Enum IfcCircleHollowProfileDef::Class() { return Type::IfcCircleHollowProfileDef; } -IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircleHollowProfileDef)) throw; entity = e; } +IfcCircleHollowProfileDef::IfcCircleHollowProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircleHollowProfileDef)) throw; entity = e; } // IfcCircleProfileDef IfcPositiveLengthMeasure IfcCircleProfileDef::Radius() { return *entity->getArgument(3); } bool IfcCircleProfileDef::is(Type::Enum v) { return v == Type::IfcCircleProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcCircleProfileDef::type() { return Type::IfcCircleProfileDef; } Type::Enum IfcCircleProfileDef::Class() { return Type::IfcCircleProfileDef; } -IfcCircleProfileDef::IfcCircleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircleProfileDef)) throw; entity = e; } +IfcCircleProfileDef::IfcCircleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCircleProfileDef)) throw; entity = e; } // IfcClassification IfcLabel IfcClassification::Source() { return *entity->getArgument(0); } IfcLabel IfcClassification::Edition() { return *entity->getArgument(1); } @@ -4794,7 +4793,7 @@ IfcClassificationItem::list IfcClassification::Contains() { RETURN_INVERSE(IfcCl bool IfcClassification::is(Type::Enum v) { return v == Type::IfcClassification; } Type::Enum IfcClassification::type() { return Type::IfcClassification; } Type::Enum IfcClassification::Class() { return Type::IfcClassification; } -IfcClassification::IfcClassification(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassification)) throw; entity = e; } +IfcClassification::IfcClassification(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassification)) throw; entity = e; } // IfcClassificationItem SHARED_PTR IfcClassificationItem::Notation() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcClassificationItem::hasItemOf() { return !entity->getArgument(1)->isNull(); } @@ -4805,44 +4804,44 @@ IfcClassificationItemRelationship::list IfcClassificationItem::IsClassifyingItem bool IfcClassificationItem::is(Type::Enum v) { return v == Type::IfcClassificationItem; } Type::Enum IfcClassificationItem::type() { return Type::IfcClassificationItem; } Type::Enum IfcClassificationItem::Class() { return Type::IfcClassificationItem; } -IfcClassificationItem::IfcClassificationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationItem)) throw; entity = e; } +IfcClassificationItem::IfcClassificationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationItem)) throw; entity = e; } // IfcClassificationItemRelationship SHARED_PTR IfcClassificationItemRelationship::RelatingItem() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcClassificationItemRelationship::RelatedItems() { RETURN_AS_LIST(IfcClassificationItem,1) } bool IfcClassificationItemRelationship::is(Type::Enum v) { return v == Type::IfcClassificationItemRelationship; } Type::Enum IfcClassificationItemRelationship::type() { return Type::IfcClassificationItemRelationship; } Type::Enum IfcClassificationItemRelationship::Class() { return Type::IfcClassificationItemRelationship; } -IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationItemRelationship)) throw; entity = e; } +IfcClassificationItemRelationship::IfcClassificationItemRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationItemRelationship)) throw; entity = e; } // IfcClassificationNotation SHARED_PTR< IfcTemplatedEntityList > IfcClassificationNotation::NotationFacets() { RETURN_AS_LIST(IfcClassificationNotationFacet,0) } bool IfcClassificationNotation::is(Type::Enum v) { return v == Type::IfcClassificationNotation; } Type::Enum IfcClassificationNotation::type() { return Type::IfcClassificationNotation; } Type::Enum IfcClassificationNotation::Class() { return Type::IfcClassificationNotation; } -IfcClassificationNotation::IfcClassificationNotation(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationNotation)) throw; entity = e; } +IfcClassificationNotation::IfcClassificationNotation(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationNotation)) throw; entity = e; } // IfcClassificationNotationFacet IfcLabel IfcClassificationNotationFacet::NotationValue() { return *entity->getArgument(0); } bool IfcClassificationNotationFacet::is(Type::Enum v) { return v == Type::IfcClassificationNotationFacet; } Type::Enum IfcClassificationNotationFacet::type() { return Type::IfcClassificationNotationFacet; } Type::Enum IfcClassificationNotationFacet::Class() { return Type::IfcClassificationNotationFacet; } -IfcClassificationNotationFacet::IfcClassificationNotationFacet(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationNotationFacet)) throw; entity = e; } +IfcClassificationNotationFacet::IfcClassificationNotationFacet(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationNotationFacet)) throw; entity = e; } // IfcClassificationReference bool IfcClassificationReference::hasReferencedSource() { return !entity->getArgument(3)->isNull(); } SHARED_PTR IfcClassificationReference::ReferencedSource() { return reinterpret_pointer_cast(*entity->getArgument(3)); } bool IfcClassificationReference::is(Type::Enum v) { return v == Type::IfcClassificationReference || IfcExternalReference::is(v); } Type::Enum IfcClassificationReference::type() { return Type::IfcClassificationReference; } Type::Enum IfcClassificationReference::Class() { return Type::IfcClassificationReference; } -IfcClassificationReference::IfcClassificationReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationReference)) throw; entity = e; } +IfcClassificationReference::IfcClassificationReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcClassificationReference)) throw; entity = e; } // IfcClosedShell bool IfcClosedShell::is(Type::Enum v) { return v == Type::IfcClosedShell || IfcConnectedFaceSet::is(v); } Type::Enum IfcClosedShell::type() { return Type::IfcClosedShell; } Type::Enum IfcClosedShell::Class() { return Type::IfcClosedShell; } -IfcClosedShell::IfcClosedShell(IfcAbstractEntityPtr e) { if (!is(Type::IfcClosedShell)) throw; entity = e; } +IfcClosedShell::IfcClosedShell(IfcAbstractEntityPtr e) { if (!is(Type::IfcClosedShell)) throw; entity = e; } // IfcCoilType IfcCoilTypeEnum::IfcCoilTypeEnum IfcCoilType::PredefinedType() { return IfcCoilTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCoilType::is(Type::Enum v) { return v == Type::IfcCoilType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcCoilType::type() { return Type::IfcCoilType; } Type::Enum IfcCoilType::Class() { return Type::IfcCoilType; } -IfcCoilType::IfcCoilType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoilType)) throw; entity = e; } +IfcCoilType::IfcCoilType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoilType)) throw; entity = e; } // IfcColourRgb IfcNormalisedRatioMeasure IfcColourRgb::Red() { return *entity->getArgument(1); } IfcNormalisedRatioMeasure IfcColourRgb::Green() { return *entity->getArgument(2); } @@ -4850,39 +4849,39 @@ IfcNormalisedRatioMeasure IfcColourRgb::Blue() { return *entity->getArgument(3); bool IfcColourRgb::is(Type::Enum v) { return v == Type::IfcColourRgb || IfcColourSpecification::is(v); } Type::Enum IfcColourRgb::type() { return Type::IfcColourRgb; } Type::Enum IfcColourRgb::Class() { return Type::IfcColourRgb; } -IfcColourRgb::IfcColourRgb(IfcAbstractEntityPtr e) { if (!is(Type::IfcColourRgb)) throw; entity = e; } +IfcColourRgb::IfcColourRgb(IfcAbstractEntityPtr e) { if (!is(Type::IfcColourRgb)) throw; entity = e; } // IfcColourSpecification bool IfcColourSpecification::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcColourSpecification::Name() { return *entity->getArgument(0); } bool IfcColourSpecification::is(Type::Enum v) { return v == Type::IfcColourSpecification; } Type::Enum IfcColourSpecification::type() { return Type::IfcColourSpecification; } Type::Enum IfcColourSpecification::Class() { return Type::IfcColourSpecification; } -IfcColourSpecification::IfcColourSpecification(IfcAbstractEntityPtr e) { if (!is(Type::IfcColourSpecification)) throw; entity = e; } +IfcColourSpecification::IfcColourSpecification(IfcAbstractEntityPtr e) { if (!is(Type::IfcColourSpecification)) throw; entity = e; } // IfcColumn bool IfcColumn::is(Type::Enum v) { return v == Type::IfcColumn || IfcBuildingElement::is(v); } Type::Enum IfcColumn::type() { return Type::IfcColumn; } Type::Enum IfcColumn::Class() { return Type::IfcColumn; } -IfcColumn::IfcColumn(IfcAbstractEntityPtr e) { if (!is(Type::IfcColumn)) throw; entity = e; } +IfcColumn::IfcColumn(IfcAbstractEntityPtr e) { if (!is(Type::IfcColumn)) throw; entity = e; } // IfcColumnType IfcColumnTypeEnum::IfcColumnTypeEnum IfcColumnType::PredefinedType() { return IfcColumnTypeEnum::FromString(*entity->getArgument(9)); } bool IfcColumnType::is(Type::Enum v) { return v == Type::IfcColumnType || IfcBuildingElementType::is(v); } Type::Enum IfcColumnType::type() { return Type::IfcColumnType; } Type::Enum IfcColumnType::Class() { return Type::IfcColumnType; } -IfcColumnType::IfcColumnType(IfcAbstractEntityPtr e) { if (!is(Type::IfcColumnType)) throw; entity = e; } +IfcColumnType::IfcColumnType(IfcAbstractEntityPtr e) { if (!is(Type::IfcColumnType)) throw; entity = e; } // IfcComplexProperty IfcIdentifier IfcComplexProperty::UsageName() { return *entity->getArgument(2); } SHARED_PTR< IfcTemplatedEntityList > IfcComplexProperty::HasProperties() { RETURN_AS_LIST(IfcProperty,3) } bool IfcComplexProperty::is(Type::Enum v) { return v == Type::IfcComplexProperty || IfcProperty::is(v); } Type::Enum IfcComplexProperty::type() { return Type::IfcComplexProperty; } Type::Enum IfcComplexProperty::Class() { return Type::IfcComplexProperty; } -IfcComplexProperty::IfcComplexProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcComplexProperty)) throw; entity = e; } +IfcComplexProperty::IfcComplexProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcComplexProperty)) throw; entity = e; } // IfcCompositeCurve SHARED_PTR< IfcTemplatedEntityList > IfcCompositeCurve::Segments() { RETURN_AS_LIST(IfcCompositeCurveSegment,0) } bool IfcCompositeCurve::SelfIntersect() { return *entity->getArgument(1); } bool IfcCompositeCurve::is(Type::Enum v) { return v == Type::IfcCompositeCurve || IfcBoundedCurve::is(v); } Type::Enum IfcCompositeCurve::type() { return Type::IfcCompositeCurve; } Type::Enum IfcCompositeCurve::Class() { return Type::IfcCompositeCurve; } -IfcCompositeCurve::IfcCompositeCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeCurve)) throw; entity = e; } +IfcCompositeCurve::IfcCompositeCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeCurve)) throw; entity = e; } // IfcCompositeCurveSegment IfcTransitionCode::IfcTransitionCode IfcCompositeCurveSegment::Transition() { return IfcTransitionCode::FromString(*entity->getArgument(0)); } bool IfcCompositeCurveSegment::SameSense() { return *entity->getArgument(1); } @@ -4891,7 +4890,7 @@ IfcCompositeCurve::list IfcCompositeCurveSegment::UsingCurves() { RETURN_INVERSE bool IfcCompositeCurveSegment::is(Type::Enum v) { return v == Type::IfcCompositeCurveSegment || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcCompositeCurveSegment::type() { return Type::IfcCompositeCurveSegment; } Type::Enum IfcCompositeCurveSegment::Class() { return Type::IfcCompositeCurveSegment; } -IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeCurveSegment)) throw; entity = e; } +IfcCompositeCurveSegment::IfcCompositeCurveSegment(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeCurveSegment)) throw; entity = e; } // IfcCompositeProfileDef SHARED_PTR< IfcTemplatedEntityList > IfcCompositeProfileDef::Profiles() { RETURN_AS_LIST(IfcProfileDef,2) } bool IfcCompositeProfileDef::hasLabel() { return !entity->getArgument(3)->isNull(); } @@ -4899,43 +4898,43 @@ IfcLabel IfcCompositeProfileDef::Label() { return *entity->getArgument(3); } bool IfcCompositeProfileDef::is(Type::Enum v) { return v == Type::IfcCompositeProfileDef || IfcProfileDef::is(v); } Type::Enum IfcCompositeProfileDef::type() { return Type::IfcCompositeProfileDef; } Type::Enum IfcCompositeProfileDef::Class() { return Type::IfcCompositeProfileDef; } -IfcCompositeProfileDef::IfcCompositeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeProfileDef)) throw; entity = e; } +IfcCompositeProfileDef::IfcCompositeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompositeProfileDef)) throw; entity = e; } // IfcCompressorType IfcCompressorTypeEnum::IfcCompressorTypeEnum IfcCompressorType::PredefinedType() { return IfcCompressorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCompressorType::is(Type::Enum v) { return v == Type::IfcCompressorType || IfcFlowMovingDeviceType::is(v); } Type::Enum IfcCompressorType::type() { return Type::IfcCompressorType; } Type::Enum IfcCompressorType::Class() { return Type::IfcCompressorType; } -IfcCompressorType::IfcCompressorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompressorType)) throw; entity = e; } +IfcCompressorType::IfcCompressorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCompressorType)) throw; entity = e; } // IfcCondenserType IfcCondenserTypeEnum::IfcCondenserTypeEnum IfcCondenserType::PredefinedType() { return IfcCondenserTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCondenserType::is(Type::Enum v) { return v == Type::IfcCondenserType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcCondenserType::type() { return Type::IfcCondenserType; } Type::Enum IfcCondenserType::Class() { return Type::IfcCondenserType; } -IfcCondenserType::IfcCondenserType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCondenserType)) throw; entity = e; } +IfcCondenserType::IfcCondenserType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCondenserType)) throw; entity = e; } // IfcCondition bool IfcCondition::is(Type::Enum v) { return v == Type::IfcCondition || IfcGroup::is(v); } Type::Enum IfcCondition::type() { return Type::IfcCondition; } Type::Enum IfcCondition::Class() { return Type::IfcCondition; } -IfcCondition::IfcCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcCondition)) throw; entity = e; } +IfcCondition::IfcCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcCondition)) throw; entity = e; } // IfcConditionCriterion IfcConditionCriterionSelect IfcConditionCriterion::Criterion() { return *entity->getArgument(5); } IfcDateTimeSelect IfcConditionCriterion::CriterionDateTime() { return *entity->getArgument(6); } bool IfcConditionCriterion::is(Type::Enum v) { return v == Type::IfcConditionCriterion || IfcControl::is(v); } Type::Enum IfcConditionCriterion::type() { return Type::IfcConditionCriterion; } Type::Enum IfcConditionCriterion::Class() { return Type::IfcConditionCriterion; } -IfcConditionCriterion::IfcConditionCriterion(IfcAbstractEntityPtr e) { if (!is(Type::IfcConditionCriterion)) throw; entity = e; } +IfcConditionCriterion::IfcConditionCriterion(IfcAbstractEntityPtr e) { if (!is(Type::IfcConditionCriterion)) throw; entity = e; } // IfcConic IfcAxis2Placement IfcConic::Position() { return *entity->getArgument(0); } bool IfcConic::is(Type::Enum v) { return v == Type::IfcConic || IfcCurve::is(v); } Type::Enum IfcConic::type() { return Type::IfcConic; } Type::Enum IfcConic::Class() { return Type::IfcConic; } -IfcConic::IfcConic(IfcAbstractEntityPtr e) { if (!is(Type::IfcConic)) throw; entity = e; } +IfcConic::IfcConic(IfcAbstractEntityPtr e) { if (!is(Type::IfcConic)) throw; entity = e; } // IfcConnectedFaceSet SHARED_PTR< IfcTemplatedEntityList > IfcConnectedFaceSet::CfsFaces() { RETURN_AS_LIST(IfcFace,0) } bool IfcConnectedFaceSet::is(Type::Enum v) { return v == Type::IfcConnectedFaceSet || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcConnectedFaceSet::type() { return Type::IfcConnectedFaceSet; } Type::Enum IfcConnectedFaceSet::Class() { return Type::IfcConnectedFaceSet; } -IfcConnectedFaceSet::IfcConnectedFaceSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectedFaceSet)) throw; entity = e; } +IfcConnectedFaceSet::IfcConnectedFaceSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectedFaceSet)) throw; entity = e; } // IfcConnectionCurveGeometry IfcCurveOrEdgeCurve IfcConnectionCurveGeometry::CurveOnRelatingElement() { return *entity->getArgument(0); } bool IfcConnectionCurveGeometry::hasCurveOnRelatedElement() { return !entity->getArgument(1)->isNull(); } @@ -4943,12 +4942,12 @@ IfcCurveOrEdgeCurve IfcConnectionCurveGeometry::CurveOnRelatedElement() { return bool IfcConnectionCurveGeometry::is(Type::Enum v) { return v == Type::IfcConnectionCurveGeometry || IfcConnectionGeometry::is(v); } Type::Enum IfcConnectionCurveGeometry::type() { return Type::IfcConnectionCurveGeometry; } Type::Enum IfcConnectionCurveGeometry::Class() { return Type::IfcConnectionCurveGeometry; } -IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionCurveGeometry)) throw; entity = e; } +IfcConnectionCurveGeometry::IfcConnectionCurveGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionCurveGeometry)) throw; entity = e; } // IfcConnectionGeometry bool IfcConnectionGeometry::is(Type::Enum v) { return v == Type::IfcConnectionGeometry; } Type::Enum IfcConnectionGeometry::type() { return Type::IfcConnectionGeometry; } Type::Enum IfcConnectionGeometry::Class() { return Type::IfcConnectionGeometry; } -IfcConnectionGeometry::IfcConnectionGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionGeometry)) throw; entity = e; } +IfcConnectionGeometry::IfcConnectionGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionGeometry)) throw; entity = e; } // IfcConnectionPointEccentricity bool IfcConnectionPointEccentricity::hasEccentricityInX() { return !entity->getArgument(2)->isNull(); } IfcLengthMeasure IfcConnectionPointEccentricity::EccentricityInX() { return *entity->getArgument(2); } @@ -4959,7 +4958,7 @@ IfcLengthMeasure IfcConnectionPointEccentricity::EccentricityInZ() { return *ent bool IfcConnectionPointEccentricity::is(Type::Enum v) { return v == Type::IfcConnectionPointEccentricity || IfcConnectionPointGeometry::is(v); } Type::Enum IfcConnectionPointEccentricity::type() { return Type::IfcConnectionPointEccentricity; } Type::Enum IfcConnectionPointEccentricity::Class() { return Type::IfcConnectionPointEccentricity; } -IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPointEccentricity)) throw; entity = e; } +IfcConnectionPointEccentricity::IfcConnectionPointEccentricity(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPointEccentricity)) throw; entity = e; } // IfcConnectionPointGeometry IfcPointOrVertexPoint IfcConnectionPointGeometry::PointOnRelatingElement() { return *entity->getArgument(0); } bool IfcConnectionPointGeometry::hasPointOnRelatedElement() { return !entity->getArgument(1)->isNull(); } @@ -4967,7 +4966,7 @@ IfcPointOrVertexPoint IfcConnectionPointGeometry::PointOnRelatedElement() { retu bool IfcConnectionPointGeometry::is(Type::Enum v) { return v == Type::IfcConnectionPointGeometry || IfcConnectionGeometry::is(v); } Type::Enum IfcConnectionPointGeometry::type() { return Type::IfcConnectionPointGeometry; } Type::Enum IfcConnectionPointGeometry::Class() { return Type::IfcConnectionPointGeometry; } -IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPointGeometry)) throw; entity = e; } +IfcConnectionPointGeometry::IfcConnectionPointGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPointGeometry)) throw; entity = e; } // IfcConnectionPortGeometry IfcAxis2Placement IfcConnectionPortGeometry::LocationAtRelatingElement() { return *entity->getArgument(0); } bool IfcConnectionPortGeometry::hasLocationAtRelatedElement() { return !entity->getArgument(1)->isNull(); } @@ -4976,7 +4975,7 @@ SHARED_PTR IfcConnectionPortGeometry::ProfileOfPort() { return re bool IfcConnectionPortGeometry::is(Type::Enum v) { return v == Type::IfcConnectionPortGeometry || IfcConnectionGeometry::is(v); } Type::Enum IfcConnectionPortGeometry::type() { return Type::IfcConnectionPortGeometry; } Type::Enum IfcConnectionPortGeometry::Class() { return Type::IfcConnectionPortGeometry; } -IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPortGeometry)) throw; entity = e; } +IfcConnectionPortGeometry::IfcConnectionPortGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionPortGeometry)) throw; entity = e; } // IfcConnectionSurfaceGeometry IfcSurfaceOrFaceSurface IfcConnectionSurfaceGeometry::SurfaceOnRelatingElement() { return *entity->getArgument(0); } bool IfcConnectionSurfaceGeometry::hasSurfaceOnRelatedElement() { return !entity->getArgument(1)->isNull(); } @@ -4984,7 +4983,7 @@ IfcSurfaceOrFaceSurface IfcConnectionSurfaceGeometry::SurfaceOnRelatedElement() bool IfcConnectionSurfaceGeometry::is(Type::Enum v) { return v == Type::IfcConnectionSurfaceGeometry || IfcConnectionGeometry::is(v); } Type::Enum IfcConnectionSurfaceGeometry::type() { return Type::IfcConnectionSurfaceGeometry; } Type::Enum IfcConnectionSurfaceGeometry::Class() { return Type::IfcConnectionSurfaceGeometry; } -IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionSurfaceGeometry)) throw; entity = e; } +IfcConnectionSurfaceGeometry::IfcConnectionSurfaceGeometry(IfcAbstractEntityPtr e) { if (!is(Type::IfcConnectionSurfaceGeometry)) throw; entity = e; } // IfcConstraint IfcLabel IfcConstraint::Name() { return *entity->getArgument(0); } bool IfcConstraint::hasDescription() { return !entity->getArgument(1)->isNull(); } @@ -5007,7 +5006,7 @@ IfcConstraintAggregationRelationship::list IfcConstraint::IsAggregatedIn() { RET bool IfcConstraint::is(Type::Enum v) { return v == Type::IfcConstraint; } Type::Enum IfcConstraint::type() { return Type::IfcConstraint; } Type::Enum IfcConstraint::Class() { return Type::IfcConstraint; } -IfcConstraint::IfcConstraint(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraint)) throw; entity = e; } +IfcConstraint::IfcConstraint(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraint)) throw; entity = e; } // IfcConstraintAggregationRelationship bool IfcConstraintAggregationRelationship::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcConstraintAggregationRelationship::Name() { return *entity->getArgument(0); } @@ -5019,14 +5018,14 @@ IfcLogicalOperatorEnum::IfcLogicalOperatorEnum IfcConstraintAggregationRelations bool IfcConstraintAggregationRelationship::is(Type::Enum v) { return v == Type::IfcConstraintAggregationRelationship; } Type::Enum IfcConstraintAggregationRelationship::type() { return Type::IfcConstraintAggregationRelationship; } Type::Enum IfcConstraintAggregationRelationship::Class() { return Type::IfcConstraintAggregationRelationship; } -IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintAggregationRelationship)) throw; entity = e; } +IfcConstraintAggregationRelationship::IfcConstraintAggregationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintAggregationRelationship)) throw; entity = e; } // IfcConstraintClassificationRelationship SHARED_PTR IfcConstraintClassificationRelationship::ClassifiedConstraint() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcConstraintClassificationRelationship::RelatedClassifications() { RETURN_AS_LIST(IfcAbstractSelect,1) } bool IfcConstraintClassificationRelationship::is(Type::Enum v) { return v == Type::IfcConstraintClassificationRelationship; } Type::Enum IfcConstraintClassificationRelationship::type() { return Type::IfcConstraintClassificationRelationship; } Type::Enum IfcConstraintClassificationRelationship::Class() { return Type::IfcConstraintClassificationRelationship; } -IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintClassificationRelationship)) throw; entity = e; } +IfcConstraintClassificationRelationship::IfcConstraintClassificationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintClassificationRelationship)) throw; entity = e; } // IfcConstraintRelationship bool IfcConstraintRelationship::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcConstraintRelationship::Name() { return *entity->getArgument(0); } @@ -5037,12 +5036,12 @@ SHARED_PTR< IfcTemplatedEntityList > IfcConstraintRelationship::R bool IfcConstraintRelationship::is(Type::Enum v) { return v == Type::IfcConstraintRelationship; } Type::Enum IfcConstraintRelationship::type() { return Type::IfcConstraintRelationship; } Type::Enum IfcConstraintRelationship::Class() { return Type::IfcConstraintRelationship; } -IfcConstraintRelationship::IfcConstraintRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintRelationship)) throw; entity = e; } +IfcConstraintRelationship::IfcConstraintRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstraintRelationship)) throw; entity = e; } // IfcConstructionEquipmentResource bool IfcConstructionEquipmentResource::is(Type::Enum v) { return v == Type::IfcConstructionEquipmentResource || IfcConstructionResource::is(v); } Type::Enum IfcConstructionEquipmentResource::type() { return Type::IfcConstructionEquipmentResource; } Type::Enum IfcConstructionEquipmentResource::Class() { return Type::IfcConstructionEquipmentResource; } -IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionEquipmentResource)) throw; entity = e; } +IfcConstructionEquipmentResource::IfcConstructionEquipmentResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionEquipmentResource)) throw; entity = e; } // IfcConstructionMaterialResource bool IfcConstructionMaterialResource::hasSuppliers() { return !entity->getArgument(9)->isNull(); } SHARED_PTR< IfcTemplatedEntityList > IfcConstructionMaterialResource::Suppliers() { RETURN_AS_LIST(IfcAbstractSelect,9) } @@ -5051,12 +5050,12 @@ IfcRatioMeasure IfcConstructionMaterialResource::UsageRatio() { return *entity-> bool IfcConstructionMaterialResource::is(Type::Enum v) { return v == Type::IfcConstructionMaterialResource || IfcConstructionResource::is(v); } Type::Enum IfcConstructionMaterialResource::type() { return Type::IfcConstructionMaterialResource; } Type::Enum IfcConstructionMaterialResource::Class() { return Type::IfcConstructionMaterialResource; } -IfcConstructionMaterialResource::IfcConstructionMaterialResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionMaterialResource)) throw; entity = e; } +IfcConstructionMaterialResource::IfcConstructionMaterialResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionMaterialResource)) throw; entity = e; } // IfcConstructionProductResource bool IfcConstructionProductResource::is(Type::Enum v) { return v == Type::IfcConstructionProductResource || IfcConstructionResource::is(v); } Type::Enum IfcConstructionProductResource::type() { return Type::IfcConstructionProductResource; } Type::Enum IfcConstructionProductResource::Class() { return Type::IfcConstructionProductResource; } -IfcConstructionProductResource::IfcConstructionProductResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionProductResource)) throw; entity = e; } +IfcConstructionProductResource::IfcConstructionProductResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionProductResource)) throw; entity = e; } // IfcConstructionResource bool IfcConstructionResource::hasResourceIdentifier() { return !entity->getArgument(5)->isNull(); } IfcIdentifier IfcConstructionResource::ResourceIdentifier() { return *entity->getArgument(5); } @@ -5069,44 +5068,44 @@ SHARED_PTR IfcConstructionResource::BaseQuantity() { return bool IfcConstructionResource::is(Type::Enum v) { return v == Type::IfcConstructionResource || IfcResource::is(v); } Type::Enum IfcConstructionResource::type() { return Type::IfcConstructionResource; } Type::Enum IfcConstructionResource::Class() { return Type::IfcConstructionResource; } -IfcConstructionResource::IfcConstructionResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionResource)) throw; entity = e; } +IfcConstructionResource::IfcConstructionResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcConstructionResource)) throw; entity = e; } // IfcContextDependentUnit IfcLabel IfcContextDependentUnit::Name() { return *entity->getArgument(2); } bool IfcContextDependentUnit::is(Type::Enum v) { return v == Type::IfcContextDependentUnit || IfcNamedUnit::is(v); } Type::Enum IfcContextDependentUnit::type() { return Type::IfcContextDependentUnit; } Type::Enum IfcContextDependentUnit::Class() { return Type::IfcContextDependentUnit; } -IfcContextDependentUnit::IfcContextDependentUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcContextDependentUnit)) throw; entity = e; } +IfcContextDependentUnit::IfcContextDependentUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcContextDependentUnit)) throw; entity = e; } // IfcControl IfcRelAssignsToControl::list IfcControl::Controls() { RETURN_INVERSE(IfcRelAssignsToControl) } bool IfcControl::is(Type::Enum v) { return v == Type::IfcControl || IfcObject::is(v); } Type::Enum IfcControl::type() { return Type::IfcControl; } Type::Enum IfcControl::Class() { return Type::IfcControl; } -IfcControl::IfcControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcControl)) throw; entity = e; } +IfcControl::IfcControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcControl)) throw; entity = e; } // IfcControllerType IfcControllerTypeEnum::IfcControllerTypeEnum IfcControllerType::PredefinedType() { return IfcControllerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcControllerType::is(Type::Enum v) { return v == Type::IfcControllerType || IfcDistributionControlElementType::is(v); } Type::Enum IfcControllerType::type() { return Type::IfcControllerType; } Type::Enum IfcControllerType::Class() { return Type::IfcControllerType; } -IfcControllerType::IfcControllerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcControllerType)) throw; entity = e; } +IfcControllerType::IfcControllerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcControllerType)) throw; entity = e; } // IfcConversionBasedUnit IfcLabel IfcConversionBasedUnit::Name() { return *entity->getArgument(2); } SHARED_PTR IfcConversionBasedUnit::ConversionFactor() { return reinterpret_pointer_cast(*entity->getArgument(3)); } bool IfcConversionBasedUnit::is(Type::Enum v) { return v == Type::IfcConversionBasedUnit || IfcNamedUnit::is(v); } Type::Enum IfcConversionBasedUnit::type() { return Type::IfcConversionBasedUnit; } Type::Enum IfcConversionBasedUnit::Class() { return Type::IfcConversionBasedUnit; } -IfcConversionBasedUnit::IfcConversionBasedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcConversionBasedUnit)) throw; entity = e; } +IfcConversionBasedUnit::IfcConversionBasedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcConversionBasedUnit)) throw; entity = e; } // IfcCooledBeamType IfcCooledBeamTypeEnum::IfcCooledBeamTypeEnum IfcCooledBeamType::PredefinedType() { return IfcCooledBeamTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCooledBeamType::is(Type::Enum v) { return v == Type::IfcCooledBeamType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcCooledBeamType::type() { return Type::IfcCooledBeamType; } Type::Enum IfcCooledBeamType::Class() { return Type::IfcCooledBeamType; } -IfcCooledBeamType::IfcCooledBeamType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCooledBeamType)) throw; entity = e; } +IfcCooledBeamType::IfcCooledBeamType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCooledBeamType)) throw; entity = e; } // IfcCoolingTowerType IfcCoolingTowerTypeEnum::IfcCoolingTowerTypeEnum IfcCoolingTowerType::PredefinedType() { return IfcCoolingTowerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCoolingTowerType::is(Type::Enum v) { return v == Type::IfcCoolingTowerType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcCoolingTowerType::type() { return Type::IfcCoolingTowerType; } Type::Enum IfcCoolingTowerType::Class() { return Type::IfcCoolingTowerType; } -IfcCoolingTowerType::IfcCoolingTowerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoolingTowerType)) throw; entity = e; } +IfcCoolingTowerType::IfcCoolingTowerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoolingTowerType)) throw; entity = e; } // IfcCoordinatedUniversalTimeOffset IfcHourInDay IfcCoordinatedUniversalTimeOffset::HourOffset() { return *entity->getArgument(0); } bool IfcCoordinatedUniversalTimeOffset::hasMinuteOffset() { return !entity->getArgument(1)->isNull(); } @@ -5115,12 +5114,12 @@ IfcAheadOrBehind::IfcAheadOrBehind IfcCoordinatedUniversalTimeOffset::Sense() { bool IfcCoordinatedUniversalTimeOffset::is(Type::Enum v) { return v == Type::IfcCoordinatedUniversalTimeOffset; } Type::Enum IfcCoordinatedUniversalTimeOffset::type() { return Type::IfcCoordinatedUniversalTimeOffset; } Type::Enum IfcCoordinatedUniversalTimeOffset::Class() { return Type::IfcCoordinatedUniversalTimeOffset; } -IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoordinatedUniversalTimeOffset)) throw; entity = e; } +IfcCoordinatedUniversalTimeOffset::IfcCoordinatedUniversalTimeOffset(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoordinatedUniversalTimeOffset)) throw; entity = e; } // IfcCostItem bool IfcCostItem::is(Type::Enum v) { return v == Type::IfcCostItem || IfcControl::is(v); } Type::Enum IfcCostItem::type() { return Type::IfcCostItem; } Type::Enum IfcCostItem::Class() { return Type::IfcCostItem; } -IfcCostItem::IfcCostItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostItem)) throw; entity = e; } +IfcCostItem::IfcCostItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostItem)) throw; entity = e; } // IfcCostSchedule bool IfcCostSchedule::hasSubmittedBy() { return !entity->getArgument(5)->isNull(); } IfcActorSelect IfcCostSchedule::SubmittedBy() { return *entity->getArgument(5); } @@ -5139,7 +5138,7 @@ IfcCostScheduleTypeEnum::IfcCostScheduleTypeEnum IfcCostSchedule::PredefinedType bool IfcCostSchedule::is(Type::Enum v) { return v == Type::IfcCostSchedule || IfcControl::is(v); } Type::Enum IfcCostSchedule::type() { return Type::IfcCostSchedule; } Type::Enum IfcCostSchedule::Class() { return Type::IfcCostSchedule; } -IfcCostSchedule::IfcCostSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostSchedule)) throw; entity = e; } +IfcCostSchedule::IfcCostSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostSchedule)) throw; entity = e; } // IfcCostValue IfcLabel IfcCostValue::CostType() { return *entity->getArgument(6); } bool IfcCostValue::hasCondition() { return !entity->getArgument(7)->isNull(); } @@ -5147,7 +5146,7 @@ IfcText IfcCostValue::Condition() { return *entity->getArgument(7); } bool IfcCostValue::is(Type::Enum v) { return v == Type::IfcCostValue || IfcAppliedValue::is(v); } Type::Enum IfcCostValue::type() { return Type::IfcCostValue; } Type::Enum IfcCostValue::Class() { return Type::IfcCostValue; } -IfcCostValue::IfcCostValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostValue)) throw; entity = e; } +IfcCostValue::IfcCostValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcCostValue)) throw; entity = e; } // IfcCovering bool IfcCovering::hasPredefinedType() { return !entity->getArgument(8)->isNull(); } IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCovering::PredefinedType() { return IfcCoveringTypeEnum::FromString(*entity->getArgument(8)); } @@ -5156,13 +5155,13 @@ IfcRelCoversBldgElements::list IfcCovering::Covers() { RETURN_INVERSE(IfcRelCove bool IfcCovering::is(Type::Enum v) { return v == Type::IfcCovering || IfcBuildingElement::is(v); } Type::Enum IfcCovering::type() { return Type::IfcCovering; } Type::Enum IfcCovering::Class() { return Type::IfcCovering; } -IfcCovering::IfcCovering(IfcAbstractEntityPtr e) { if (!is(Type::IfcCovering)) throw; entity = e; } +IfcCovering::IfcCovering(IfcAbstractEntityPtr e) { if (!is(Type::IfcCovering)) throw; entity = e; } // IfcCoveringType IfcCoveringTypeEnum::IfcCoveringTypeEnum IfcCoveringType::PredefinedType() { return IfcCoveringTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCoveringType::is(Type::Enum v) { return v == Type::IfcCoveringType || IfcBuildingElementType::is(v); } Type::Enum IfcCoveringType::type() { return Type::IfcCoveringType; } Type::Enum IfcCoveringType::Class() { return Type::IfcCoveringType; } -IfcCoveringType::IfcCoveringType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoveringType)) throw; entity = e; } +IfcCoveringType::IfcCoveringType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCoveringType)) throw; entity = e; } // IfcCraneRailAShapeProfileDef IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::OverallHeight() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::BaseWidth2() { return *entity->getArgument(4); } @@ -5181,7 +5180,7 @@ IfcPositiveLengthMeasure IfcCraneRailAShapeProfileDef::CentreOfGravityInY() { re bool IfcCraneRailAShapeProfileDef::is(Type::Enum v) { return v == Type::IfcCraneRailAShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcCraneRailAShapeProfileDef::type() { return Type::IfcCraneRailAShapeProfileDef; } Type::Enum IfcCraneRailAShapeProfileDef::Class() { return Type::IfcCraneRailAShapeProfileDef; } -IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCraneRailAShapeProfileDef)) throw; entity = e; } +IfcCraneRailAShapeProfileDef::IfcCraneRailAShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCraneRailAShapeProfileDef)) throw; entity = e; } // IfcCraneRailFShapeProfileDef IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::OverallHeight() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::HeadWidth() { return *entity->getArgument(4); } @@ -5197,24 +5196,24 @@ IfcPositiveLengthMeasure IfcCraneRailFShapeProfileDef::CentreOfGravityInY() { re bool IfcCraneRailFShapeProfileDef::is(Type::Enum v) { return v == Type::IfcCraneRailFShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcCraneRailFShapeProfileDef::type() { return Type::IfcCraneRailFShapeProfileDef; } Type::Enum IfcCraneRailFShapeProfileDef::Class() { return Type::IfcCraneRailFShapeProfileDef; } -IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCraneRailFShapeProfileDef)) throw; entity = e; } +IfcCraneRailFShapeProfileDef::IfcCraneRailFShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcCraneRailFShapeProfileDef)) throw; entity = e; } // IfcCrewResource bool IfcCrewResource::is(Type::Enum v) { return v == Type::IfcCrewResource || IfcConstructionResource::is(v); } Type::Enum IfcCrewResource::type() { return Type::IfcCrewResource; } Type::Enum IfcCrewResource::Class() { return Type::IfcCrewResource; } -IfcCrewResource::IfcCrewResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcCrewResource)) throw; entity = e; } +IfcCrewResource::IfcCrewResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcCrewResource)) throw; entity = e; } // IfcCsgPrimitive3D SHARED_PTR IfcCsgPrimitive3D::Position() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcCsgPrimitive3D::is(Type::Enum v) { return v == Type::IfcCsgPrimitive3D || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcCsgPrimitive3D::type() { return Type::IfcCsgPrimitive3D; } Type::Enum IfcCsgPrimitive3D::Class() { return Type::IfcCsgPrimitive3D; } -IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCsgPrimitive3D)) throw; entity = e; } +IfcCsgPrimitive3D::IfcCsgPrimitive3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcCsgPrimitive3D)) throw; entity = e; } // IfcCsgSolid IfcCsgSelect IfcCsgSolid::TreeRootExpression() { return *entity->getArgument(0); } bool IfcCsgSolid::is(Type::Enum v) { return v == Type::IfcCsgSolid || IfcSolidModel::is(v); } Type::Enum IfcCsgSolid::type() { return Type::IfcCsgSolid; } Type::Enum IfcCsgSolid::Class() { return Type::IfcCsgSolid; } -IfcCsgSolid::IfcCsgSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcCsgSolid)) throw; entity = e; } +IfcCsgSolid::IfcCsgSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcCsgSolid)) throw; entity = e; } // IfcCurrencyRelationship SHARED_PTR IfcCurrencyRelationship::RelatingMonetaryUnit() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcCurrencyRelationship::RelatedMonetaryUnit() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -5225,23 +5224,23 @@ SHARED_PTR IfcCurrencyRelationship::RateSource() { return bool IfcCurrencyRelationship::is(Type::Enum v) { return v == Type::IfcCurrencyRelationship; } Type::Enum IfcCurrencyRelationship::type() { return Type::IfcCurrencyRelationship; } Type::Enum IfcCurrencyRelationship::Class() { return Type::IfcCurrencyRelationship; } -IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurrencyRelationship)) throw; entity = e; } +IfcCurrencyRelationship::IfcCurrencyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurrencyRelationship)) throw; entity = e; } // IfcCurtainWall bool IfcCurtainWall::is(Type::Enum v) { return v == Type::IfcCurtainWall || IfcBuildingElement::is(v); } Type::Enum IfcCurtainWall::type() { return Type::IfcCurtainWall; } Type::Enum IfcCurtainWall::Class() { return Type::IfcCurtainWall; } -IfcCurtainWall::IfcCurtainWall(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurtainWall)) throw; entity = e; } +IfcCurtainWall::IfcCurtainWall(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurtainWall)) throw; entity = e; } // IfcCurtainWallType IfcCurtainWallTypeEnum::IfcCurtainWallTypeEnum IfcCurtainWallType::PredefinedType() { return IfcCurtainWallTypeEnum::FromString(*entity->getArgument(9)); } bool IfcCurtainWallType::is(Type::Enum v) { return v == Type::IfcCurtainWallType || IfcBuildingElementType::is(v); } Type::Enum IfcCurtainWallType::type() { return Type::IfcCurtainWallType; } Type::Enum IfcCurtainWallType::Class() { return Type::IfcCurtainWallType; } -IfcCurtainWallType::IfcCurtainWallType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurtainWallType)) throw; entity = e; } +IfcCurtainWallType::IfcCurtainWallType(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurtainWallType)) throw; entity = e; } // IfcCurve bool IfcCurve::is(Type::Enum v) { return v == Type::IfcCurve || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcCurve::type() { return Type::IfcCurve; } Type::Enum IfcCurve::Class() { return Type::IfcCurve; } -IfcCurve::IfcCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurve)) throw; entity = e; } +IfcCurve::IfcCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurve)) throw; entity = e; } // IfcCurveBoundedPlane SHARED_PTR IfcCurveBoundedPlane::BasisSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcCurveBoundedPlane::OuterBoundary() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -5249,7 +5248,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcCurveBoundedPlane::InnerBounda bool IfcCurveBoundedPlane::is(Type::Enum v) { return v == Type::IfcCurveBoundedPlane || IfcBoundedSurface::is(v); } Type::Enum IfcCurveBoundedPlane::type() { return Type::IfcCurveBoundedPlane; } Type::Enum IfcCurveBoundedPlane::Class() { return Type::IfcCurveBoundedPlane; } -IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveBoundedPlane)) throw; entity = e; } +IfcCurveBoundedPlane::IfcCurveBoundedPlane(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveBoundedPlane)) throw; entity = e; } // IfcCurveStyle bool IfcCurveStyle::hasCurveFont() { return !entity->getArgument(1)->isNull(); } IfcCurveFontOrScaledCurveFontSelect IfcCurveStyle::CurveFont() { return *entity->getArgument(1); } @@ -5260,7 +5259,7 @@ IfcColour IfcCurveStyle::CurveColour() { return *entity->getArgument(3); } bool IfcCurveStyle::is(Type::Enum v) { return v == Type::IfcCurveStyle || IfcPresentationStyle::is(v); } Type::Enum IfcCurveStyle::type() { return Type::IfcCurveStyle; } Type::Enum IfcCurveStyle::Class() { return Type::IfcCurveStyle; } -IfcCurveStyle::IfcCurveStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyle)) throw; entity = e; } +IfcCurveStyle::IfcCurveStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyle)) throw; entity = e; } // IfcCurveStyleFont bool IfcCurveStyleFont::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcCurveStyleFont::Name() { return *entity->getArgument(0); } @@ -5268,7 +5267,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcCurveStyleFont bool IfcCurveStyleFont::is(Type::Enum v) { return v == Type::IfcCurveStyleFont; } Type::Enum IfcCurveStyleFont::type() { return Type::IfcCurveStyleFont; } Type::Enum IfcCurveStyleFont::Class() { return Type::IfcCurveStyleFont; } -IfcCurveStyleFont::IfcCurveStyleFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFont)) throw; entity = e; } +IfcCurveStyleFont::IfcCurveStyleFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFont)) throw; entity = e; } // IfcCurveStyleFontAndScaling bool IfcCurveStyleFontAndScaling::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcCurveStyleFontAndScaling::Name() { return *entity->getArgument(0); } @@ -5277,34 +5276,34 @@ IfcPositiveRatioMeasure IfcCurveStyleFontAndScaling::CurveFontScaling() { return bool IfcCurveStyleFontAndScaling::is(Type::Enum v) { return v == Type::IfcCurveStyleFontAndScaling; } Type::Enum IfcCurveStyleFontAndScaling::type() { return Type::IfcCurveStyleFontAndScaling; } Type::Enum IfcCurveStyleFontAndScaling::Class() { return Type::IfcCurveStyleFontAndScaling; } -IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFontAndScaling)) throw; entity = e; } +IfcCurveStyleFontAndScaling::IfcCurveStyleFontAndScaling(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFontAndScaling)) throw; entity = e; } // IfcCurveStyleFontPattern IfcLengthMeasure IfcCurveStyleFontPattern::VisibleSegmentLength() { return *entity->getArgument(0); } IfcPositiveLengthMeasure IfcCurveStyleFontPattern::InvisibleSegmentLength() { return *entity->getArgument(1); } bool IfcCurveStyleFontPattern::is(Type::Enum v) { return v == Type::IfcCurveStyleFontPattern; } Type::Enum IfcCurveStyleFontPattern::type() { return Type::IfcCurveStyleFontPattern; } Type::Enum IfcCurveStyleFontPattern::Class() { return Type::IfcCurveStyleFontPattern; } -IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFontPattern)) throw; entity = e; } +IfcCurveStyleFontPattern::IfcCurveStyleFontPattern(IfcAbstractEntityPtr e) { if (!is(Type::IfcCurveStyleFontPattern)) throw; entity = e; } // IfcDamperType IfcDamperTypeEnum::IfcDamperTypeEnum IfcDamperType::PredefinedType() { return IfcDamperTypeEnum::FromString(*entity->getArgument(9)); } bool IfcDamperType::is(Type::Enum v) { return v == Type::IfcDamperType || IfcFlowControllerType::is(v); } Type::Enum IfcDamperType::type() { return Type::IfcDamperType; } Type::Enum IfcDamperType::Class() { return Type::IfcDamperType; } -IfcDamperType::IfcDamperType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDamperType)) throw; entity = e; } +IfcDamperType::IfcDamperType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDamperType)) throw; entity = e; } // IfcDateAndTime SHARED_PTR IfcDateAndTime::DateComponent() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcDateAndTime::TimeComponent() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcDateAndTime::is(Type::Enum v) { return v == Type::IfcDateAndTime; } Type::Enum IfcDateAndTime::type() { return Type::IfcDateAndTime; } Type::Enum IfcDateAndTime::Class() { return Type::IfcDateAndTime; } -IfcDateAndTime::IfcDateAndTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcDateAndTime)) throw; entity = e; } +IfcDateAndTime::IfcDateAndTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcDateAndTime)) throw; entity = e; } // IfcDefinedSymbol IfcDefinedSymbolSelect IfcDefinedSymbol::Definition() { return *entity->getArgument(0); } SHARED_PTR IfcDefinedSymbol::Target() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcDefinedSymbol::is(Type::Enum v) { return v == Type::IfcDefinedSymbol || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcDefinedSymbol::type() { return Type::IfcDefinedSymbol; } Type::Enum IfcDefinedSymbol::Class() { return Type::IfcDefinedSymbol; } -IfcDefinedSymbol::IfcDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcDefinedSymbol)) throw; entity = e; } +IfcDefinedSymbol::IfcDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcDefinedSymbol)) throw; entity = e; } // IfcDerivedProfileDef SHARED_PTR IfcDerivedProfileDef::ParentProfile() { return reinterpret_pointer_cast(*entity->getArgument(2)); } SHARED_PTR IfcDerivedProfileDef::Operator() { return reinterpret_pointer_cast(*entity->getArgument(3)); } @@ -5313,7 +5312,7 @@ IfcLabel IfcDerivedProfileDef::Label() { return *entity->getArgument(4); } bool IfcDerivedProfileDef::is(Type::Enum v) { return v == Type::IfcDerivedProfileDef || IfcProfileDef::is(v); } Type::Enum IfcDerivedProfileDef::type() { return Type::IfcDerivedProfileDef; } Type::Enum IfcDerivedProfileDef::Class() { return Type::IfcDerivedProfileDef; } -IfcDerivedProfileDef::IfcDerivedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedProfileDef)) throw; entity = e; } +IfcDerivedProfileDef::IfcDerivedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedProfileDef)) throw; entity = e; } // IfcDerivedUnit SHARED_PTR< IfcTemplatedEntityList > IfcDerivedUnit::Elements() { RETURN_AS_LIST(IfcDerivedUnitElement,0) } IfcDerivedUnitEnum::IfcDerivedUnitEnum IfcDerivedUnit::UnitType() { return IfcDerivedUnitEnum::FromString(*entity->getArgument(1)); } @@ -5322,46 +5321,46 @@ IfcLabel IfcDerivedUnit::UserDefinedType() { return *entity->getArgument(2); } bool IfcDerivedUnit::is(Type::Enum v) { return v == Type::IfcDerivedUnit; } Type::Enum IfcDerivedUnit::type() { return Type::IfcDerivedUnit; } Type::Enum IfcDerivedUnit::Class() { return Type::IfcDerivedUnit; } -IfcDerivedUnit::IfcDerivedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedUnit)) throw; entity = e; } +IfcDerivedUnit::IfcDerivedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedUnit)) throw; entity = e; } // IfcDerivedUnitElement SHARED_PTR IfcDerivedUnitElement::Unit() { return reinterpret_pointer_cast(*entity->getArgument(0)); } int IfcDerivedUnitElement::Exponent() { return *entity->getArgument(1); } bool IfcDerivedUnitElement::is(Type::Enum v) { return v == Type::IfcDerivedUnitElement; } Type::Enum IfcDerivedUnitElement::type() { return Type::IfcDerivedUnitElement; } Type::Enum IfcDerivedUnitElement::Class() { return Type::IfcDerivedUnitElement; } -IfcDerivedUnitElement::IfcDerivedUnitElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedUnitElement)) throw; entity = e; } +IfcDerivedUnitElement::IfcDerivedUnitElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDerivedUnitElement)) throw; entity = e; } // IfcDiameterDimension bool IfcDiameterDimension::is(Type::Enum v) { return v == Type::IfcDiameterDimension || IfcDimensionCurveDirectedCallout::is(v); } Type::Enum IfcDiameterDimension::type() { return Type::IfcDiameterDimension; } Type::Enum IfcDiameterDimension::Class() { return Type::IfcDiameterDimension; } -IfcDiameterDimension::IfcDiameterDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiameterDimension)) throw; entity = e; } +IfcDiameterDimension::IfcDiameterDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiameterDimension)) throw; entity = e; } // IfcDimensionCalloutRelationship bool IfcDimensionCalloutRelationship::is(Type::Enum v) { return v == Type::IfcDimensionCalloutRelationship || IfcDraughtingCalloutRelationship::is(v); } Type::Enum IfcDimensionCalloutRelationship::type() { return Type::IfcDimensionCalloutRelationship; } Type::Enum IfcDimensionCalloutRelationship::Class() { return Type::IfcDimensionCalloutRelationship; } -IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCalloutRelationship)) throw; entity = e; } +IfcDimensionCalloutRelationship::IfcDimensionCalloutRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCalloutRelationship)) throw; entity = e; } // IfcDimensionCurve IfcTerminatorSymbol::list IfcDimensionCurve::AnnotatedBySymbols() { RETURN_INVERSE(IfcTerminatorSymbol) } bool IfcDimensionCurve::is(Type::Enum v) { return v == Type::IfcDimensionCurve || IfcAnnotationCurveOccurrence::is(v); } Type::Enum IfcDimensionCurve::type() { return Type::IfcDimensionCurve; } Type::Enum IfcDimensionCurve::Class() { return Type::IfcDimensionCurve; } -IfcDimensionCurve::IfcDimensionCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurve)) throw; entity = e; } +IfcDimensionCurve::IfcDimensionCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurve)) throw; entity = e; } // IfcDimensionCurveDirectedCallout bool IfcDimensionCurveDirectedCallout::is(Type::Enum v) { return v == Type::IfcDimensionCurveDirectedCallout || IfcDraughtingCallout::is(v); } Type::Enum IfcDimensionCurveDirectedCallout::type() { return Type::IfcDimensionCurveDirectedCallout; } Type::Enum IfcDimensionCurveDirectedCallout::Class() { return Type::IfcDimensionCurveDirectedCallout; } -IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurveDirectedCallout)) throw; entity = e; } +IfcDimensionCurveDirectedCallout::IfcDimensionCurveDirectedCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurveDirectedCallout)) throw; entity = e; } // IfcDimensionCurveTerminator IfcDimensionExtentUsage::IfcDimensionExtentUsage IfcDimensionCurveTerminator::Role() { return IfcDimensionExtentUsage::FromString(*entity->getArgument(4)); } bool IfcDimensionCurveTerminator::is(Type::Enum v) { return v == Type::IfcDimensionCurveTerminator || IfcTerminatorSymbol::is(v); } Type::Enum IfcDimensionCurveTerminator::type() { return Type::IfcDimensionCurveTerminator; } Type::Enum IfcDimensionCurveTerminator::Class() { return Type::IfcDimensionCurveTerminator; } -IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurveTerminator)) throw; entity = e; } +IfcDimensionCurveTerminator::IfcDimensionCurveTerminator(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionCurveTerminator)) throw; entity = e; } // IfcDimensionPair bool IfcDimensionPair::is(Type::Enum v) { return v == Type::IfcDimensionPair || IfcDraughtingCalloutRelationship::is(v); } Type::Enum IfcDimensionPair::type() { return Type::IfcDimensionPair; } Type::Enum IfcDimensionPair::Class() { return Type::IfcDimensionPair; } -IfcDimensionPair::IfcDimensionPair(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionPair)) throw; entity = e; } +IfcDimensionPair::IfcDimensionPair(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionPair)) throw; entity = e; } // IfcDimensionalExponents int IfcDimensionalExponents::LengthExponent() { return *entity->getArgument(0); } int IfcDimensionalExponents::MassExponent() { return *entity->getArgument(1); } @@ -5373,34 +5372,34 @@ int IfcDimensionalExponents::LuminousIntensityExponent() { return *entity->getAr bool IfcDimensionalExponents::is(Type::Enum v) { return v == Type::IfcDimensionalExponents; } Type::Enum IfcDimensionalExponents::type() { return Type::IfcDimensionalExponents; } Type::Enum IfcDimensionalExponents::Class() { return Type::IfcDimensionalExponents; } -IfcDimensionalExponents::IfcDimensionalExponents(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionalExponents)) throw; entity = e; } +IfcDimensionalExponents::IfcDimensionalExponents(IfcAbstractEntityPtr e) { if (!is(Type::IfcDimensionalExponents)) throw; entity = e; } // IfcDirection -std::vector IfcDirection::DirectionRatios() { return *entity->getArgument(0); } +std::vector /*[2:3]*/ IfcDirection::DirectionRatios() { return *entity->getArgument(0); } bool IfcDirection::is(Type::Enum v) { return v == Type::IfcDirection || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcDirection::type() { return Type::IfcDirection; } Type::Enum IfcDirection::Class() { return Type::IfcDirection; } -IfcDirection::IfcDirection(IfcAbstractEntityPtr e) { if (!is(Type::IfcDirection)) throw; entity = e; } +IfcDirection::IfcDirection(IfcAbstractEntityPtr e) { if (!is(Type::IfcDirection)) throw; entity = e; } // IfcDiscreteAccessory bool IfcDiscreteAccessory::is(Type::Enum v) { return v == Type::IfcDiscreteAccessory || IfcElementComponent::is(v); } Type::Enum IfcDiscreteAccessory::type() { return Type::IfcDiscreteAccessory; } Type::Enum IfcDiscreteAccessory::Class() { return Type::IfcDiscreteAccessory; } -IfcDiscreteAccessory::IfcDiscreteAccessory(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiscreteAccessory)) throw; entity = e; } +IfcDiscreteAccessory::IfcDiscreteAccessory(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiscreteAccessory)) throw; entity = e; } // IfcDiscreteAccessoryType bool IfcDiscreteAccessoryType::is(Type::Enum v) { return v == Type::IfcDiscreteAccessoryType || IfcElementComponentType::is(v); } Type::Enum IfcDiscreteAccessoryType::type() { return Type::IfcDiscreteAccessoryType; } Type::Enum IfcDiscreteAccessoryType::Class() { return Type::IfcDiscreteAccessoryType; } -IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiscreteAccessoryType)) throw; entity = e; } +IfcDiscreteAccessoryType::IfcDiscreteAccessoryType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDiscreteAccessoryType)) throw; entity = e; } // IfcDistributionChamberElement bool IfcDistributionChamberElement::is(Type::Enum v) { return v == Type::IfcDistributionChamberElement || IfcDistributionFlowElement::is(v); } Type::Enum IfcDistributionChamberElement::type() { return Type::IfcDistributionChamberElement; } Type::Enum IfcDistributionChamberElement::Class() { return Type::IfcDistributionChamberElement; } -IfcDistributionChamberElement::IfcDistributionChamberElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionChamberElement)) throw; entity = e; } +IfcDistributionChamberElement::IfcDistributionChamberElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionChamberElement)) throw; entity = e; } // IfcDistributionChamberElementType IfcDistributionChamberElementTypeEnum::IfcDistributionChamberElementTypeEnum IfcDistributionChamberElementType::PredefinedType() { return IfcDistributionChamberElementTypeEnum::FromString(*entity->getArgument(9)); } bool IfcDistributionChamberElementType::is(Type::Enum v) { return v == Type::IfcDistributionChamberElementType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcDistributionChamberElementType::type() { return Type::IfcDistributionChamberElementType; } Type::Enum IfcDistributionChamberElementType::Class() { return Type::IfcDistributionChamberElementType; } -IfcDistributionChamberElementType::IfcDistributionChamberElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionChamberElementType)) throw; entity = e; } +IfcDistributionChamberElementType::IfcDistributionChamberElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionChamberElementType)) throw; entity = e; } // IfcDistributionControlElement bool IfcDistributionControlElement::hasControlElementId() { return !entity->getArgument(8)->isNull(); } IfcIdentifier IfcDistributionControlElement::ControlElementId() { return *entity->getArgument(8); } @@ -5408,40 +5407,40 @@ IfcRelFlowControlElements::list IfcDistributionControlElement::AssignedToFlowEle bool IfcDistributionControlElement::is(Type::Enum v) { return v == Type::IfcDistributionControlElement || IfcDistributionElement::is(v); } Type::Enum IfcDistributionControlElement::type() { return Type::IfcDistributionControlElement; } Type::Enum IfcDistributionControlElement::Class() { return Type::IfcDistributionControlElement; } -IfcDistributionControlElement::IfcDistributionControlElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionControlElement)) throw; entity = e; } +IfcDistributionControlElement::IfcDistributionControlElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionControlElement)) throw; entity = e; } // IfcDistributionControlElementType bool IfcDistributionControlElementType::is(Type::Enum v) { return v == Type::IfcDistributionControlElementType || IfcDistributionElementType::is(v); } Type::Enum IfcDistributionControlElementType::type() { return Type::IfcDistributionControlElementType; } Type::Enum IfcDistributionControlElementType::Class() { return Type::IfcDistributionControlElementType; } -IfcDistributionControlElementType::IfcDistributionControlElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionControlElementType)) throw; entity = e; } +IfcDistributionControlElementType::IfcDistributionControlElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionControlElementType)) throw; entity = e; } // IfcDistributionElement bool IfcDistributionElement::is(Type::Enum v) { return v == Type::IfcDistributionElement || IfcElement::is(v); } Type::Enum IfcDistributionElement::type() { return Type::IfcDistributionElement; } Type::Enum IfcDistributionElement::Class() { return Type::IfcDistributionElement; } -IfcDistributionElement::IfcDistributionElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionElement)) throw; entity = e; } +IfcDistributionElement::IfcDistributionElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionElement)) throw; entity = e; } // IfcDistributionElementType bool IfcDistributionElementType::is(Type::Enum v) { return v == Type::IfcDistributionElementType || IfcElementType::is(v); } Type::Enum IfcDistributionElementType::type() { return Type::IfcDistributionElementType; } Type::Enum IfcDistributionElementType::Class() { return Type::IfcDistributionElementType; } -IfcDistributionElementType::IfcDistributionElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionElementType)) throw; entity = e; } +IfcDistributionElementType::IfcDistributionElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionElementType)) throw; entity = e; } // IfcDistributionFlowElement IfcRelFlowControlElements::list IfcDistributionFlowElement::HasControlElements() { RETURN_INVERSE(IfcRelFlowControlElements) } bool IfcDistributionFlowElement::is(Type::Enum v) { return v == Type::IfcDistributionFlowElement || IfcDistributionElement::is(v); } Type::Enum IfcDistributionFlowElement::type() { return Type::IfcDistributionFlowElement; } Type::Enum IfcDistributionFlowElement::Class() { return Type::IfcDistributionFlowElement; } -IfcDistributionFlowElement::IfcDistributionFlowElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionFlowElement)) throw; entity = e; } +IfcDistributionFlowElement::IfcDistributionFlowElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionFlowElement)) throw; entity = e; } // IfcDistributionFlowElementType bool IfcDistributionFlowElementType::is(Type::Enum v) { return v == Type::IfcDistributionFlowElementType || IfcDistributionElementType::is(v); } Type::Enum IfcDistributionFlowElementType::type() { return Type::IfcDistributionFlowElementType; } Type::Enum IfcDistributionFlowElementType::Class() { return Type::IfcDistributionFlowElementType; } -IfcDistributionFlowElementType::IfcDistributionFlowElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionFlowElementType)) throw; entity = e; } +IfcDistributionFlowElementType::IfcDistributionFlowElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionFlowElementType)) throw; entity = e; } // IfcDistributionPort bool IfcDistributionPort::hasFlowDirection() { return !entity->getArgument(7)->isNull(); } IfcFlowDirectionEnum::IfcFlowDirectionEnum IfcDistributionPort::FlowDirection() { return IfcFlowDirectionEnum::FromString(*entity->getArgument(7)); } bool IfcDistributionPort::is(Type::Enum v) { return v == Type::IfcDistributionPort || IfcPort::is(v); } Type::Enum IfcDistributionPort::type() { return Type::IfcDistributionPort; } Type::Enum IfcDistributionPort::Class() { return Type::IfcDistributionPort; } -IfcDistributionPort::IfcDistributionPort(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionPort)) throw; entity = e; } +IfcDistributionPort::IfcDistributionPort(IfcAbstractEntityPtr e) { if (!is(Type::IfcDistributionPort)) throw; entity = e; } // IfcDocumentElectronicFormat bool IfcDocumentElectronicFormat::hasFileExtension() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcDocumentElectronicFormat::FileExtension() { return *entity->getArgument(0); } @@ -5452,7 +5451,7 @@ IfcLabel IfcDocumentElectronicFormat::MimeSubtype() { return *entity->getArgumen bool IfcDocumentElectronicFormat::is(Type::Enum v) { return v == Type::IfcDocumentElectronicFormat; } Type::Enum IfcDocumentElectronicFormat::type() { return Type::IfcDocumentElectronicFormat; } Type::Enum IfcDocumentElectronicFormat::Class() { return Type::IfcDocumentElectronicFormat; } -IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentElectronicFormat)) throw; entity = e; } +IfcDocumentElectronicFormat::IfcDocumentElectronicFormat(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentElectronicFormat)) throw; entity = e; } // IfcDocumentInformation IfcIdentifier IfcDocumentInformation::DocumentId() { return *entity->getArgument(0); } IfcLabel IfcDocumentInformation::Name() { return *entity->getArgument(1); } @@ -5491,7 +5490,7 @@ IfcDocumentInformationRelationship::list IfcDocumentInformation::IsPointer() { R bool IfcDocumentInformation::is(Type::Enum v) { return v == Type::IfcDocumentInformation; } Type::Enum IfcDocumentInformation::type() { return Type::IfcDocumentInformation; } Type::Enum IfcDocumentInformation::Class() { return Type::IfcDocumentInformation; } -IfcDocumentInformation::IfcDocumentInformation(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentInformation)) throw; entity = e; } +IfcDocumentInformation::IfcDocumentInformation(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentInformation)) throw; entity = e; } // IfcDocumentInformationRelationship SHARED_PTR IfcDocumentInformationRelationship::RelatingDocument() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcDocumentInformationRelationship::RelatedDocuments() { RETURN_AS_LIST(IfcDocumentInformation,1) } @@ -5500,13 +5499,13 @@ IfcLabel IfcDocumentInformationRelationship::RelationshipType() { return *entity bool IfcDocumentInformationRelationship::is(Type::Enum v) { return v == Type::IfcDocumentInformationRelationship; } Type::Enum IfcDocumentInformationRelationship::type() { return Type::IfcDocumentInformationRelationship; } Type::Enum IfcDocumentInformationRelationship::Class() { return Type::IfcDocumentInformationRelationship; } -IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentInformationRelationship)) throw; entity = e; } +IfcDocumentInformationRelationship::IfcDocumentInformationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentInformationRelationship)) throw; entity = e; } // IfcDocumentReference IfcDocumentInformation::list IfcDocumentReference::ReferenceToDocument() { RETURN_INVERSE(IfcDocumentInformation) } bool IfcDocumentReference::is(Type::Enum v) { return v == Type::IfcDocumentReference || IfcExternalReference::is(v); } Type::Enum IfcDocumentReference::type() { return Type::IfcDocumentReference; } Type::Enum IfcDocumentReference::Class() { return Type::IfcDocumentReference; } -IfcDocumentReference::IfcDocumentReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentReference)) throw; entity = e; } +IfcDocumentReference::IfcDocumentReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcDocumentReference)) throw; entity = e; } // IfcDoor bool IfcDoor::hasOverallHeight() { return !entity->getArgument(8)->isNull(); } IfcPositiveLengthMeasure IfcDoor::OverallHeight() { return *entity->getArgument(8); } @@ -5515,7 +5514,7 @@ IfcPositiveLengthMeasure IfcDoor::OverallWidth() { return *entity->getArgument(9 bool IfcDoor::is(Type::Enum v) { return v == Type::IfcDoor || IfcBuildingElement::is(v); } Type::Enum IfcDoor::type() { return Type::IfcDoor; } Type::Enum IfcDoor::Class() { return Type::IfcDoor; } -IfcDoor::IfcDoor(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoor)) throw; entity = e; } +IfcDoor::IfcDoor(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoor)) throw; entity = e; } // IfcDoorLiningProperties bool IfcDoorLiningProperties::hasLiningDepth() { return !entity->getArgument(4)->isNull(); } IfcPositiveLengthMeasure IfcDoorLiningProperties::LiningDepth() { return *entity->getArgument(4); } @@ -5542,7 +5541,7 @@ SHARED_PTR IfcDoorLiningProperties::ShapeAspectStyle() { return bool IfcDoorLiningProperties::is(Type::Enum v) { return v == Type::IfcDoorLiningProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcDoorLiningProperties::type() { return Type::IfcDoorLiningProperties; } Type::Enum IfcDoorLiningProperties::Class() { return Type::IfcDoorLiningProperties; } -IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorLiningProperties)) throw; entity = e; } +IfcDoorLiningProperties::IfcDoorLiningProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorLiningProperties)) throw; entity = e; } // IfcDoorPanelProperties bool IfcDoorPanelProperties::hasPanelDepth() { return !entity->getArgument(4)->isNull(); } IfcPositiveLengthMeasure IfcDoorPanelProperties::PanelDepth() { return *entity->getArgument(4); } @@ -5555,7 +5554,7 @@ SHARED_PTR IfcDoorPanelProperties::ShapeAspectStyle() { return r bool IfcDoorPanelProperties::is(Type::Enum v) { return v == Type::IfcDoorPanelProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcDoorPanelProperties::type() { return Type::IfcDoorPanelProperties; } Type::Enum IfcDoorPanelProperties::Class() { return Type::IfcDoorPanelProperties; } -IfcDoorPanelProperties::IfcDoorPanelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorPanelProperties)) throw; entity = e; } +IfcDoorPanelProperties::IfcDoorPanelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorPanelProperties)) throw; entity = e; } // IfcDoorStyle IfcDoorStyleOperationEnum::IfcDoorStyleOperationEnum IfcDoorStyle::OperationType() { return IfcDoorStyleOperationEnum::FromString(*entity->getArgument(8)); } IfcDoorStyleConstructionEnum::IfcDoorStyleConstructionEnum IfcDoorStyle::ConstructionType() { return IfcDoorStyleConstructionEnum::FromString(*entity->getArgument(9)); } @@ -5564,7 +5563,7 @@ bool IfcDoorStyle::Sizeable() { return *entity->getArgument(11); } bool IfcDoorStyle::is(Type::Enum v) { return v == Type::IfcDoorStyle || IfcTypeProduct::is(v); } Type::Enum IfcDoorStyle::type() { return Type::IfcDoorStyle; } Type::Enum IfcDoorStyle::Class() { return Type::IfcDoorStyle; } -IfcDoorStyle::IfcDoorStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorStyle)) throw; entity = e; } +IfcDoorStyle::IfcDoorStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcDoorStyle)) throw; entity = e; } // IfcDraughtingCallout SHARED_PTR< IfcTemplatedEntityList > IfcDraughtingCallout::Contents() { RETURN_AS_LIST(IfcAbstractSelect,0) } IfcDraughtingCalloutRelationship::list IfcDraughtingCallout::IsRelatedFromCallout() { RETURN_INVERSE(IfcDraughtingCalloutRelationship) } @@ -5572,7 +5571,7 @@ IfcDraughtingCalloutRelationship::list IfcDraughtingCallout::IsRelatedToCallout( bool IfcDraughtingCallout::is(Type::Enum v) { return v == Type::IfcDraughtingCallout || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcDraughtingCallout::type() { return Type::IfcDraughtingCallout; } Type::Enum IfcDraughtingCallout::Class() { return Type::IfcDraughtingCallout; } -IfcDraughtingCallout::IfcDraughtingCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingCallout)) throw; entity = e; } +IfcDraughtingCallout::IfcDraughtingCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingCallout)) throw; entity = e; } // IfcDraughtingCalloutRelationship bool IfcDraughtingCalloutRelationship::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcDraughtingCalloutRelationship::Name() { return *entity->getArgument(0); } @@ -5583,73 +5582,73 @@ SHARED_PTR IfcDraughtingCalloutRelationship::RelatedDraugh bool IfcDraughtingCalloutRelationship::is(Type::Enum v) { return v == Type::IfcDraughtingCalloutRelationship; } Type::Enum IfcDraughtingCalloutRelationship::type() { return Type::IfcDraughtingCalloutRelationship; } Type::Enum IfcDraughtingCalloutRelationship::Class() { return Type::IfcDraughtingCalloutRelationship; } -IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingCalloutRelationship)) throw; entity = e; } +IfcDraughtingCalloutRelationship::IfcDraughtingCalloutRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingCalloutRelationship)) throw; entity = e; } // IfcDraughtingPreDefinedColour bool IfcDraughtingPreDefinedColour::is(Type::Enum v) { return v == Type::IfcDraughtingPreDefinedColour || IfcPreDefinedColour::is(v); } Type::Enum IfcDraughtingPreDefinedColour::type() { return Type::IfcDraughtingPreDefinedColour; } Type::Enum IfcDraughtingPreDefinedColour::Class() { return Type::IfcDraughtingPreDefinedColour; } -IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedColour)) throw; entity = e; } +IfcDraughtingPreDefinedColour::IfcDraughtingPreDefinedColour(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedColour)) throw; entity = e; } // IfcDraughtingPreDefinedCurveFont bool IfcDraughtingPreDefinedCurveFont::is(Type::Enum v) { return v == Type::IfcDraughtingPreDefinedCurveFont || IfcPreDefinedCurveFont::is(v); } Type::Enum IfcDraughtingPreDefinedCurveFont::type() { return Type::IfcDraughtingPreDefinedCurveFont; } Type::Enum IfcDraughtingPreDefinedCurveFont::Class() { return Type::IfcDraughtingPreDefinedCurveFont; } -IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedCurveFont)) throw; entity = e; } +IfcDraughtingPreDefinedCurveFont::IfcDraughtingPreDefinedCurveFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedCurveFont)) throw; entity = e; } // IfcDraughtingPreDefinedTextFont bool IfcDraughtingPreDefinedTextFont::is(Type::Enum v) { return v == Type::IfcDraughtingPreDefinedTextFont || IfcPreDefinedTextFont::is(v); } Type::Enum IfcDraughtingPreDefinedTextFont::type() { return Type::IfcDraughtingPreDefinedTextFont; } Type::Enum IfcDraughtingPreDefinedTextFont::Class() { return Type::IfcDraughtingPreDefinedTextFont; } -IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedTextFont)) throw; entity = e; } +IfcDraughtingPreDefinedTextFont::IfcDraughtingPreDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcDraughtingPreDefinedTextFont)) throw; entity = e; } // IfcDuctFittingType IfcDuctFittingTypeEnum::IfcDuctFittingTypeEnum IfcDuctFittingType::PredefinedType() { return IfcDuctFittingTypeEnum::FromString(*entity->getArgument(9)); } bool IfcDuctFittingType::is(Type::Enum v) { return v == Type::IfcDuctFittingType || IfcFlowFittingType::is(v); } Type::Enum IfcDuctFittingType::type() { return Type::IfcDuctFittingType; } Type::Enum IfcDuctFittingType::Class() { return Type::IfcDuctFittingType; } -IfcDuctFittingType::IfcDuctFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctFittingType)) throw; entity = e; } +IfcDuctFittingType::IfcDuctFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctFittingType)) throw; entity = e; } // IfcDuctSegmentType IfcDuctSegmentTypeEnum::IfcDuctSegmentTypeEnum IfcDuctSegmentType::PredefinedType() { return IfcDuctSegmentTypeEnum::FromString(*entity->getArgument(9)); } bool IfcDuctSegmentType::is(Type::Enum v) { return v == Type::IfcDuctSegmentType || IfcFlowSegmentType::is(v); } Type::Enum IfcDuctSegmentType::type() { return Type::IfcDuctSegmentType; } Type::Enum IfcDuctSegmentType::Class() { return Type::IfcDuctSegmentType; } -IfcDuctSegmentType::IfcDuctSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctSegmentType)) throw; entity = e; } +IfcDuctSegmentType::IfcDuctSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctSegmentType)) throw; entity = e; } // IfcDuctSilencerType IfcDuctSilencerTypeEnum::IfcDuctSilencerTypeEnum IfcDuctSilencerType::PredefinedType() { return IfcDuctSilencerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcDuctSilencerType::is(Type::Enum v) { return v == Type::IfcDuctSilencerType || IfcFlowTreatmentDeviceType::is(v); } Type::Enum IfcDuctSilencerType::type() { return Type::IfcDuctSilencerType; } Type::Enum IfcDuctSilencerType::Class() { return Type::IfcDuctSilencerType; } -IfcDuctSilencerType::IfcDuctSilencerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctSilencerType)) throw; entity = e; } +IfcDuctSilencerType::IfcDuctSilencerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcDuctSilencerType)) throw; entity = e; } // IfcEdge SHARED_PTR IfcEdge::EdgeStart() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcEdge::EdgeEnd() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcEdge::is(Type::Enum v) { return v == Type::IfcEdge || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcEdge::type() { return Type::IfcEdge; } Type::Enum IfcEdge::Class() { return Type::IfcEdge; } -IfcEdge::IfcEdge(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdge)) throw; entity = e; } +IfcEdge::IfcEdge(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdge)) throw; entity = e; } // IfcEdgeCurve SHARED_PTR IfcEdgeCurve::EdgeGeometry() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcEdgeCurve::SameSense() { return *entity->getArgument(3); } bool IfcEdgeCurve::is(Type::Enum v) { return v == Type::IfcEdgeCurve || IfcEdge::is(v); } Type::Enum IfcEdgeCurve::type() { return Type::IfcEdgeCurve; } Type::Enum IfcEdgeCurve::Class() { return Type::IfcEdgeCurve; } -IfcEdgeCurve::IfcEdgeCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeCurve)) throw; entity = e; } +IfcEdgeCurve::IfcEdgeCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeCurve)) throw; entity = e; } // IfcEdgeFeature bool IfcEdgeFeature::hasFeatureLength() { return !entity->getArgument(8)->isNull(); } IfcPositiveLengthMeasure IfcEdgeFeature::FeatureLength() { return *entity->getArgument(8); } bool IfcEdgeFeature::is(Type::Enum v) { return v == Type::IfcEdgeFeature || IfcFeatureElementSubtraction::is(v); } Type::Enum IfcEdgeFeature::type() { return Type::IfcEdgeFeature; } Type::Enum IfcEdgeFeature::Class() { return Type::IfcEdgeFeature; } -IfcEdgeFeature::IfcEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeFeature)) throw; entity = e; } +IfcEdgeFeature::IfcEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeFeature)) throw; entity = e; } // IfcEdgeLoop SHARED_PTR< IfcTemplatedEntityList > IfcEdgeLoop::EdgeList() { RETURN_AS_LIST(IfcOrientedEdge,0) } bool IfcEdgeLoop::is(Type::Enum v) { return v == Type::IfcEdgeLoop || IfcLoop::is(v); } Type::Enum IfcEdgeLoop::type() { return Type::IfcEdgeLoop; } Type::Enum IfcEdgeLoop::Class() { return Type::IfcEdgeLoop; } -IfcEdgeLoop::IfcEdgeLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeLoop)) throw; entity = e; } +IfcEdgeLoop::IfcEdgeLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcEdgeLoop)) throw; entity = e; } // IfcElectricApplianceType IfcElectricApplianceTypeEnum::IfcElectricApplianceTypeEnum IfcElectricApplianceType::PredefinedType() { return IfcElectricApplianceTypeEnum::FromString(*entity->getArgument(9)); } bool IfcElectricApplianceType::is(Type::Enum v) { return v == Type::IfcElectricApplianceType || IfcFlowTerminalType::is(v); } Type::Enum IfcElectricApplianceType::type() { return Type::IfcElectricApplianceType; } Type::Enum IfcElectricApplianceType::Class() { return Type::IfcElectricApplianceType; } -IfcElectricApplianceType::IfcElectricApplianceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricApplianceType)) throw; entity = e; } +IfcElectricApplianceType::IfcElectricApplianceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricApplianceType)) throw; entity = e; } // IfcElectricDistributionPoint IfcElectricDistributionPointFunctionEnum::IfcElectricDistributionPointFunctionEnum IfcElectricDistributionPoint::DistributionPointFunction() { return IfcElectricDistributionPointFunctionEnum::FromString(*entity->getArgument(8)); } bool IfcElectricDistributionPoint::hasUserDefinedFunction() { return !entity->getArgument(9)->isNull(); } @@ -5657,37 +5656,37 @@ IfcLabel IfcElectricDistributionPoint::UserDefinedFunction() { return *entity->g bool IfcElectricDistributionPoint::is(Type::Enum v) { return v == Type::IfcElectricDistributionPoint || IfcFlowController::is(v); } Type::Enum IfcElectricDistributionPoint::type() { return Type::IfcElectricDistributionPoint; } Type::Enum IfcElectricDistributionPoint::Class() { return Type::IfcElectricDistributionPoint; } -IfcElectricDistributionPoint::IfcElectricDistributionPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricDistributionPoint)) throw; entity = e; } +IfcElectricDistributionPoint::IfcElectricDistributionPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricDistributionPoint)) throw; entity = e; } // IfcElectricFlowStorageDeviceType IfcElectricFlowStorageDeviceTypeEnum::IfcElectricFlowStorageDeviceTypeEnum IfcElectricFlowStorageDeviceType::PredefinedType() { return IfcElectricFlowStorageDeviceTypeEnum::FromString(*entity->getArgument(9)); } bool IfcElectricFlowStorageDeviceType::is(Type::Enum v) { return v == Type::IfcElectricFlowStorageDeviceType || IfcFlowStorageDeviceType::is(v); } Type::Enum IfcElectricFlowStorageDeviceType::type() { return Type::IfcElectricFlowStorageDeviceType; } Type::Enum IfcElectricFlowStorageDeviceType::Class() { return Type::IfcElectricFlowStorageDeviceType; } -IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricFlowStorageDeviceType)) throw; entity = e; } +IfcElectricFlowStorageDeviceType::IfcElectricFlowStorageDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricFlowStorageDeviceType)) throw; entity = e; } // IfcElectricGeneratorType IfcElectricGeneratorTypeEnum::IfcElectricGeneratorTypeEnum IfcElectricGeneratorType::PredefinedType() { return IfcElectricGeneratorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcElectricGeneratorType::is(Type::Enum v) { return v == Type::IfcElectricGeneratorType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcElectricGeneratorType::type() { return Type::IfcElectricGeneratorType; } Type::Enum IfcElectricGeneratorType::Class() { return Type::IfcElectricGeneratorType; } -IfcElectricGeneratorType::IfcElectricGeneratorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricGeneratorType)) throw; entity = e; } +IfcElectricGeneratorType::IfcElectricGeneratorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricGeneratorType)) throw; entity = e; } // IfcElectricHeaterType IfcElectricHeaterTypeEnum::IfcElectricHeaterTypeEnum IfcElectricHeaterType::PredefinedType() { return IfcElectricHeaterTypeEnum::FromString(*entity->getArgument(9)); } bool IfcElectricHeaterType::is(Type::Enum v) { return v == Type::IfcElectricHeaterType || IfcFlowTerminalType::is(v); } Type::Enum IfcElectricHeaterType::type() { return Type::IfcElectricHeaterType; } Type::Enum IfcElectricHeaterType::Class() { return Type::IfcElectricHeaterType; } -IfcElectricHeaterType::IfcElectricHeaterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricHeaterType)) throw; entity = e; } +IfcElectricHeaterType::IfcElectricHeaterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricHeaterType)) throw; entity = e; } // IfcElectricMotorType IfcElectricMotorTypeEnum::IfcElectricMotorTypeEnum IfcElectricMotorType::PredefinedType() { return IfcElectricMotorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcElectricMotorType::is(Type::Enum v) { return v == Type::IfcElectricMotorType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcElectricMotorType::type() { return Type::IfcElectricMotorType; } Type::Enum IfcElectricMotorType::Class() { return Type::IfcElectricMotorType; } -IfcElectricMotorType::IfcElectricMotorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricMotorType)) throw; entity = e; } +IfcElectricMotorType::IfcElectricMotorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricMotorType)) throw; entity = e; } // IfcElectricTimeControlType IfcElectricTimeControlTypeEnum::IfcElectricTimeControlTypeEnum IfcElectricTimeControlType::PredefinedType() { return IfcElectricTimeControlTypeEnum::FromString(*entity->getArgument(9)); } bool IfcElectricTimeControlType::is(Type::Enum v) { return v == Type::IfcElectricTimeControlType || IfcFlowControllerType::is(v); } Type::Enum IfcElectricTimeControlType::type() { return Type::IfcElectricTimeControlType; } Type::Enum IfcElectricTimeControlType::Class() { return Type::IfcElectricTimeControlType; } -IfcElectricTimeControlType::IfcElectricTimeControlType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricTimeControlType)) throw; entity = e; } +IfcElectricTimeControlType::IfcElectricTimeControlType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricTimeControlType)) throw; entity = e; } // IfcElectricalBaseProperties bool IfcElectricalBaseProperties::hasElectricCurrentType() { return !entity->getArgument(6)->isNull(); } IfcElectricCurrentEnum::IfcElectricCurrentEnum IfcElectricalBaseProperties::ElectricCurrentType() { return IfcElectricCurrentEnum::FromString(*entity->getArgument(6)); } @@ -5705,17 +5704,17 @@ int IfcElectricalBaseProperties::InputPhase() { return *entity->getArgument(13); bool IfcElectricalBaseProperties::is(Type::Enum v) { return v == Type::IfcElectricalBaseProperties || IfcEnergyProperties::is(v); } Type::Enum IfcElectricalBaseProperties::type() { return Type::IfcElectricalBaseProperties; } Type::Enum IfcElectricalBaseProperties::Class() { return Type::IfcElectricalBaseProperties; } -IfcElectricalBaseProperties::IfcElectricalBaseProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalBaseProperties)) throw; entity = e; } +IfcElectricalBaseProperties::IfcElectricalBaseProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalBaseProperties)) throw; entity = e; } // IfcElectricalCircuit bool IfcElectricalCircuit::is(Type::Enum v) { return v == Type::IfcElectricalCircuit || IfcSystem::is(v); } Type::Enum IfcElectricalCircuit::type() { return Type::IfcElectricalCircuit; } Type::Enum IfcElectricalCircuit::Class() { return Type::IfcElectricalCircuit; } -IfcElectricalCircuit::IfcElectricalCircuit(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalCircuit)) throw; entity = e; } +IfcElectricalCircuit::IfcElectricalCircuit(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalCircuit)) throw; entity = e; } // IfcElectricalElement bool IfcElectricalElement::is(Type::Enum v) { return v == Type::IfcElectricalElement || IfcElement::is(v); } Type::Enum IfcElectricalElement::type() { return Type::IfcElectricalElement; } Type::Enum IfcElectricalElement::Class() { return Type::IfcElectricalElement; } -IfcElectricalElement::IfcElectricalElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalElement)) throw; entity = e; } +IfcElectricalElement::IfcElectricalElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcElectricalElement)) throw; entity = e; } // IfcElement bool IfcElement::hasTag() { return !entity->getArgument(7)->isNull(); } IfcIdentifier IfcElement::Tag() { return *entity->getArgument(7); } @@ -5734,7 +5733,7 @@ IfcRelContainedInSpatialStructure::list IfcElement::ContainedInStructure() { RET bool IfcElement::is(Type::Enum v) { return v == Type::IfcElement || IfcProduct::is(v); } Type::Enum IfcElement::type() { return Type::IfcElement; } Type::Enum IfcElement::Class() { return Type::IfcElement; } -IfcElement::IfcElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcElement)) throw; entity = e; } +IfcElement::IfcElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcElement)) throw; entity = e; } // IfcElementAssembly bool IfcElementAssembly::hasAssemblyPlace() { return !entity->getArgument(8)->isNull(); } IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcElementAssembly::AssemblyPlace() { return IfcAssemblyPlaceEnum::FromString(*entity->getArgument(8)); } @@ -5742,17 +5741,17 @@ IfcElementAssemblyTypeEnum::IfcElementAssemblyTypeEnum IfcElementAssembly::Prede bool IfcElementAssembly::is(Type::Enum v) { return v == Type::IfcElementAssembly || IfcElement::is(v); } Type::Enum IfcElementAssembly::type() { return Type::IfcElementAssembly; } Type::Enum IfcElementAssembly::Class() { return Type::IfcElementAssembly; } -IfcElementAssembly::IfcElementAssembly(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementAssembly)) throw; entity = e; } +IfcElementAssembly::IfcElementAssembly(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementAssembly)) throw; entity = e; } // IfcElementComponent bool IfcElementComponent::is(Type::Enum v) { return v == Type::IfcElementComponent || IfcElement::is(v); } Type::Enum IfcElementComponent::type() { return Type::IfcElementComponent; } Type::Enum IfcElementComponent::Class() { return Type::IfcElementComponent; } -IfcElementComponent::IfcElementComponent(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementComponent)) throw; entity = e; } +IfcElementComponent::IfcElementComponent(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementComponent)) throw; entity = e; } // IfcElementComponentType bool IfcElementComponentType::is(Type::Enum v) { return v == Type::IfcElementComponentType || IfcElementType::is(v); } Type::Enum IfcElementComponentType::type() { return Type::IfcElementComponentType; } Type::Enum IfcElementComponentType::Class() { return Type::IfcElementComponentType; } -IfcElementComponentType::IfcElementComponentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementComponentType)) throw; entity = e; } +IfcElementComponentType::IfcElementComponentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementComponentType)) throw; entity = e; } // IfcElementQuantity bool IfcElementQuantity::hasMethodOfMeasurement() { return !entity->getArgument(4)->isNull(); } IfcLabel IfcElementQuantity::MethodOfMeasurement() { return *entity->getArgument(4); } @@ -5760,44 +5759,44 @@ SHARED_PTR< IfcTemplatedEntityList > IfcElementQuantity::Qu bool IfcElementQuantity::is(Type::Enum v) { return v == Type::IfcElementQuantity || IfcPropertySetDefinition::is(v); } Type::Enum IfcElementQuantity::type() { return Type::IfcElementQuantity; } Type::Enum IfcElementQuantity::Class() { return Type::IfcElementQuantity; } -IfcElementQuantity::IfcElementQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementQuantity)) throw; entity = e; } +IfcElementQuantity::IfcElementQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementQuantity)) throw; entity = e; } // IfcElementType bool IfcElementType::hasElementType() { return !entity->getArgument(8)->isNull(); } IfcLabel IfcElementType::ElementType() { return *entity->getArgument(8); } bool IfcElementType::is(Type::Enum v) { return v == Type::IfcElementType || IfcTypeProduct::is(v); } Type::Enum IfcElementType::type() { return Type::IfcElementType; } Type::Enum IfcElementType::Class() { return Type::IfcElementType; } -IfcElementType::IfcElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementType)) throw; entity = e; } +IfcElementType::IfcElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementType)) throw; entity = e; } // IfcElementarySurface SHARED_PTR IfcElementarySurface::Position() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcElementarySurface::is(Type::Enum v) { return v == Type::IfcElementarySurface || IfcSurface::is(v); } Type::Enum IfcElementarySurface::type() { return Type::IfcElementarySurface; } Type::Enum IfcElementarySurface::Class() { return Type::IfcElementarySurface; } -IfcElementarySurface::IfcElementarySurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementarySurface)) throw; entity = e; } +IfcElementarySurface::IfcElementarySurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcElementarySurface)) throw; entity = e; } // IfcEllipse IfcPositiveLengthMeasure IfcEllipse::SemiAxis1() { return *entity->getArgument(1); } IfcPositiveLengthMeasure IfcEllipse::SemiAxis2() { return *entity->getArgument(2); } bool IfcEllipse::is(Type::Enum v) { return v == Type::IfcEllipse || IfcConic::is(v); } Type::Enum IfcEllipse::type() { return Type::IfcEllipse; } Type::Enum IfcEllipse::Class() { return Type::IfcEllipse; } -IfcEllipse::IfcEllipse(IfcAbstractEntityPtr e) { if (!is(Type::IfcEllipse)) throw; entity = e; } +IfcEllipse::IfcEllipse(IfcAbstractEntityPtr e) { if (!is(Type::IfcEllipse)) throw; entity = e; } // IfcEllipseProfileDef IfcPositiveLengthMeasure IfcEllipseProfileDef::SemiAxis1() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcEllipseProfileDef::SemiAxis2() { return *entity->getArgument(4); } bool IfcEllipseProfileDef::is(Type::Enum v) { return v == Type::IfcEllipseProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcEllipseProfileDef::type() { return Type::IfcEllipseProfileDef; } Type::Enum IfcEllipseProfileDef::Class() { return Type::IfcEllipseProfileDef; } -IfcEllipseProfileDef::IfcEllipseProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcEllipseProfileDef)) throw; entity = e; } +IfcEllipseProfileDef::IfcEllipseProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcEllipseProfileDef)) throw; entity = e; } // IfcEnergyConversionDevice bool IfcEnergyConversionDevice::is(Type::Enum v) { return v == Type::IfcEnergyConversionDevice || IfcDistributionFlowElement::is(v); } Type::Enum IfcEnergyConversionDevice::type() { return Type::IfcEnergyConversionDevice; } Type::Enum IfcEnergyConversionDevice::Class() { return Type::IfcEnergyConversionDevice; } -IfcEnergyConversionDevice::IfcEnergyConversionDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyConversionDevice)) throw; entity = e; } +IfcEnergyConversionDevice::IfcEnergyConversionDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyConversionDevice)) throw; entity = e; } // IfcEnergyConversionDeviceType bool IfcEnergyConversionDeviceType::is(Type::Enum v) { return v == Type::IfcEnergyConversionDeviceType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcEnergyConversionDeviceType::type() { return Type::IfcEnergyConversionDeviceType; } Type::Enum IfcEnergyConversionDeviceType::Class() { return Type::IfcEnergyConversionDeviceType; } -IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyConversionDeviceType)) throw; entity = e; } +IfcEnergyConversionDeviceType::IfcEnergyConversionDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyConversionDeviceType)) throw; entity = e; } // IfcEnergyProperties bool IfcEnergyProperties::hasEnergySequence() { return !entity->getArgument(4)->isNull(); } IfcEnergySequenceEnum::IfcEnergySequenceEnum IfcEnergyProperties::EnergySequence() { return IfcEnergySequenceEnum::FromString(*entity->getArgument(4)); } @@ -5806,7 +5805,7 @@ IfcLabel IfcEnergyProperties::UserDefinedEnergySequence() { return *entity->getA bool IfcEnergyProperties::is(Type::Enum v) { return v == Type::IfcEnergyProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcEnergyProperties::type() { return Type::IfcEnergyProperties; } Type::Enum IfcEnergyProperties::Class() { return Type::IfcEnergyProperties; } -IfcEnergyProperties::IfcEnergyProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyProperties)) throw; entity = e; } +IfcEnergyProperties::IfcEnergyProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnergyProperties)) throw; entity = e; } // IfcEnvironmentalImpactValue IfcLabel IfcEnvironmentalImpactValue::ImpactType() { return *entity->getArgument(6); } IfcEnvironmentalImpactCategoryEnum::IfcEnvironmentalImpactCategoryEnum IfcEnvironmentalImpactValue::Category() { return IfcEnvironmentalImpactCategoryEnum::FromString(*entity->getArgument(7)); } @@ -5815,29 +5814,29 @@ IfcLabel IfcEnvironmentalImpactValue::UserDefinedCategory() { return *entity->ge bool IfcEnvironmentalImpactValue::is(Type::Enum v) { return v == Type::IfcEnvironmentalImpactValue || IfcAppliedValue::is(v); } Type::Enum IfcEnvironmentalImpactValue::type() { return Type::IfcEnvironmentalImpactValue; } Type::Enum IfcEnvironmentalImpactValue::Class() { return Type::IfcEnvironmentalImpactValue; } -IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnvironmentalImpactValue)) throw; entity = e; } +IfcEnvironmentalImpactValue::IfcEnvironmentalImpactValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcEnvironmentalImpactValue)) throw; entity = e; } // IfcEquipmentElement bool IfcEquipmentElement::is(Type::Enum v) { return v == Type::IfcEquipmentElement || IfcElement::is(v); } Type::Enum IfcEquipmentElement::type() { return Type::IfcEquipmentElement; } Type::Enum IfcEquipmentElement::Class() { return Type::IfcEquipmentElement; } -IfcEquipmentElement::IfcEquipmentElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcEquipmentElement)) throw; entity = e; } +IfcEquipmentElement::IfcEquipmentElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcEquipmentElement)) throw; entity = e; } // IfcEquipmentStandard bool IfcEquipmentStandard::is(Type::Enum v) { return v == Type::IfcEquipmentStandard || IfcControl::is(v); } Type::Enum IfcEquipmentStandard::type() { return Type::IfcEquipmentStandard; } Type::Enum IfcEquipmentStandard::Class() { return Type::IfcEquipmentStandard; } -IfcEquipmentStandard::IfcEquipmentStandard(IfcAbstractEntityPtr e) { if (!is(Type::IfcEquipmentStandard)) throw; entity = e; } +IfcEquipmentStandard::IfcEquipmentStandard(IfcAbstractEntityPtr e) { if (!is(Type::IfcEquipmentStandard)) throw; entity = e; } // IfcEvaporativeCoolerType IfcEvaporativeCoolerTypeEnum::IfcEvaporativeCoolerTypeEnum IfcEvaporativeCoolerType::PredefinedType() { return IfcEvaporativeCoolerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcEvaporativeCoolerType::is(Type::Enum v) { return v == Type::IfcEvaporativeCoolerType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcEvaporativeCoolerType::type() { return Type::IfcEvaporativeCoolerType; } Type::Enum IfcEvaporativeCoolerType::Class() { return Type::IfcEvaporativeCoolerType; } -IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEvaporativeCoolerType)) throw; entity = e; } +IfcEvaporativeCoolerType::IfcEvaporativeCoolerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEvaporativeCoolerType)) throw; entity = e; } // IfcEvaporatorType IfcEvaporatorTypeEnum::IfcEvaporatorTypeEnum IfcEvaporatorType::PredefinedType() { return IfcEvaporatorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcEvaporatorType::is(Type::Enum v) { return v == Type::IfcEvaporatorType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcEvaporatorType::type() { return Type::IfcEvaporatorType; } Type::Enum IfcEvaporatorType::Class() { return Type::IfcEvaporatorType; } -IfcEvaporatorType::IfcEvaporatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEvaporatorType)) throw; entity = e; } +IfcEvaporatorType::IfcEvaporatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcEvaporatorType)) throw; entity = e; } // IfcExtendedMaterialProperties SHARED_PTR< IfcTemplatedEntityList > IfcExtendedMaterialProperties::ExtendedProperties() { RETURN_AS_LIST(IfcProperty,1) } bool IfcExtendedMaterialProperties::hasDescription() { return !entity->getArgument(2)->isNull(); } @@ -5846,7 +5845,7 @@ IfcLabel IfcExtendedMaterialProperties::Name() { return *entity->getArgument(3); bool IfcExtendedMaterialProperties::is(Type::Enum v) { return v == Type::IfcExtendedMaterialProperties || IfcMaterialProperties::is(v); } Type::Enum IfcExtendedMaterialProperties::type() { return Type::IfcExtendedMaterialProperties; } Type::Enum IfcExtendedMaterialProperties::Class() { return Type::IfcExtendedMaterialProperties; } -IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcExtendedMaterialProperties)) throw; entity = e; } +IfcExtendedMaterialProperties::IfcExtendedMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcExtendedMaterialProperties)) throw; entity = e; } // IfcExternalReference bool IfcExternalReference::hasLocation() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcExternalReference::Location() { return *entity->getArgument(0); } @@ -5857,76 +5856,76 @@ IfcLabel IfcExternalReference::Name() { return *entity->getArgument(2); } bool IfcExternalReference::is(Type::Enum v) { return v == Type::IfcExternalReference; } Type::Enum IfcExternalReference::type() { return Type::IfcExternalReference; } Type::Enum IfcExternalReference::Class() { return Type::IfcExternalReference; } -IfcExternalReference::IfcExternalReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternalReference)) throw; entity = e; } +IfcExternalReference::IfcExternalReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternalReference)) throw; entity = e; } // IfcExternallyDefinedHatchStyle bool IfcExternallyDefinedHatchStyle::is(Type::Enum v) { return v == Type::IfcExternallyDefinedHatchStyle || IfcExternalReference::is(v); } Type::Enum IfcExternallyDefinedHatchStyle::type() { return Type::IfcExternallyDefinedHatchStyle; } Type::Enum IfcExternallyDefinedHatchStyle::Class() { return Type::IfcExternallyDefinedHatchStyle; } -IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedHatchStyle)) throw; entity = e; } +IfcExternallyDefinedHatchStyle::IfcExternallyDefinedHatchStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedHatchStyle)) throw; entity = e; } // IfcExternallyDefinedSurfaceStyle bool IfcExternallyDefinedSurfaceStyle::is(Type::Enum v) { return v == Type::IfcExternallyDefinedSurfaceStyle || IfcExternalReference::is(v); } Type::Enum IfcExternallyDefinedSurfaceStyle::type() { return Type::IfcExternallyDefinedSurfaceStyle; } Type::Enum IfcExternallyDefinedSurfaceStyle::Class() { return Type::IfcExternallyDefinedSurfaceStyle; } -IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedSurfaceStyle)) throw; entity = e; } +IfcExternallyDefinedSurfaceStyle::IfcExternallyDefinedSurfaceStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedSurfaceStyle)) throw; entity = e; } // IfcExternallyDefinedSymbol bool IfcExternallyDefinedSymbol::is(Type::Enum v) { return v == Type::IfcExternallyDefinedSymbol || IfcExternalReference::is(v); } Type::Enum IfcExternallyDefinedSymbol::type() { return Type::IfcExternallyDefinedSymbol; } Type::Enum IfcExternallyDefinedSymbol::Class() { return Type::IfcExternallyDefinedSymbol; } -IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedSymbol)) throw; entity = e; } +IfcExternallyDefinedSymbol::IfcExternallyDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedSymbol)) throw; entity = e; } // IfcExternallyDefinedTextFont bool IfcExternallyDefinedTextFont::is(Type::Enum v) { return v == Type::IfcExternallyDefinedTextFont || IfcExternalReference::is(v); } Type::Enum IfcExternallyDefinedTextFont::type() { return Type::IfcExternallyDefinedTextFont; } Type::Enum IfcExternallyDefinedTextFont::Class() { return Type::IfcExternallyDefinedTextFont; } -IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedTextFont)) throw; entity = e; } +IfcExternallyDefinedTextFont::IfcExternallyDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcExternallyDefinedTextFont)) throw; entity = e; } // IfcExtrudedAreaSolid SHARED_PTR IfcExtrudedAreaSolid::ExtrudedDirection() { return reinterpret_pointer_cast(*entity->getArgument(2)); } IfcPositiveLengthMeasure IfcExtrudedAreaSolid::Depth() { return *entity->getArgument(3); } bool IfcExtrudedAreaSolid::is(Type::Enum v) { return v == Type::IfcExtrudedAreaSolid || IfcSweptAreaSolid::is(v); } Type::Enum IfcExtrudedAreaSolid::type() { return Type::IfcExtrudedAreaSolid; } Type::Enum IfcExtrudedAreaSolid::Class() { return Type::IfcExtrudedAreaSolid; } -IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcExtrudedAreaSolid)) throw; entity = e; } +IfcExtrudedAreaSolid::IfcExtrudedAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcExtrudedAreaSolid)) throw; entity = e; } // IfcFace SHARED_PTR< IfcTemplatedEntityList > IfcFace::Bounds() { RETURN_AS_LIST(IfcFaceBound,0) } bool IfcFace::is(Type::Enum v) { return v == Type::IfcFace || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcFace::type() { return Type::IfcFace; } Type::Enum IfcFace::Class() { return Type::IfcFace; } -IfcFace::IfcFace(IfcAbstractEntityPtr e) { if (!is(Type::IfcFace)) throw; entity = e; } +IfcFace::IfcFace(IfcAbstractEntityPtr e) { if (!is(Type::IfcFace)) throw; entity = e; } // IfcFaceBasedSurfaceModel SHARED_PTR< IfcTemplatedEntityList > IfcFaceBasedSurfaceModel::FbsmFaces() { RETURN_AS_LIST(IfcConnectedFaceSet,0) } bool IfcFaceBasedSurfaceModel::is(Type::Enum v) { return v == Type::IfcFaceBasedSurfaceModel || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcFaceBasedSurfaceModel::type() { return Type::IfcFaceBasedSurfaceModel; } Type::Enum IfcFaceBasedSurfaceModel::Class() { return Type::IfcFaceBasedSurfaceModel; } -IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceBasedSurfaceModel)) throw; entity = e; } +IfcFaceBasedSurfaceModel::IfcFaceBasedSurfaceModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceBasedSurfaceModel)) throw; entity = e; } // IfcFaceBound SHARED_PTR IfcFaceBound::Bound() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcFaceBound::Orientation() { return *entity->getArgument(1); } bool IfcFaceBound::is(Type::Enum v) { return v == Type::IfcFaceBound || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcFaceBound::type() { return Type::IfcFaceBound; } Type::Enum IfcFaceBound::Class() { return Type::IfcFaceBound; } -IfcFaceBound::IfcFaceBound(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceBound)) throw; entity = e; } +IfcFaceBound::IfcFaceBound(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceBound)) throw; entity = e; } // IfcFaceOuterBound bool IfcFaceOuterBound::is(Type::Enum v) { return v == Type::IfcFaceOuterBound || IfcFaceBound::is(v); } Type::Enum IfcFaceOuterBound::type() { return Type::IfcFaceOuterBound; } Type::Enum IfcFaceOuterBound::Class() { return Type::IfcFaceOuterBound; } -IfcFaceOuterBound::IfcFaceOuterBound(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceOuterBound)) throw; entity = e; } +IfcFaceOuterBound::IfcFaceOuterBound(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceOuterBound)) throw; entity = e; } // IfcFaceSurface SHARED_PTR IfcFaceSurface::FaceSurface() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcFaceSurface::SameSense() { return *entity->getArgument(2); } bool IfcFaceSurface::is(Type::Enum v) { return v == Type::IfcFaceSurface || IfcFace::is(v); } Type::Enum IfcFaceSurface::type() { return Type::IfcFaceSurface; } Type::Enum IfcFaceSurface::Class() { return Type::IfcFaceSurface; } -IfcFaceSurface::IfcFaceSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceSurface)) throw; entity = e; } +IfcFaceSurface::IfcFaceSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcFaceSurface)) throw; entity = e; } // IfcFacetedBrep bool IfcFacetedBrep::is(Type::Enum v) { return v == Type::IfcFacetedBrep || IfcManifoldSolidBrep::is(v); } Type::Enum IfcFacetedBrep::type() { return Type::IfcFacetedBrep; } Type::Enum IfcFacetedBrep::Class() { return Type::IfcFacetedBrep; } -IfcFacetedBrep::IfcFacetedBrep(IfcAbstractEntityPtr e) { if (!is(Type::IfcFacetedBrep)) throw; entity = e; } +IfcFacetedBrep::IfcFacetedBrep(IfcAbstractEntityPtr e) { if (!is(Type::IfcFacetedBrep)) throw; entity = e; } // IfcFacetedBrepWithVoids SHARED_PTR< IfcTemplatedEntityList > IfcFacetedBrepWithVoids::Voids() { RETURN_AS_LIST(IfcClosedShell,1) } bool IfcFacetedBrepWithVoids::is(Type::Enum v) { return v == Type::IfcFacetedBrepWithVoids || IfcManifoldSolidBrep::is(v); } Type::Enum IfcFacetedBrepWithVoids::type() { return Type::IfcFacetedBrepWithVoids; } Type::Enum IfcFacetedBrepWithVoids::Class() { return Type::IfcFacetedBrepWithVoids; } -IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcAbstractEntityPtr e) { if (!is(Type::IfcFacetedBrepWithVoids)) throw; entity = e; } +IfcFacetedBrepWithVoids::IfcFacetedBrepWithVoids(IfcAbstractEntityPtr e) { if (!is(Type::IfcFacetedBrepWithVoids)) throw; entity = e; } // IfcFailureConnectionCondition bool IfcFailureConnectionCondition::hasTensionFailureX() { return !entity->getArgument(1)->isNull(); } IfcForceMeasure IfcFailureConnectionCondition::TensionFailureX() { return *entity->getArgument(1); } @@ -5943,46 +5942,46 @@ IfcForceMeasure IfcFailureConnectionCondition::CompressionFailureZ() { return *e bool IfcFailureConnectionCondition::is(Type::Enum v) { return v == Type::IfcFailureConnectionCondition || IfcStructuralConnectionCondition::is(v); } Type::Enum IfcFailureConnectionCondition::type() { return Type::IfcFailureConnectionCondition; } Type::Enum IfcFailureConnectionCondition::Class() { return Type::IfcFailureConnectionCondition; } -IfcFailureConnectionCondition::IfcFailureConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcFailureConnectionCondition)) throw; entity = e; } +IfcFailureConnectionCondition::IfcFailureConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcFailureConnectionCondition)) throw; entity = e; } // IfcFanType IfcFanTypeEnum::IfcFanTypeEnum IfcFanType::PredefinedType() { return IfcFanTypeEnum::FromString(*entity->getArgument(9)); } bool IfcFanType::is(Type::Enum v) { return v == Type::IfcFanType || IfcFlowMovingDeviceType::is(v); } Type::Enum IfcFanType::type() { return Type::IfcFanType; } Type::Enum IfcFanType::Class() { return Type::IfcFanType; } -IfcFanType::IfcFanType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFanType)) throw; entity = e; } +IfcFanType::IfcFanType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFanType)) throw; entity = e; } // IfcFastener bool IfcFastener::is(Type::Enum v) { return v == Type::IfcFastener || IfcElementComponent::is(v); } Type::Enum IfcFastener::type() { return Type::IfcFastener; } Type::Enum IfcFastener::Class() { return Type::IfcFastener; } -IfcFastener::IfcFastener(IfcAbstractEntityPtr e) { if (!is(Type::IfcFastener)) throw; entity = e; } +IfcFastener::IfcFastener(IfcAbstractEntityPtr e) { if (!is(Type::IfcFastener)) throw; entity = e; } // IfcFastenerType bool IfcFastenerType::is(Type::Enum v) { return v == Type::IfcFastenerType || IfcElementComponentType::is(v); } Type::Enum IfcFastenerType::type() { return Type::IfcFastenerType; } Type::Enum IfcFastenerType::Class() { return Type::IfcFastenerType; } -IfcFastenerType::IfcFastenerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFastenerType)) throw; entity = e; } +IfcFastenerType::IfcFastenerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFastenerType)) throw; entity = e; } // IfcFeatureElement bool IfcFeatureElement::is(Type::Enum v) { return v == Type::IfcFeatureElement || IfcElement::is(v); } Type::Enum IfcFeatureElement::type() { return Type::IfcFeatureElement; } Type::Enum IfcFeatureElement::Class() { return Type::IfcFeatureElement; } -IfcFeatureElement::IfcFeatureElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElement)) throw; entity = e; } +IfcFeatureElement::IfcFeatureElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElement)) throw; entity = e; } // IfcFeatureElementAddition IfcRelProjectsElement::list IfcFeatureElementAddition::ProjectsElements() { RETURN_INVERSE(IfcRelProjectsElement) } bool IfcFeatureElementAddition::is(Type::Enum v) { return v == Type::IfcFeatureElementAddition || IfcFeatureElement::is(v); } Type::Enum IfcFeatureElementAddition::type() { return Type::IfcFeatureElementAddition; } Type::Enum IfcFeatureElementAddition::Class() { return Type::IfcFeatureElementAddition; } -IfcFeatureElementAddition::IfcFeatureElementAddition(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElementAddition)) throw; entity = e; } +IfcFeatureElementAddition::IfcFeatureElementAddition(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElementAddition)) throw; entity = e; } // IfcFeatureElementSubtraction IfcRelVoidsElement::list IfcFeatureElementSubtraction::VoidsElements() { RETURN_INVERSE(IfcRelVoidsElement) } bool IfcFeatureElementSubtraction::is(Type::Enum v) { return v == Type::IfcFeatureElementSubtraction || IfcFeatureElement::is(v); } Type::Enum IfcFeatureElementSubtraction::type() { return Type::IfcFeatureElementSubtraction; } Type::Enum IfcFeatureElementSubtraction::Class() { return Type::IfcFeatureElementSubtraction; } -IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElementSubtraction)) throw; entity = e; } +IfcFeatureElementSubtraction::IfcFeatureElementSubtraction(IfcAbstractEntityPtr e) { if (!is(Type::IfcFeatureElementSubtraction)) throw; entity = e; } // IfcFillAreaStyle SHARED_PTR< IfcTemplatedEntityList > IfcFillAreaStyle::FillStyles() { RETURN_AS_LIST(IfcAbstractSelect,1) } bool IfcFillAreaStyle::is(Type::Enum v) { return v == Type::IfcFillAreaStyle || IfcPresentationStyle::is(v); } Type::Enum IfcFillAreaStyle::type() { return Type::IfcFillAreaStyle; } Type::Enum IfcFillAreaStyle::Class() { return Type::IfcFillAreaStyle; } -IfcFillAreaStyle::IfcFillAreaStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyle)) throw; entity = e; } +IfcFillAreaStyle::IfcFillAreaStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyle)) throw; entity = e; } // IfcFillAreaStyleHatching SHARED_PTR IfcFillAreaStyleHatching::HatchLineAppearance() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcHatchLineDistanceSelect IfcFillAreaStyleHatching::StartOfNextHatchLine() { return *entity->getArgument(1); } @@ -5994,13 +5993,13 @@ IfcPlaneAngleMeasure IfcFillAreaStyleHatching::HatchLineAngle() { return *entity bool IfcFillAreaStyleHatching::is(Type::Enum v) { return v == Type::IfcFillAreaStyleHatching || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcFillAreaStyleHatching::type() { return Type::IfcFillAreaStyleHatching; } Type::Enum IfcFillAreaStyleHatching::Class() { return Type::IfcFillAreaStyleHatching; } -IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleHatching)) throw; entity = e; } +IfcFillAreaStyleHatching::IfcFillAreaStyleHatching(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleHatching)) throw; entity = e; } // IfcFillAreaStyleTileSymbolWithStyle SHARED_PTR IfcFillAreaStyleTileSymbolWithStyle::Symbol() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcFillAreaStyleTileSymbolWithStyle::is(Type::Enum v) { return v == Type::IfcFillAreaStyleTileSymbolWithStyle || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcFillAreaStyleTileSymbolWithStyle::type() { return Type::IfcFillAreaStyleTileSymbolWithStyle; } Type::Enum IfcFillAreaStyleTileSymbolWithStyle::Class() { return Type::IfcFillAreaStyleTileSymbolWithStyle; } -IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleTileSymbolWithStyle)) throw; entity = e; } +IfcFillAreaStyleTileSymbolWithStyle::IfcFillAreaStyleTileSymbolWithStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleTileSymbolWithStyle)) throw; entity = e; } // IfcFillAreaStyleTiles SHARED_PTR IfcFillAreaStyleTiles::TilingPattern() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcFillAreaStyleTiles::Tiles() { RETURN_AS_LIST(IfcAbstractSelect,1) } @@ -6008,101 +6007,101 @@ IfcPositiveRatioMeasure IfcFillAreaStyleTiles::TilingScale() { return *entity->g bool IfcFillAreaStyleTiles::is(Type::Enum v) { return v == Type::IfcFillAreaStyleTiles || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcFillAreaStyleTiles::type() { return Type::IfcFillAreaStyleTiles; } Type::Enum IfcFillAreaStyleTiles::Class() { return Type::IfcFillAreaStyleTiles; } -IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleTiles)) throw; entity = e; } +IfcFillAreaStyleTiles::IfcFillAreaStyleTiles(IfcAbstractEntityPtr e) { if (!is(Type::IfcFillAreaStyleTiles)) throw; entity = e; } // IfcFilterType IfcFilterTypeEnum::IfcFilterTypeEnum IfcFilterType::PredefinedType() { return IfcFilterTypeEnum::FromString(*entity->getArgument(9)); } bool IfcFilterType::is(Type::Enum v) { return v == Type::IfcFilterType || IfcFlowTreatmentDeviceType::is(v); } Type::Enum IfcFilterType::type() { return Type::IfcFilterType; } Type::Enum IfcFilterType::Class() { return Type::IfcFilterType; } -IfcFilterType::IfcFilterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFilterType)) throw; entity = e; } +IfcFilterType::IfcFilterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFilterType)) throw; entity = e; } // IfcFireSuppressionTerminalType IfcFireSuppressionTerminalTypeEnum::IfcFireSuppressionTerminalTypeEnum IfcFireSuppressionTerminalType::PredefinedType() { return IfcFireSuppressionTerminalTypeEnum::FromString(*entity->getArgument(9)); } bool IfcFireSuppressionTerminalType::is(Type::Enum v) { return v == Type::IfcFireSuppressionTerminalType || IfcFlowTerminalType::is(v); } Type::Enum IfcFireSuppressionTerminalType::type() { return Type::IfcFireSuppressionTerminalType; } Type::Enum IfcFireSuppressionTerminalType::Class() { return Type::IfcFireSuppressionTerminalType; } -IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFireSuppressionTerminalType)) throw; entity = e; } +IfcFireSuppressionTerminalType::IfcFireSuppressionTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFireSuppressionTerminalType)) throw; entity = e; } // IfcFlowController bool IfcFlowController::is(Type::Enum v) { return v == Type::IfcFlowController || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowController::type() { return Type::IfcFlowController; } Type::Enum IfcFlowController::Class() { return Type::IfcFlowController; } -IfcFlowController::IfcFlowController(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowController)) throw; entity = e; } +IfcFlowController::IfcFlowController(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowController)) throw; entity = e; } // IfcFlowControllerType bool IfcFlowControllerType::is(Type::Enum v) { return v == Type::IfcFlowControllerType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowControllerType::type() { return Type::IfcFlowControllerType; } Type::Enum IfcFlowControllerType::Class() { return Type::IfcFlowControllerType; } -IfcFlowControllerType::IfcFlowControllerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowControllerType)) throw; entity = e; } +IfcFlowControllerType::IfcFlowControllerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowControllerType)) throw; entity = e; } // IfcFlowFitting bool IfcFlowFitting::is(Type::Enum v) { return v == Type::IfcFlowFitting || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowFitting::type() { return Type::IfcFlowFitting; } Type::Enum IfcFlowFitting::Class() { return Type::IfcFlowFitting; } -IfcFlowFitting::IfcFlowFitting(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowFitting)) throw; entity = e; } +IfcFlowFitting::IfcFlowFitting(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowFitting)) throw; entity = e; } // IfcFlowFittingType bool IfcFlowFittingType::is(Type::Enum v) { return v == Type::IfcFlowFittingType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowFittingType::type() { return Type::IfcFlowFittingType; } Type::Enum IfcFlowFittingType::Class() { return Type::IfcFlowFittingType; } -IfcFlowFittingType::IfcFlowFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowFittingType)) throw; entity = e; } +IfcFlowFittingType::IfcFlowFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowFittingType)) throw; entity = e; } // IfcFlowInstrumentType IfcFlowInstrumentTypeEnum::IfcFlowInstrumentTypeEnum IfcFlowInstrumentType::PredefinedType() { return IfcFlowInstrumentTypeEnum::FromString(*entity->getArgument(9)); } bool IfcFlowInstrumentType::is(Type::Enum v) { return v == Type::IfcFlowInstrumentType || IfcDistributionControlElementType::is(v); } Type::Enum IfcFlowInstrumentType::type() { return Type::IfcFlowInstrumentType; } Type::Enum IfcFlowInstrumentType::Class() { return Type::IfcFlowInstrumentType; } -IfcFlowInstrumentType::IfcFlowInstrumentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowInstrumentType)) throw; entity = e; } +IfcFlowInstrumentType::IfcFlowInstrumentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowInstrumentType)) throw; entity = e; } // IfcFlowMeterType IfcFlowMeterTypeEnum::IfcFlowMeterTypeEnum IfcFlowMeterType::PredefinedType() { return IfcFlowMeterTypeEnum::FromString(*entity->getArgument(9)); } bool IfcFlowMeterType::is(Type::Enum v) { return v == Type::IfcFlowMeterType || IfcFlowControllerType::is(v); } Type::Enum IfcFlowMeterType::type() { return Type::IfcFlowMeterType; } Type::Enum IfcFlowMeterType::Class() { return Type::IfcFlowMeterType; } -IfcFlowMeterType::IfcFlowMeterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMeterType)) throw; entity = e; } +IfcFlowMeterType::IfcFlowMeterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMeterType)) throw; entity = e; } // IfcFlowMovingDevice bool IfcFlowMovingDevice::is(Type::Enum v) { return v == Type::IfcFlowMovingDevice || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowMovingDevice::type() { return Type::IfcFlowMovingDevice; } Type::Enum IfcFlowMovingDevice::Class() { return Type::IfcFlowMovingDevice; } -IfcFlowMovingDevice::IfcFlowMovingDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMovingDevice)) throw; entity = e; } +IfcFlowMovingDevice::IfcFlowMovingDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMovingDevice)) throw; entity = e; } // IfcFlowMovingDeviceType bool IfcFlowMovingDeviceType::is(Type::Enum v) { return v == Type::IfcFlowMovingDeviceType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowMovingDeviceType::type() { return Type::IfcFlowMovingDeviceType; } Type::Enum IfcFlowMovingDeviceType::Class() { return Type::IfcFlowMovingDeviceType; } -IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMovingDeviceType)) throw; entity = e; } +IfcFlowMovingDeviceType::IfcFlowMovingDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowMovingDeviceType)) throw; entity = e; } // IfcFlowSegment bool IfcFlowSegment::is(Type::Enum v) { return v == Type::IfcFlowSegment || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowSegment::type() { return Type::IfcFlowSegment; } Type::Enum IfcFlowSegment::Class() { return Type::IfcFlowSegment; } -IfcFlowSegment::IfcFlowSegment(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowSegment)) throw; entity = e; } +IfcFlowSegment::IfcFlowSegment(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowSegment)) throw; entity = e; } // IfcFlowSegmentType bool IfcFlowSegmentType::is(Type::Enum v) { return v == Type::IfcFlowSegmentType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowSegmentType::type() { return Type::IfcFlowSegmentType; } Type::Enum IfcFlowSegmentType::Class() { return Type::IfcFlowSegmentType; } -IfcFlowSegmentType::IfcFlowSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowSegmentType)) throw; entity = e; } +IfcFlowSegmentType::IfcFlowSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowSegmentType)) throw; entity = e; } // IfcFlowStorageDevice bool IfcFlowStorageDevice::is(Type::Enum v) { return v == Type::IfcFlowStorageDevice || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowStorageDevice::type() { return Type::IfcFlowStorageDevice; } Type::Enum IfcFlowStorageDevice::Class() { return Type::IfcFlowStorageDevice; } -IfcFlowStorageDevice::IfcFlowStorageDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowStorageDevice)) throw; entity = e; } +IfcFlowStorageDevice::IfcFlowStorageDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowStorageDevice)) throw; entity = e; } // IfcFlowStorageDeviceType bool IfcFlowStorageDeviceType::is(Type::Enum v) { return v == Type::IfcFlowStorageDeviceType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowStorageDeviceType::type() { return Type::IfcFlowStorageDeviceType; } Type::Enum IfcFlowStorageDeviceType::Class() { return Type::IfcFlowStorageDeviceType; } -IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowStorageDeviceType)) throw; entity = e; } +IfcFlowStorageDeviceType::IfcFlowStorageDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowStorageDeviceType)) throw; entity = e; } // IfcFlowTerminal bool IfcFlowTerminal::is(Type::Enum v) { return v == Type::IfcFlowTerminal || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowTerminal::type() { return Type::IfcFlowTerminal; } Type::Enum IfcFlowTerminal::Class() { return Type::IfcFlowTerminal; } -IfcFlowTerminal::IfcFlowTerminal(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTerminal)) throw; entity = e; } +IfcFlowTerminal::IfcFlowTerminal(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTerminal)) throw; entity = e; } // IfcFlowTerminalType bool IfcFlowTerminalType::is(Type::Enum v) { return v == Type::IfcFlowTerminalType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowTerminalType::type() { return Type::IfcFlowTerminalType; } Type::Enum IfcFlowTerminalType::Class() { return Type::IfcFlowTerminalType; } -IfcFlowTerminalType::IfcFlowTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTerminalType)) throw; entity = e; } +IfcFlowTerminalType::IfcFlowTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTerminalType)) throw; entity = e; } // IfcFlowTreatmentDevice bool IfcFlowTreatmentDevice::is(Type::Enum v) { return v == Type::IfcFlowTreatmentDevice || IfcDistributionFlowElement::is(v); } Type::Enum IfcFlowTreatmentDevice::type() { return Type::IfcFlowTreatmentDevice; } Type::Enum IfcFlowTreatmentDevice::Class() { return Type::IfcFlowTreatmentDevice; } -IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTreatmentDevice)) throw; entity = e; } +IfcFlowTreatmentDevice::IfcFlowTreatmentDevice(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTreatmentDevice)) throw; entity = e; } // IfcFlowTreatmentDeviceType bool IfcFlowTreatmentDeviceType::is(Type::Enum v) { return v == Type::IfcFlowTreatmentDeviceType || IfcDistributionFlowElementType::is(v); } Type::Enum IfcFlowTreatmentDeviceType::type() { return Type::IfcFlowTreatmentDeviceType; } Type::Enum IfcFlowTreatmentDeviceType::Class() { return Type::IfcFlowTreatmentDeviceType; } -IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTreatmentDeviceType)) throw; entity = e; } +IfcFlowTreatmentDeviceType::IfcFlowTreatmentDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFlowTreatmentDeviceType)) throw; entity = e; } // IfcFluidFlowProperties IfcPropertySourceEnum::IfcPropertySourceEnum IfcFluidFlowProperties::PropertySource() { return IfcPropertySourceEnum::FromString(*entity->getArgument(4)); } bool IfcFluidFlowProperties::hasFlowConditionTimeSeries() { return !entity->getArgument(5)->isNull(); } @@ -6135,13 +6134,13 @@ IfcPressureMeasure IfcFluidFlowProperties::PressureSingleValue() { return *entit bool IfcFluidFlowProperties::is(Type::Enum v) { return v == Type::IfcFluidFlowProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcFluidFlowProperties::type() { return Type::IfcFluidFlowProperties; } Type::Enum IfcFluidFlowProperties::Class() { return Type::IfcFluidFlowProperties; } -IfcFluidFlowProperties::IfcFluidFlowProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcFluidFlowProperties)) throw; entity = e; } +IfcFluidFlowProperties::IfcFluidFlowProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcFluidFlowProperties)) throw; entity = e; } // IfcFooting IfcFootingTypeEnum::IfcFootingTypeEnum IfcFooting::PredefinedType() { return IfcFootingTypeEnum::FromString(*entity->getArgument(8)); } bool IfcFooting::is(Type::Enum v) { return v == Type::IfcFooting || IfcBuildingElement::is(v); } Type::Enum IfcFooting::type() { return Type::IfcFooting; } Type::Enum IfcFooting::Class() { return Type::IfcFooting; } -IfcFooting::IfcFooting(IfcAbstractEntityPtr e) { if (!is(Type::IfcFooting)) throw; entity = e; } +IfcFooting::IfcFooting(IfcAbstractEntityPtr e) { if (!is(Type::IfcFooting)) throw; entity = e; } // IfcFuelProperties bool IfcFuelProperties::hasCombustionTemperature() { return !entity->getArgument(1)->isNull(); } IfcThermodynamicTemperatureMeasure IfcFuelProperties::CombustionTemperature() { return *entity->getArgument(1); } @@ -6154,34 +6153,34 @@ IfcHeatingValueMeasure IfcFuelProperties::HigherHeatingValue() { return *entity- bool IfcFuelProperties::is(Type::Enum v) { return v == Type::IfcFuelProperties || IfcMaterialProperties::is(v); } Type::Enum IfcFuelProperties::type() { return Type::IfcFuelProperties; } Type::Enum IfcFuelProperties::Class() { return Type::IfcFuelProperties; } -IfcFuelProperties::IfcFuelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcFuelProperties)) throw; entity = e; } +IfcFuelProperties::IfcFuelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcFuelProperties)) throw; entity = e; } // IfcFurnishingElement bool IfcFurnishingElement::is(Type::Enum v) { return v == Type::IfcFurnishingElement || IfcElement::is(v); } Type::Enum IfcFurnishingElement::type() { return Type::IfcFurnishingElement; } Type::Enum IfcFurnishingElement::Class() { return Type::IfcFurnishingElement; } -IfcFurnishingElement::IfcFurnishingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnishingElement)) throw; entity = e; } +IfcFurnishingElement::IfcFurnishingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnishingElement)) throw; entity = e; } // IfcFurnishingElementType bool IfcFurnishingElementType::is(Type::Enum v) { return v == Type::IfcFurnishingElementType || IfcElementType::is(v); } Type::Enum IfcFurnishingElementType::type() { return Type::IfcFurnishingElementType; } Type::Enum IfcFurnishingElementType::Class() { return Type::IfcFurnishingElementType; } -IfcFurnishingElementType::IfcFurnishingElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnishingElementType)) throw; entity = e; } +IfcFurnishingElementType::IfcFurnishingElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnishingElementType)) throw; entity = e; } // IfcFurnitureStandard bool IfcFurnitureStandard::is(Type::Enum v) { return v == Type::IfcFurnitureStandard || IfcControl::is(v); } Type::Enum IfcFurnitureStandard::type() { return Type::IfcFurnitureStandard; } Type::Enum IfcFurnitureStandard::Class() { return Type::IfcFurnitureStandard; } -IfcFurnitureStandard::IfcFurnitureStandard(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnitureStandard)) throw; entity = e; } +IfcFurnitureStandard::IfcFurnitureStandard(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnitureStandard)) throw; entity = e; } // IfcFurnitureType IfcAssemblyPlaceEnum::IfcAssemblyPlaceEnum IfcFurnitureType::AssemblyPlace() { return IfcAssemblyPlaceEnum::FromString(*entity->getArgument(9)); } bool IfcFurnitureType::is(Type::Enum v) { return v == Type::IfcFurnitureType || IfcFurnishingElementType::is(v); } Type::Enum IfcFurnitureType::type() { return Type::IfcFurnitureType; } Type::Enum IfcFurnitureType::Class() { return Type::IfcFurnitureType; } -IfcFurnitureType::IfcFurnitureType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnitureType)) throw; entity = e; } +IfcFurnitureType::IfcFurnitureType(IfcAbstractEntityPtr e) { if (!is(Type::IfcFurnitureType)) throw; entity = e; } // IfcGasTerminalType IfcGasTerminalTypeEnum::IfcGasTerminalTypeEnum IfcGasTerminalType::PredefinedType() { return IfcGasTerminalTypeEnum::FromString(*entity->getArgument(9)); } bool IfcGasTerminalType::is(Type::Enum v) { return v == Type::IfcGasTerminalType || IfcFlowTerminalType::is(v); } Type::Enum IfcGasTerminalType::type() { return Type::IfcGasTerminalType; } Type::Enum IfcGasTerminalType::Class() { return Type::IfcGasTerminalType; } -IfcGasTerminalType::IfcGasTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcGasTerminalType)) throw; entity = e; } +IfcGasTerminalType::IfcGasTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcGasTerminalType)) throw; entity = e; } // IfcGeneralMaterialProperties bool IfcGeneralMaterialProperties::hasMolecularWeight() { return !entity->getArgument(1)->isNull(); } IfcMolecularWeightMeasure IfcGeneralMaterialProperties::MolecularWeight() { return *entity->getArgument(1); } @@ -6192,7 +6191,7 @@ IfcMassDensityMeasure IfcGeneralMaterialProperties::MassDensity() { return *enti bool IfcGeneralMaterialProperties::is(Type::Enum v) { return v == Type::IfcGeneralMaterialProperties || IfcMaterialProperties::is(v); } Type::Enum IfcGeneralMaterialProperties::type() { return Type::IfcGeneralMaterialProperties; } Type::Enum IfcGeneralMaterialProperties::Class() { return Type::IfcGeneralMaterialProperties; } -IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeneralMaterialProperties)) throw; entity = e; } +IfcGeneralMaterialProperties::IfcGeneralMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeneralMaterialProperties)) throw; entity = e; } // IfcGeneralProfileProperties bool IfcGeneralProfileProperties::hasPhysicalWeight() { return !entity->getArgument(2)->isNull(); } IfcMassPerLengthMeasure IfcGeneralProfileProperties::PhysicalWeight() { return *entity->getArgument(2); } @@ -6207,12 +6206,12 @@ IfcAreaMeasure IfcGeneralProfileProperties::CrossSectionArea() { return *entity- bool IfcGeneralProfileProperties::is(Type::Enum v) { return v == Type::IfcGeneralProfileProperties || IfcProfileProperties::is(v); } Type::Enum IfcGeneralProfileProperties::type() { return Type::IfcGeneralProfileProperties; } Type::Enum IfcGeneralProfileProperties::Class() { return Type::IfcGeneralProfileProperties; } -IfcGeneralProfileProperties::IfcGeneralProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeneralProfileProperties)) throw; entity = e; } +IfcGeneralProfileProperties::IfcGeneralProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeneralProfileProperties)) throw; entity = e; } // IfcGeometricCurveSet bool IfcGeometricCurveSet::is(Type::Enum v) { return v == Type::IfcGeometricCurveSet || IfcGeometricSet::is(v); } Type::Enum IfcGeometricCurveSet::type() { return Type::IfcGeometricCurveSet; } Type::Enum IfcGeometricCurveSet::Class() { return Type::IfcGeometricCurveSet; } -IfcGeometricCurveSet::IfcGeometricCurveSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricCurveSet)) throw; entity = e; } +IfcGeometricCurveSet::IfcGeometricCurveSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricCurveSet)) throw; entity = e; } // IfcGeometricRepresentationContext IfcDimensionCount IfcGeometricRepresentationContext::CoordinateSpaceDimension() { return *entity->getArgument(2); } bool IfcGeometricRepresentationContext::hasPrecision() { return !entity->getArgument(3)->isNull(); } @@ -6224,12 +6223,12 @@ IfcGeometricRepresentationSubContext::list IfcGeometricRepresentationContext::Ha bool IfcGeometricRepresentationContext::is(Type::Enum v) { return v == Type::IfcGeometricRepresentationContext || IfcRepresentationContext::is(v); } Type::Enum IfcGeometricRepresentationContext::type() { return Type::IfcGeometricRepresentationContext; } Type::Enum IfcGeometricRepresentationContext::Class() { return Type::IfcGeometricRepresentationContext; } -IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationContext)) throw; entity = e; } +IfcGeometricRepresentationContext::IfcGeometricRepresentationContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationContext)) throw; entity = e; } // IfcGeometricRepresentationItem bool IfcGeometricRepresentationItem::is(Type::Enum v) { return v == Type::IfcGeometricRepresentationItem || IfcRepresentationItem::is(v); } Type::Enum IfcGeometricRepresentationItem::type() { return Type::IfcGeometricRepresentationItem; } Type::Enum IfcGeometricRepresentationItem::Class() { return Type::IfcGeometricRepresentationItem; } -IfcGeometricRepresentationItem::IfcGeometricRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationItem)) throw; entity = e; } +IfcGeometricRepresentationItem::IfcGeometricRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationItem)) throw; entity = e; } // IfcGeometricRepresentationSubContext SHARED_PTR IfcGeometricRepresentationSubContext::ParentContext() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcGeometricRepresentationSubContext::hasTargetScale() { return !entity->getArgument(7)->isNull(); } @@ -6240,13 +6239,13 @@ IfcLabel IfcGeometricRepresentationSubContext::UserDefinedTargetView() { return bool IfcGeometricRepresentationSubContext::is(Type::Enum v) { return v == Type::IfcGeometricRepresentationSubContext || IfcGeometricRepresentationContext::is(v); } Type::Enum IfcGeometricRepresentationSubContext::type() { return Type::IfcGeometricRepresentationSubContext; } Type::Enum IfcGeometricRepresentationSubContext::Class() { return Type::IfcGeometricRepresentationSubContext; } -IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationSubContext)) throw; entity = e; } +IfcGeometricRepresentationSubContext::IfcGeometricRepresentationSubContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricRepresentationSubContext)) throw; entity = e; } // IfcGeometricSet SHARED_PTR< IfcTemplatedEntityList > IfcGeometricSet::Elements() { RETURN_AS_LIST(IfcAbstractSelect,0) } bool IfcGeometricSet::is(Type::Enum v) { return v == Type::IfcGeometricSet || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcGeometricSet::type() { return Type::IfcGeometricSet; } Type::Enum IfcGeometricSet::Class() { return Type::IfcGeometricSet; } -IfcGeometricSet::IfcGeometricSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricSet)) throw; entity = e; } +IfcGeometricSet::IfcGeometricSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcGeometricSet)) throw; entity = e; } // IfcGrid SHARED_PTR< IfcTemplatedEntityList > IfcGrid::UAxes() { RETURN_AS_LIST(IfcGridAxis,7) } SHARED_PTR< IfcTemplatedEntityList > IfcGrid::VAxes() { RETURN_AS_LIST(IfcGridAxis,8) } @@ -6256,7 +6255,7 @@ IfcRelContainedInSpatialStructure::list IfcGrid::ContainedInStructure() { RETURN bool IfcGrid::is(Type::Enum v) { return v == Type::IfcGrid || IfcProduct::is(v); } Type::Enum IfcGrid::type() { return Type::IfcGrid; } Type::Enum IfcGrid::Class() { return Type::IfcGrid; } -IfcGrid::IfcGrid(IfcAbstractEntityPtr e) { if (!is(Type::IfcGrid)) throw; entity = e; } +IfcGrid::IfcGrid(IfcAbstractEntityPtr e) { if (!is(Type::IfcGrid)) throw; entity = e; } // IfcGridAxis bool IfcGridAxis::hasAxisTag() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcGridAxis::AxisTag() { return *entity->getArgument(0); } @@ -6269,7 +6268,7 @@ IfcVirtualGridIntersection::list IfcGridAxis::HasIntersections() { RETURN_INVERS bool IfcGridAxis::is(Type::Enum v) { return v == Type::IfcGridAxis; } Type::Enum IfcGridAxis::type() { return Type::IfcGridAxis; } Type::Enum IfcGridAxis::Class() { return Type::IfcGridAxis; } -IfcGridAxis::IfcGridAxis(IfcAbstractEntityPtr e) { if (!is(Type::IfcGridAxis)) throw; entity = e; } +IfcGridAxis::IfcGridAxis(IfcAbstractEntityPtr e) { if (!is(Type::IfcGridAxis)) throw; entity = e; } // IfcGridPlacement SHARED_PTR IfcGridPlacement::PlacementLocation() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcGridPlacement::hasPlacementRefDirection() { return !entity->getArgument(1)->isNull(); } @@ -6277,32 +6276,32 @@ SHARED_PTR IfcGridPlacement::PlacementRefDirection() bool IfcGridPlacement::is(Type::Enum v) { return v == Type::IfcGridPlacement || IfcObjectPlacement::is(v); } Type::Enum IfcGridPlacement::type() { return Type::IfcGridPlacement; } Type::Enum IfcGridPlacement::Class() { return Type::IfcGridPlacement; } -IfcGridPlacement::IfcGridPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcGridPlacement)) throw; entity = e; } +IfcGridPlacement::IfcGridPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcGridPlacement)) throw; entity = e; } // IfcGroup IfcRelAssignsToGroup::list IfcGroup::IsGroupedBy() { RETURN_INVERSE(IfcRelAssignsToGroup) } bool IfcGroup::is(Type::Enum v) { return v == Type::IfcGroup || IfcObject::is(v); } Type::Enum IfcGroup::type() { return Type::IfcGroup; } Type::Enum IfcGroup::Class() { return Type::IfcGroup; } -IfcGroup::IfcGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcGroup)) throw; entity = e; } +IfcGroup::IfcGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcGroup)) throw; entity = e; } // IfcHalfSpaceSolid SHARED_PTR IfcHalfSpaceSolid::BaseSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcHalfSpaceSolid::AgreementFlag() { return *entity->getArgument(1); } bool IfcHalfSpaceSolid::is(Type::Enum v) { return v == Type::IfcHalfSpaceSolid || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcHalfSpaceSolid::type() { return Type::IfcHalfSpaceSolid; } Type::Enum IfcHalfSpaceSolid::Class() { return Type::IfcHalfSpaceSolid; } -IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcHalfSpaceSolid)) throw; entity = e; } +IfcHalfSpaceSolid::IfcHalfSpaceSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcHalfSpaceSolid)) throw; entity = e; } // IfcHeatExchangerType IfcHeatExchangerTypeEnum::IfcHeatExchangerTypeEnum IfcHeatExchangerType::PredefinedType() { return IfcHeatExchangerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcHeatExchangerType::is(Type::Enum v) { return v == Type::IfcHeatExchangerType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcHeatExchangerType::type() { return Type::IfcHeatExchangerType; } Type::Enum IfcHeatExchangerType::Class() { return Type::IfcHeatExchangerType; } -IfcHeatExchangerType::IfcHeatExchangerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcHeatExchangerType)) throw; entity = e; } +IfcHeatExchangerType::IfcHeatExchangerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcHeatExchangerType)) throw; entity = e; } // IfcHumidifierType IfcHumidifierTypeEnum::IfcHumidifierTypeEnum IfcHumidifierType::PredefinedType() { return IfcHumidifierTypeEnum::FromString(*entity->getArgument(9)); } bool IfcHumidifierType::is(Type::Enum v) { return v == Type::IfcHumidifierType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcHumidifierType::type() { return Type::IfcHumidifierType; } Type::Enum IfcHumidifierType::Class() { return Type::IfcHumidifierType; } -IfcHumidifierType::IfcHumidifierType(IfcAbstractEntityPtr e) { if (!is(Type::IfcHumidifierType)) throw; entity = e; } +IfcHumidifierType::IfcHumidifierType(IfcAbstractEntityPtr e) { if (!is(Type::IfcHumidifierType)) throw; entity = e; } // IfcHygroscopicMaterialProperties bool IfcHygroscopicMaterialProperties::hasUpperVaporResistanceFactor() { return !entity->getArgument(1)->isNull(); } IfcPositiveRatioMeasure IfcHygroscopicMaterialProperties::UpperVaporResistanceFactor() { return *entity->getArgument(1); } @@ -6317,7 +6316,7 @@ IfcMoistureDiffusivityMeasure IfcHygroscopicMaterialProperties::MoistureDiffusiv bool IfcHygroscopicMaterialProperties::is(Type::Enum v) { return v == Type::IfcHygroscopicMaterialProperties || IfcMaterialProperties::is(v); } Type::Enum IfcHygroscopicMaterialProperties::type() { return Type::IfcHygroscopicMaterialProperties; } Type::Enum IfcHygroscopicMaterialProperties::Class() { return Type::IfcHygroscopicMaterialProperties; } -IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcHygroscopicMaterialProperties)) throw; entity = e; } +IfcHygroscopicMaterialProperties::IfcHygroscopicMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcHygroscopicMaterialProperties)) throw; entity = e; } // IfcIShapeProfileDef IfcPositiveLengthMeasure IfcIShapeProfileDef::OverallWidth() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcIShapeProfileDef::OverallDepth() { return *entity->getArgument(4); } @@ -6328,13 +6327,13 @@ IfcPositiveLengthMeasure IfcIShapeProfileDef::FilletRadius() { return *entity->g bool IfcIShapeProfileDef::is(Type::Enum v) { return v == Type::IfcIShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcIShapeProfileDef::type() { return Type::IfcIShapeProfileDef; } Type::Enum IfcIShapeProfileDef::Class() { return Type::IfcIShapeProfileDef; } -IfcIShapeProfileDef::IfcIShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcIShapeProfileDef)) throw; entity = e; } +IfcIShapeProfileDef::IfcIShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcIShapeProfileDef)) throw; entity = e; } // IfcImageTexture IfcIdentifier IfcImageTexture::UrlReference() { return *entity->getArgument(4); } bool IfcImageTexture::is(Type::Enum v) { return v == Type::IfcImageTexture || IfcSurfaceTexture::is(v); } Type::Enum IfcImageTexture::type() { return Type::IfcImageTexture; } Type::Enum IfcImageTexture::Class() { return Type::IfcImageTexture; } -IfcImageTexture::IfcImageTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcImageTexture)) throw; entity = e; } +IfcImageTexture::IfcImageTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcImageTexture)) throw; entity = e; } // IfcInventory IfcInventoryTypeEnum::IfcInventoryTypeEnum IfcInventory::InventoryType() { return IfcInventoryTypeEnum::FromString(*entity->getArgument(5)); } IfcActorSelect IfcInventory::Jurisdiction() { return *entity->getArgument(6); } @@ -6347,26 +6346,26 @@ SHARED_PTR IfcInventory::OriginalValue() { return reinterpret_poin bool IfcInventory::is(Type::Enum v) { return v == Type::IfcInventory || IfcGroup::is(v); } Type::Enum IfcInventory::type() { return Type::IfcInventory; } Type::Enum IfcInventory::Class() { return Type::IfcInventory; } -IfcInventory::IfcInventory(IfcAbstractEntityPtr e) { if (!is(Type::IfcInventory)) throw; entity = e; } +IfcInventory::IfcInventory(IfcAbstractEntityPtr e) { if (!is(Type::IfcInventory)) throw; entity = e; } // IfcIrregularTimeSeries SHARED_PTR< IfcTemplatedEntityList > IfcIrregularTimeSeries::Values() { RETURN_AS_LIST(IfcIrregularTimeSeriesValue,8) } bool IfcIrregularTimeSeries::is(Type::Enum v) { return v == Type::IfcIrregularTimeSeries || IfcTimeSeries::is(v); } Type::Enum IfcIrregularTimeSeries::type() { return Type::IfcIrregularTimeSeries; } Type::Enum IfcIrregularTimeSeries::Class() { return Type::IfcIrregularTimeSeries; } -IfcIrregularTimeSeries::IfcIrregularTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcIrregularTimeSeries)) throw; entity = e; } +IfcIrregularTimeSeries::IfcIrregularTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcIrregularTimeSeries)) throw; entity = e; } // IfcIrregularTimeSeriesValue IfcDateTimeSelect IfcIrregularTimeSeriesValue::TimeStamp() { return *entity->getArgument(0); } SHARED_PTR< IfcTemplatedEntityList > IfcIrregularTimeSeriesValue::ListValues() { RETURN_AS_LIST(IfcAbstractSelect,1) } bool IfcIrregularTimeSeriesValue::is(Type::Enum v) { return v == Type::IfcIrregularTimeSeriesValue; } Type::Enum IfcIrregularTimeSeriesValue::type() { return Type::IfcIrregularTimeSeriesValue; } Type::Enum IfcIrregularTimeSeriesValue::Class() { return Type::IfcIrregularTimeSeriesValue; } -IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcIrregularTimeSeriesValue)) throw; entity = e; } +IfcIrregularTimeSeriesValue::IfcIrregularTimeSeriesValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcIrregularTimeSeriesValue)) throw; entity = e; } // IfcJunctionBoxType IfcJunctionBoxTypeEnum::IfcJunctionBoxTypeEnum IfcJunctionBoxType::PredefinedType() { return IfcJunctionBoxTypeEnum::FromString(*entity->getArgument(9)); } bool IfcJunctionBoxType::is(Type::Enum v) { return v == Type::IfcJunctionBoxType || IfcFlowFittingType::is(v); } Type::Enum IfcJunctionBoxType::type() { return Type::IfcJunctionBoxType; } Type::Enum IfcJunctionBoxType::Class() { return Type::IfcJunctionBoxType; } -IfcJunctionBoxType::IfcJunctionBoxType(IfcAbstractEntityPtr e) { if (!is(Type::IfcJunctionBoxType)) throw; entity = e; } +IfcJunctionBoxType::IfcJunctionBoxType(IfcAbstractEntityPtr e) { if (!is(Type::IfcJunctionBoxType)) throw; entity = e; } // IfcLShapeProfileDef IfcPositiveLengthMeasure IfcLShapeProfileDef::Depth() { return *entity->getArgument(3); } bool IfcLShapeProfileDef::hasWidth() { return !entity->getArgument(4)->isNull(); } @@ -6385,20 +6384,20 @@ IfcPositiveLengthMeasure IfcLShapeProfileDef::CentreOfGravityInY() { return *ent bool IfcLShapeProfileDef::is(Type::Enum v) { return v == Type::IfcLShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcLShapeProfileDef::type() { return Type::IfcLShapeProfileDef; } Type::Enum IfcLShapeProfileDef::Class() { return Type::IfcLShapeProfileDef; } -IfcLShapeProfileDef::IfcLShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcLShapeProfileDef)) throw; entity = e; } +IfcLShapeProfileDef::IfcLShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcLShapeProfileDef)) throw; entity = e; } // IfcLaborResource bool IfcLaborResource::hasSkillSet() { return !entity->getArgument(9)->isNull(); } IfcText IfcLaborResource::SkillSet() { return *entity->getArgument(9); } bool IfcLaborResource::is(Type::Enum v) { return v == Type::IfcLaborResource || IfcConstructionResource::is(v); } Type::Enum IfcLaborResource::type() { return Type::IfcLaborResource; } Type::Enum IfcLaborResource::Class() { return Type::IfcLaborResource; } -IfcLaborResource::IfcLaborResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcLaborResource)) throw; entity = e; } +IfcLaborResource::IfcLaborResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcLaborResource)) throw; entity = e; } // IfcLampType IfcLampTypeEnum::IfcLampTypeEnum IfcLampType::PredefinedType() { return IfcLampTypeEnum::FromString(*entity->getArgument(9)); } bool IfcLampType::is(Type::Enum v) { return v == Type::IfcLampType || IfcFlowTerminalType::is(v); } Type::Enum IfcLampType::type() { return Type::IfcLampType; } Type::Enum IfcLampType::Class() { return Type::IfcLampType; } -IfcLampType::IfcLampType(IfcAbstractEntityPtr e) { if (!is(Type::IfcLampType)) throw; entity = e; } +IfcLampType::IfcLampType(IfcAbstractEntityPtr e) { if (!is(Type::IfcLampType)) throw; entity = e; } // IfcLibraryInformation IfcLabel IfcLibraryInformation::Name() { return *entity->getArgument(0); } bool IfcLibraryInformation::hasVersion() { return !entity->getArgument(1)->isNull(); } @@ -6412,34 +6411,34 @@ SHARED_PTR< IfcTemplatedEntityList > IfcLibraryInformation: bool IfcLibraryInformation::is(Type::Enum v) { return v == Type::IfcLibraryInformation; } Type::Enum IfcLibraryInformation::type() { return Type::IfcLibraryInformation; } Type::Enum IfcLibraryInformation::Class() { return Type::IfcLibraryInformation; } -IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntityPtr e) { if (!is(Type::IfcLibraryInformation)) throw; entity = e; } +IfcLibraryInformation::IfcLibraryInformation(IfcAbstractEntityPtr e) { if (!is(Type::IfcLibraryInformation)) throw; entity = e; } // IfcLibraryReference IfcLibraryInformation::list IfcLibraryReference::ReferenceIntoLibrary() { RETURN_INVERSE(IfcLibraryInformation) } bool IfcLibraryReference::is(Type::Enum v) { return v == Type::IfcLibraryReference || IfcExternalReference::is(v); } Type::Enum IfcLibraryReference::type() { return Type::IfcLibraryReference; } Type::Enum IfcLibraryReference::Class() { return Type::IfcLibraryReference; } -IfcLibraryReference::IfcLibraryReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcLibraryReference)) throw; entity = e; } +IfcLibraryReference::IfcLibraryReference(IfcAbstractEntityPtr e) { if (!is(Type::IfcLibraryReference)) throw; entity = e; } // IfcLightDistributionData IfcPlaneAngleMeasure IfcLightDistributionData::MainPlaneAngle() { return *entity->getArgument(0); } -std::vector IfcLightDistributionData::SecondaryPlaneAngle() { return *entity->getArgument(1); } -std::vector IfcLightDistributionData::LuminousIntensity() { return *entity->getArgument(2); } +std::vector /*[1:?]*/ IfcLightDistributionData::SecondaryPlaneAngle() { return *entity->getArgument(1); } +std::vector /*[1:?]*/ IfcLightDistributionData::LuminousIntensity() { return *entity->getArgument(2); } bool IfcLightDistributionData::is(Type::Enum v) { return v == Type::IfcLightDistributionData; } Type::Enum IfcLightDistributionData::type() { return Type::IfcLightDistributionData; } Type::Enum IfcLightDistributionData::Class() { return Type::IfcLightDistributionData; } -IfcLightDistributionData::IfcLightDistributionData(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightDistributionData)) throw; entity = e; } +IfcLightDistributionData::IfcLightDistributionData(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightDistributionData)) throw; entity = e; } // IfcLightFixtureType IfcLightFixtureTypeEnum::IfcLightFixtureTypeEnum IfcLightFixtureType::PredefinedType() { return IfcLightFixtureTypeEnum::FromString(*entity->getArgument(9)); } bool IfcLightFixtureType::is(Type::Enum v) { return v == Type::IfcLightFixtureType || IfcFlowTerminalType::is(v); } Type::Enum IfcLightFixtureType::type() { return Type::IfcLightFixtureType; } Type::Enum IfcLightFixtureType::Class() { return Type::IfcLightFixtureType; } -IfcLightFixtureType::IfcLightFixtureType(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightFixtureType)) throw; entity = e; } +IfcLightFixtureType::IfcLightFixtureType(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightFixtureType)) throw; entity = e; } // IfcLightIntensityDistribution IfcLightDistributionCurveEnum::IfcLightDistributionCurveEnum IfcLightIntensityDistribution::LightDistributionCurve() { return IfcLightDistributionCurveEnum::FromString(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcLightIntensityDistribution::DistributionData() { RETURN_AS_LIST(IfcLightDistributionData,1) } bool IfcLightIntensityDistribution::is(Type::Enum v) { return v == Type::IfcLightIntensityDistribution; } Type::Enum IfcLightIntensityDistribution::type() { return Type::IfcLightIntensityDistribution; } Type::Enum IfcLightIntensityDistribution::Class() { return Type::IfcLightIntensityDistribution; } -IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightIntensityDistribution)) throw; entity = e; } +IfcLightIntensityDistribution::IfcLightIntensityDistribution(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightIntensityDistribution)) throw; entity = e; } // IfcLightSource bool IfcLightSource::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcLightSource::Name() { return *entity->getArgument(0); } @@ -6451,18 +6450,18 @@ IfcNormalisedRatioMeasure IfcLightSource::Intensity() { return *entity->getArgum bool IfcLightSource::is(Type::Enum v) { return v == Type::IfcLightSource || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcLightSource::type() { return Type::IfcLightSource; } Type::Enum IfcLightSource::Class() { return Type::IfcLightSource; } -IfcLightSource::IfcLightSource(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSource)) throw; entity = e; } +IfcLightSource::IfcLightSource(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSource)) throw; entity = e; } // IfcLightSourceAmbient bool IfcLightSourceAmbient::is(Type::Enum v) { return v == Type::IfcLightSourceAmbient || IfcLightSource::is(v); } Type::Enum IfcLightSourceAmbient::type() { return Type::IfcLightSourceAmbient; } Type::Enum IfcLightSourceAmbient::Class() { return Type::IfcLightSourceAmbient; } -IfcLightSourceAmbient::IfcLightSourceAmbient(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceAmbient)) throw; entity = e; } +IfcLightSourceAmbient::IfcLightSourceAmbient(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceAmbient)) throw; entity = e; } // IfcLightSourceDirectional SHARED_PTR IfcLightSourceDirectional::Orientation() { return reinterpret_pointer_cast(*entity->getArgument(4)); } bool IfcLightSourceDirectional::is(Type::Enum v) { return v == Type::IfcLightSourceDirectional || IfcLightSource::is(v); } Type::Enum IfcLightSourceDirectional::type() { return Type::IfcLightSourceDirectional; } Type::Enum IfcLightSourceDirectional::Class() { return Type::IfcLightSourceDirectional; } -IfcLightSourceDirectional::IfcLightSourceDirectional(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceDirectional)) throw; entity = e; } +IfcLightSourceDirectional::IfcLightSourceDirectional(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceDirectional)) throw; entity = e; } // IfcLightSourceGoniometric SHARED_PTR IfcLightSourceGoniometric::Position() { return reinterpret_pointer_cast(*entity->getArgument(4)); } bool IfcLightSourceGoniometric::hasColourAppearance() { return !entity->getArgument(5)->isNull(); } @@ -6474,7 +6473,7 @@ IfcLightDistributionDataSourceSelect IfcLightSourceGoniometric::LightDistributio bool IfcLightSourceGoniometric::is(Type::Enum v) { return v == Type::IfcLightSourceGoniometric || IfcLightSource::is(v); } Type::Enum IfcLightSourceGoniometric::type() { return Type::IfcLightSourceGoniometric; } Type::Enum IfcLightSourceGoniometric::Class() { return Type::IfcLightSourceGoniometric; } -IfcLightSourceGoniometric::IfcLightSourceGoniometric(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceGoniometric)) throw; entity = e; } +IfcLightSourceGoniometric::IfcLightSourceGoniometric(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceGoniometric)) throw; entity = e; } // IfcLightSourcePositional SHARED_PTR IfcLightSourcePositional::Position() { return reinterpret_pointer_cast(*entity->getArgument(4)); } IfcPositiveLengthMeasure IfcLightSourcePositional::Radius() { return *entity->getArgument(5); } @@ -6484,7 +6483,7 @@ IfcReal IfcLightSourcePositional::QuadricAttenuation() { return *entity->getArgu bool IfcLightSourcePositional::is(Type::Enum v) { return v == Type::IfcLightSourcePositional || IfcLightSource::is(v); } Type::Enum IfcLightSourcePositional::type() { return Type::IfcLightSourcePositional; } Type::Enum IfcLightSourcePositional::Class() { return Type::IfcLightSourcePositional; } -IfcLightSourcePositional::IfcLightSourcePositional(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourcePositional)) throw; entity = e; } +IfcLightSourcePositional::IfcLightSourcePositional(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourcePositional)) throw; entity = e; } // IfcLightSourceSpot SHARED_PTR IfcLightSourceSpot::Orientation() { return reinterpret_pointer_cast(*entity->getArgument(9)); } bool IfcLightSourceSpot::hasConcentrationExponent() { return !entity->getArgument(10)->isNull(); } @@ -6494,19 +6493,19 @@ IfcPositivePlaneAngleMeasure IfcLightSourceSpot::BeamWidthAngle() { return *enti bool IfcLightSourceSpot::is(Type::Enum v) { return v == Type::IfcLightSourceSpot || IfcLightSourcePositional::is(v); } Type::Enum IfcLightSourceSpot::type() { return Type::IfcLightSourceSpot; } Type::Enum IfcLightSourceSpot::Class() { return Type::IfcLightSourceSpot; } -IfcLightSourceSpot::IfcLightSourceSpot(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceSpot)) throw; entity = e; } +IfcLightSourceSpot::IfcLightSourceSpot(IfcAbstractEntityPtr e) { if (!is(Type::IfcLightSourceSpot)) throw; entity = e; } // IfcLine SHARED_PTR IfcLine::Pnt() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcLine::Dir() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcLine::is(Type::Enum v) { return v == Type::IfcLine || IfcCurve::is(v); } Type::Enum IfcLine::type() { return Type::IfcLine; } Type::Enum IfcLine::Class() { return Type::IfcLine; } -IfcLine::IfcLine(IfcAbstractEntityPtr e) { if (!is(Type::IfcLine)) throw; entity = e; } +IfcLine::IfcLine(IfcAbstractEntityPtr e) { if (!is(Type::IfcLine)) throw; entity = e; } // IfcLinearDimension bool IfcLinearDimension::is(Type::Enum v) { return v == Type::IfcLinearDimension || IfcDimensionCurveDirectedCallout::is(v); } Type::Enum IfcLinearDimension::type() { return Type::IfcLinearDimension; } Type::Enum IfcLinearDimension::Class() { return Type::IfcLinearDimension; } -IfcLinearDimension::IfcLinearDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcLinearDimension)) throw; entity = e; } +IfcLinearDimension::IfcLinearDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcLinearDimension)) throw; entity = e; } // IfcLocalPlacement bool IfcLocalPlacement::hasPlacementRelTo() { return !entity->getArgument(0)->isNull(); } SHARED_PTR IfcLocalPlacement::PlacementRelTo() { return reinterpret_pointer_cast(*entity->getArgument(0)); } @@ -6514,7 +6513,7 @@ IfcAxis2Placement IfcLocalPlacement::RelativePlacement() { return *entity->getAr bool IfcLocalPlacement::is(Type::Enum v) { return v == Type::IfcLocalPlacement || IfcObjectPlacement::is(v); } Type::Enum IfcLocalPlacement::type() { return Type::IfcLocalPlacement; } Type::Enum IfcLocalPlacement::Class() { return Type::IfcLocalPlacement; } -IfcLocalPlacement::IfcLocalPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcLocalPlacement)) throw; entity = e; } +IfcLocalPlacement::IfcLocalPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcLocalPlacement)) throw; entity = e; } // IfcLocalTime IfcHourInDay IfcLocalTime::HourComponent() { return *entity->getArgument(0); } bool IfcLocalTime::hasMinuteComponent() { return !entity->getArgument(1)->isNull(); } @@ -6528,25 +6527,25 @@ IfcDaylightSavingHour IfcLocalTime::DaylightSavingOffset() { return *entity->get bool IfcLocalTime::is(Type::Enum v) { return v == Type::IfcLocalTime; } Type::Enum IfcLocalTime::type() { return Type::IfcLocalTime; } Type::Enum IfcLocalTime::Class() { return Type::IfcLocalTime; } -IfcLocalTime::IfcLocalTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcLocalTime)) throw; entity = e; } +IfcLocalTime::IfcLocalTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcLocalTime)) throw; entity = e; } // IfcLoop bool IfcLoop::is(Type::Enum v) { return v == Type::IfcLoop || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcLoop::type() { return Type::IfcLoop; } Type::Enum IfcLoop::Class() { return Type::IfcLoop; } -IfcLoop::IfcLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcLoop)) throw; entity = e; } +IfcLoop::IfcLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcLoop)) throw; entity = e; } // IfcManifoldSolidBrep SHARED_PTR IfcManifoldSolidBrep::Outer() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcManifoldSolidBrep::is(Type::Enum v) { return v == Type::IfcManifoldSolidBrep || IfcSolidModel::is(v); } Type::Enum IfcManifoldSolidBrep::type() { return Type::IfcManifoldSolidBrep; } Type::Enum IfcManifoldSolidBrep::Class() { return Type::IfcManifoldSolidBrep; } -IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcAbstractEntityPtr e) { if (!is(Type::IfcManifoldSolidBrep)) throw; entity = e; } +IfcManifoldSolidBrep::IfcManifoldSolidBrep(IfcAbstractEntityPtr e) { if (!is(Type::IfcManifoldSolidBrep)) throw; entity = e; } // IfcMappedItem SHARED_PTR IfcMappedItem::MappingSource() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcMappedItem::MappingTarget() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcMappedItem::is(Type::Enum v) { return v == Type::IfcMappedItem || IfcRepresentationItem::is(v); } Type::Enum IfcMappedItem::type() { return Type::IfcMappedItem; } Type::Enum IfcMappedItem::Class() { return Type::IfcMappedItem; } -IfcMappedItem::IfcMappedItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcMappedItem)) throw; entity = e; } +IfcMappedItem::IfcMappedItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcMappedItem)) throw; entity = e; } // IfcMaterial IfcLabel IfcMaterial::Name() { return *entity->getArgument(0); } IfcMaterialDefinitionRepresentation::list IfcMaterial::HasRepresentation() { RETURN_INVERSE(IfcMaterialDefinitionRepresentation) } @@ -6554,20 +6553,20 @@ IfcMaterialClassificationRelationship::list IfcMaterial::ClassifiedAs() { RETURN bool IfcMaterial::is(Type::Enum v) { return v == Type::IfcMaterial; } Type::Enum IfcMaterial::type() { return Type::IfcMaterial; } Type::Enum IfcMaterial::Class() { return Type::IfcMaterial; } -IfcMaterial::IfcMaterial(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterial)) throw; entity = e; } +IfcMaterial::IfcMaterial(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterial)) throw; entity = e; } // IfcMaterialClassificationRelationship SHARED_PTR< IfcTemplatedEntityList > IfcMaterialClassificationRelationship::MaterialClassifications() { RETURN_AS_LIST(IfcAbstractSelect,0) } SHARED_PTR IfcMaterialClassificationRelationship::ClassifiedMaterial() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcMaterialClassificationRelationship::is(Type::Enum v) { return v == Type::IfcMaterialClassificationRelationship; } Type::Enum IfcMaterialClassificationRelationship::type() { return Type::IfcMaterialClassificationRelationship; } Type::Enum IfcMaterialClassificationRelationship::Class() { return Type::IfcMaterialClassificationRelationship; } -IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialClassificationRelationship)) throw; entity = e; } +IfcMaterialClassificationRelationship::IfcMaterialClassificationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialClassificationRelationship)) throw; entity = e; } // IfcMaterialDefinitionRepresentation SHARED_PTR IfcMaterialDefinitionRepresentation::RepresentedMaterial() { return reinterpret_pointer_cast(*entity->getArgument(3)); } bool IfcMaterialDefinitionRepresentation::is(Type::Enum v) { return v == Type::IfcMaterialDefinitionRepresentation || IfcProductRepresentation::is(v); } Type::Enum IfcMaterialDefinitionRepresentation::type() { return Type::IfcMaterialDefinitionRepresentation; } Type::Enum IfcMaterialDefinitionRepresentation::Class() { return Type::IfcMaterialDefinitionRepresentation; } -IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialDefinitionRepresentation)) throw; entity = e; } +IfcMaterialDefinitionRepresentation::IfcMaterialDefinitionRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialDefinitionRepresentation)) throw; entity = e; } // IfcMaterialLayer bool IfcMaterialLayer::hasMaterial() { return !entity->getArgument(0)->isNull(); } SHARED_PTR IfcMaterialLayer::Material() { return reinterpret_pointer_cast(*entity->getArgument(0)); } @@ -6578,7 +6577,7 @@ IfcMaterialLayerSet::list IfcMaterialLayer::ToMaterialLayerSet() { RETURN_INVERS bool IfcMaterialLayer::is(Type::Enum v) { return v == Type::IfcMaterialLayer; } Type::Enum IfcMaterialLayer::type() { return Type::IfcMaterialLayer; } Type::Enum IfcMaterialLayer::Class() { return Type::IfcMaterialLayer; } -IfcMaterialLayer::IfcMaterialLayer(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayer)) throw; entity = e; } +IfcMaterialLayer::IfcMaterialLayer(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayer)) throw; entity = e; } // IfcMaterialLayerSet SHARED_PTR< IfcTemplatedEntityList > IfcMaterialLayerSet::MaterialLayers() { RETURN_AS_LIST(IfcMaterialLayer,0) } bool IfcMaterialLayerSet::hasLayerSetName() { return !entity->getArgument(1)->isNull(); } @@ -6586,7 +6585,7 @@ IfcLabel IfcMaterialLayerSet::LayerSetName() { return *entity->getArgument(1); } bool IfcMaterialLayerSet::is(Type::Enum v) { return v == Type::IfcMaterialLayerSet; } Type::Enum IfcMaterialLayerSet::type() { return Type::IfcMaterialLayerSet; } Type::Enum IfcMaterialLayerSet::Class() { return Type::IfcMaterialLayerSet; } -IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayerSet)) throw; entity = e; } +IfcMaterialLayerSet::IfcMaterialLayerSet(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayerSet)) throw; entity = e; } // IfcMaterialLayerSetUsage SHARED_PTR IfcMaterialLayerSetUsage::ForLayerSet() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcLayerSetDirectionEnum::IfcLayerSetDirectionEnum IfcMaterialLayerSetUsage::LayerSetDirection() { return IfcLayerSetDirectionEnum::FromString(*entity->getArgument(1)); } @@ -6595,26 +6594,26 @@ IfcLengthMeasure IfcMaterialLayerSetUsage::OffsetFromReferenceLine() { return *e bool IfcMaterialLayerSetUsage::is(Type::Enum v) { return v == Type::IfcMaterialLayerSetUsage; } Type::Enum IfcMaterialLayerSetUsage::type() { return Type::IfcMaterialLayerSetUsage; } Type::Enum IfcMaterialLayerSetUsage::Class() { return Type::IfcMaterialLayerSetUsage; } -IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayerSetUsage)) throw; entity = e; } +IfcMaterialLayerSetUsage::IfcMaterialLayerSetUsage(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialLayerSetUsage)) throw; entity = e; } // IfcMaterialList SHARED_PTR< IfcTemplatedEntityList > IfcMaterialList::Materials() { RETURN_AS_LIST(IfcMaterial,0) } bool IfcMaterialList::is(Type::Enum v) { return v == Type::IfcMaterialList; } Type::Enum IfcMaterialList::type() { return Type::IfcMaterialList; } Type::Enum IfcMaterialList::Class() { return Type::IfcMaterialList; } -IfcMaterialList::IfcMaterialList(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialList)) throw; entity = e; } +IfcMaterialList::IfcMaterialList(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialList)) throw; entity = e; } // IfcMaterialProperties SHARED_PTR IfcMaterialProperties::Material() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcMaterialProperties::is(Type::Enum v) { return v == Type::IfcMaterialProperties; } Type::Enum IfcMaterialProperties::type() { return Type::IfcMaterialProperties; } Type::Enum IfcMaterialProperties::Class() { return Type::IfcMaterialProperties; } -IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialProperties)) throw; entity = e; } +IfcMaterialProperties::IfcMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMaterialProperties)) throw; entity = e; } // IfcMeasureWithUnit IfcValue IfcMeasureWithUnit::ValueComponent() { return *entity->getArgument(0); } IfcUnit IfcMeasureWithUnit::UnitComponent() { return *entity->getArgument(1); } bool IfcMeasureWithUnit::is(Type::Enum v) { return v == Type::IfcMeasureWithUnit; } Type::Enum IfcMeasureWithUnit::type() { return Type::IfcMeasureWithUnit; } Type::Enum IfcMeasureWithUnit::Class() { return Type::IfcMeasureWithUnit; } -IfcMeasureWithUnit::IfcMeasureWithUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcMeasureWithUnit)) throw; entity = e; } +IfcMeasureWithUnit::IfcMeasureWithUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcMeasureWithUnit)) throw; entity = e; } // IfcMechanicalConcreteMaterialProperties bool IfcMechanicalConcreteMaterialProperties::hasCompressiveStrength() { return !entity->getArgument(6)->isNull(); } IfcPressureMeasure IfcMechanicalConcreteMaterialProperties::CompressiveStrength() { return *entity->getArgument(6); } @@ -6631,7 +6630,7 @@ IfcText IfcMechanicalConcreteMaterialProperties::WaterImpermeability() { return bool IfcMechanicalConcreteMaterialProperties::is(Type::Enum v) { return v == Type::IfcMechanicalConcreteMaterialProperties || IfcMechanicalMaterialProperties::is(v); } Type::Enum IfcMechanicalConcreteMaterialProperties::type() { return Type::IfcMechanicalConcreteMaterialProperties; } Type::Enum IfcMechanicalConcreteMaterialProperties::Class() { return Type::IfcMechanicalConcreteMaterialProperties; } -IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalConcreteMaterialProperties)) throw; entity = e; } +IfcMechanicalConcreteMaterialProperties::IfcMechanicalConcreteMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalConcreteMaterialProperties)) throw; entity = e; } // IfcMechanicalFastener bool IfcMechanicalFastener::hasNominalDiameter() { return !entity->getArgument(8)->isNull(); } IfcPositiveLengthMeasure IfcMechanicalFastener::NominalDiameter() { return *entity->getArgument(8); } @@ -6640,12 +6639,12 @@ IfcPositiveLengthMeasure IfcMechanicalFastener::NominalLength() { return *entity bool IfcMechanicalFastener::is(Type::Enum v) { return v == Type::IfcMechanicalFastener || IfcFastener::is(v); } Type::Enum IfcMechanicalFastener::type() { return Type::IfcMechanicalFastener; } Type::Enum IfcMechanicalFastener::Class() { return Type::IfcMechanicalFastener; } -IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalFastener)) throw; entity = e; } +IfcMechanicalFastener::IfcMechanicalFastener(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalFastener)) throw; entity = e; } // IfcMechanicalFastenerType bool IfcMechanicalFastenerType::is(Type::Enum v) { return v == Type::IfcMechanicalFastenerType || IfcFastenerType::is(v); } Type::Enum IfcMechanicalFastenerType::type() { return Type::IfcMechanicalFastenerType; } Type::Enum IfcMechanicalFastenerType::Class() { return Type::IfcMechanicalFastenerType; } -IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalFastenerType)) throw; entity = e; } +IfcMechanicalFastenerType::IfcMechanicalFastenerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalFastenerType)) throw; entity = e; } // IfcMechanicalMaterialProperties bool IfcMechanicalMaterialProperties::hasDynamicViscosity() { return !entity->getArgument(1)->isNull(); } IfcDynamicViscosityMeasure IfcMechanicalMaterialProperties::DynamicViscosity() { return *entity->getArgument(1); } @@ -6660,7 +6659,7 @@ IfcThermalExpansionCoefficientMeasure IfcMechanicalMaterialProperties::ThermalEx bool IfcMechanicalMaterialProperties::is(Type::Enum v) { return v == Type::IfcMechanicalMaterialProperties || IfcMaterialProperties::is(v); } Type::Enum IfcMechanicalMaterialProperties::type() { return Type::IfcMechanicalMaterialProperties; } Type::Enum IfcMechanicalMaterialProperties::Class() { return Type::IfcMechanicalMaterialProperties; } -IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalMaterialProperties)) throw; entity = e; } +IfcMechanicalMaterialProperties::IfcMechanicalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalMaterialProperties)) throw; entity = e; } // IfcMechanicalSteelMaterialProperties bool IfcMechanicalSteelMaterialProperties::hasYieldStress() { return !entity->getArgument(6)->isNull(); } IfcPressureMeasure IfcMechanicalSteelMaterialProperties::YieldStress() { return *entity->getArgument(6); } @@ -6679,18 +6678,18 @@ SHARED_PTR< IfcTemplatedEntityList > IfcMechanicalSteelMaterialPr bool IfcMechanicalSteelMaterialProperties::is(Type::Enum v) { return v == Type::IfcMechanicalSteelMaterialProperties || IfcMechanicalMaterialProperties::is(v); } Type::Enum IfcMechanicalSteelMaterialProperties::type() { return Type::IfcMechanicalSteelMaterialProperties; } Type::Enum IfcMechanicalSteelMaterialProperties::Class() { return Type::IfcMechanicalSteelMaterialProperties; } -IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalSteelMaterialProperties)) throw; entity = e; } +IfcMechanicalSteelMaterialProperties::IfcMechanicalSteelMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcMechanicalSteelMaterialProperties)) throw; entity = e; } // IfcMember bool IfcMember::is(Type::Enum v) { return v == Type::IfcMember || IfcBuildingElement::is(v); } Type::Enum IfcMember::type() { return Type::IfcMember; } Type::Enum IfcMember::Class() { return Type::IfcMember; } -IfcMember::IfcMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcMember)) throw; entity = e; } +IfcMember::IfcMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcMember)) throw; entity = e; } // IfcMemberType IfcMemberTypeEnum::IfcMemberTypeEnum IfcMemberType::PredefinedType() { return IfcMemberTypeEnum::FromString(*entity->getArgument(9)); } bool IfcMemberType::is(Type::Enum v) { return v == Type::IfcMemberType || IfcBuildingElementType::is(v); } Type::Enum IfcMemberType::type() { return Type::IfcMemberType; } Type::Enum IfcMemberType::Class() { return Type::IfcMemberType; } -IfcMemberType::IfcMemberType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMemberType)) throw; entity = e; } +IfcMemberType::IfcMemberType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMemberType)) throw; entity = e; } // IfcMetric IfcBenchmarkEnum::IfcBenchmarkEnum IfcMetric::Benchmark() { return IfcBenchmarkEnum::FromString(*entity->getArgument(7)); } bool IfcMetric::hasValueSource() { return !entity->getArgument(8)->isNull(); } @@ -6699,35 +6698,35 @@ IfcMetricValueSelect IfcMetric::DataValue() { return *entity->getArgument(9); } bool IfcMetric::is(Type::Enum v) { return v == Type::IfcMetric || IfcConstraint::is(v); } Type::Enum IfcMetric::type() { return Type::IfcMetric; } Type::Enum IfcMetric::Class() { return Type::IfcMetric; } -IfcMetric::IfcMetric(IfcAbstractEntityPtr e) { if (!is(Type::IfcMetric)) throw; entity = e; } +IfcMetric::IfcMetric(IfcAbstractEntityPtr e) { if (!is(Type::IfcMetric)) throw; entity = e; } // IfcMonetaryUnit IfcCurrencyEnum::IfcCurrencyEnum IfcMonetaryUnit::Currency() { return IfcCurrencyEnum::FromString(*entity->getArgument(0)); } bool IfcMonetaryUnit::is(Type::Enum v) { return v == Type::IfcMonetaryUnit; } Type::Enum IfcMonetaryUnit::type() { return Type::IfcMonetaryUnit; } Type::Enum IfcMonetaryUnit::Class() { return Type::IfcMonetaryUnit; } -IfcMonetaryUnit::IfcMonetaryUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcMonetaryUnit)) throw; entity = e; } +IfcMonetaryUnit::IfcMonetaryUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcMonetaryUnit)) throw; entity = e; } // IfcMotorConnectionType IfcMotorConnectionTypeEnum::IfcMotorConnectionTypeEnum IfcMotorConnectionType::PredefinedType() { return IfcMotorConnectionTypeEnum::FromString(*entity->getArgument(9)); } bool IfcMotorConnectionType::is(Type::Enum v) { return v == Type::IfcMotorConnectionType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcMotorConnectionType::type() { return Type::IfcMotorConnectionType; } Type::Enum IfcMotorConnectionType::Class() { return Type::IfcMotorConnectionType; } -IfcMotorConnectionType::IfcMotorConnectionType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMotorConnectionType)) throw; entity = e; } +IfcMotorConnectionType::IfcMotorConnectionType(IfcAbstractEntityPtr e) { if (!is(Type::IfcMotorConnectionType)) throw; entity = e; } // IfcMove SHARED_PTR IfcMove::MoveFrom() { return reinterpret_pointer_cast(*entity->getArgument(10)); } SHARED_PTR IfcMove::MoveTo() { return reinterpret_pointer_cast(*entity->getArgument(11)); } bool IfcMove::hasPunchList() { return !entity->getArgument(12)->isNull(); } -std::vector IfcMove::PunchList() { return *entity->getArgument(12); } +std::vector /*[1:?]*/ IfcMove::PunchList() { return *entity->getArgument(12); } bool IfcMove::is(Type::Enum v) { return v == Type::IfcMove || IfcTask::is(v); } Type::Enum IfcMove::type() { return Type::IfcMove; } Type::Enum IfcMove::Class() { return Type::IfcMove; } -IfcMove::IfcMove(IfcAbstractEntityPtr e) { if (!is(Type::IfcMove)) throw; entity = e; } +IfcMove::IfcMove(IfcAbstractEntityPtr e) { if (!is(Type::IfcMove)) throw; entity = e; } // IfcNamedUnit SHARED_PTR IfcNamedUnit::Dimensions() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcUnitEnum::IfcUnitEnum IfcNamedUnit::UnitType() { return IfcUnitEnum::FromString(*entity->getArgument(1)); } bool IfcNamedUnit::is(Type::Enum v) { return v == Type::IfcNamedUnit; } Type::Enum IfcNamedUnit::type() { return Type::IfcNamedUnit; } Type::Enum IfcNamedUnit::Class() { return Type::IfcNamedUnit; } -IfcNamedUnit::IfcNamedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcNamedUnit)) throw; entity = e; } +IfcNamedUnit::IfcNamedUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcNamedUnit)) throw; entity = e; } // IfcObject bool IfcObject::hasObjectType() { return !entity->getArgument(4)->isNull(); } IfcLabel IfcObject::ObjectType() { return *entity->getArgument(4); } @@ -6735,7 +6734,7 @@ IfcRelDefines::list IfcObject::IsDefinedBy() { RETURN_INVERSE(IfcRelDefines) } bool IfcObject::is(Type::Enum v) { return v == Type::IfcObject || IfcObjectDefinition::is(v); } Type::Enum IfcObject::type() { return Type::IfcObject; } Type::Enum IfcObject::Class() { return Type::IfcObject; } -IfcObject::IfcObject(IfcAbstractEntityPtr e) { if (!is(Type::IfcObject)) throw; entity = e; } +IfcObject::IfcObject(IfcAbstractEntityPtr e) { if (!is(Type::IfcObject)) throw; entity = e; } // IfcObjectDefinition IfcRelAssigns::list IfcObjectDefinition::HasAssignments() { RETURN_INVERSE(IfcRelAssigns) } IfcRelDecomposes::list IfcObjectDefinition::IsDecomposedBy() { RETURN_INVERSE(IfcRelDecomposes) } @@ -6744,14 +6743,14 @@ IfcRelAssociates::list IfcObjectDefinition::HasAssociations() { RETURN_INVERSE(I bool IfcObjectDefinition::is(Type::Enum v) { return v == Type::IfcObjectDefinition || IfcRoot::is(v); } Type::Enum IfcObjectDefinition::type() { return Type::IfcObjectDefinition; } Type::Enum IfcObjectDefinition::Class() { return Type::IfcObjectDefinition; } -IfcObjectDefinition::IfcObjectDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjectDefinition)) throw; entity = e; } +IfcObjectDefinition::IfcObjectDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjectDefinition)) throw; entity = e; } // IfcObjectPlacement IfcProduct::list IfcObjectPlacement::PlacesObject() { RETURN_INVERSE(IfcProduct) } IfcLocalPlacement::list IfcObjectPlacement::ReferencedByPlacements() { RETURN_INVERSE(IfcLocalPlacement) } bool IfcObjectPlacement::is(Type::Enum v) { return v == Type::IfcObjectPlacement; } Type::Enum IfcObjectPlacement::type() { return Type::IfcObjectPlacement; } Type::Enum IfcObjectPlacement::Class() { return Type::IfcObjectPlacement; } -IfcObjectPlacement::IfcObjectPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjectPlacement)) throw; entity = e; } +IfcObjectPlacement::IfcObjectPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjectPlacement)) throw; entity = e; } // IfcObjective bool IfcObjective::hasBenchmarkValues() { return !entity->getArgument(7)->isNull(); } SHARED_PTR IfcObjective::BenchmarkValues() { return reinterpret_pointer_cast(*entity->getArgument(7)); } @@ -6763,13 +6762,13 @@ IfcLabel IfcObjective::UserDefinedQualifier() { return *entity->getArgument(10); bool IfcObjective::is(Type::Enum v) { return v == Type::IfcObjective || IfcConstraint::is(v); } Type::Enum IfcObjective::type() { return Type::IfcObjective; } Type::Enum IfcObjective::Class() { return Type::IfcObjective; } -IfcObjective::IfcObjective(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjective)) throw; entity = e; } +IfcObjective::IfcObjective(IfcAbstractEntityPtr e) { if (!is(Type::IfcObjective)) throw; entity = e; } // IfcOccupant IfcOccupantTypeEnum::IfcOccupantTypeEnum IfcOccupant::PredefinedType() { return IfcOccupantTypeEnum::FromString(*entity->getArgument(6)); } bool IfcOccupant::is(Type::Enum v) { return v == Type::IfcOccupant || IfcActor::is(v); } Type::Enum IfcOccupant::type() { return Type::IfcOccupant; } Type::Enum IfcOccupant::Class() { return Type::IfcOccupant; } -IfcOccupant::IfcOccupant(IfcAbstractEntityPtr e) { if (!is(Type::IfcOccupant)) throw; entity = e; } +IfcOccupant::IfcOccupant(IfcAbstractEntityPtr e) { if (!is(Type::IfcOccupant)) throw; entity = e; } // IfcOffsetCurve2D SHARED_PTR IfcOffsetCurve2D::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcLengthMeasure IfcOffsetCurve2D::Distance() { return *entity->getArgument(1); } @@ -6777,7 +6776,7 @@ bool IfcOffsetCurve2D::SelfIntersect() { return *entity->getArgument(2); } bool IfcOffsetCurve2D::is(Type::Enum v) { return v == Type::IfcOffsetCurve2D || IfcCurve::is(v); } Type::Enum IfcOffsetCurve2D::type() { return Type::IfcOffsetCurve2D; } Type::Enum IfcOffsetCurve2D::Class() { return Type::IfcOffsetCurve2D; } -IfcOffsetCurve2D::IfcOffsetCurve2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcOffsetCurve2D)) throw; entity = e; } +IfcOffsetCurve2D::IfcOffsetCurve2D(IfcAbstractEntityPtr e) { if (!is(Type::IfcOffsetCurve2D)) throw; entity = e; } // IfcOffsetCurve3D SHARED_PTR IfcOffsetCurve3D::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcLengthMeasure IfcOffsetCurve3D::Distance() { return *entity->getArgument(1); } @@ -6786,24 +6785,24 @@ SHARED_PTR IfcOffsetCurve3D::RefDirection() { return reinterpret_p bool IfcOffsetCurve3D::is(Type::Enum v) { return v == Type::IfcOffsetCurve3D || IfcCurve::is(v); } Type::Enum IfcOffsetCurve3D::type() { return Type::IfcOffsetCurve3D; } Type::Enum IfcOffsetCurve3D::Class() { return Type::IfcOffsetCurve3D; } -IfcOffsetCurve3D::IfcOffsetCurve3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcOffsetCurve3D)) throw; entity = e; } +IfcOffsetCurve3D::IfcOffsetCurve3D(IfcAbstractEntityPtr e) { if (!is(Type::IfcOffsetCurve3D)) throw; entity = e; } // IfcOneDirectionRepeatFactor SHARED_PTR IfcOneDirectionRepeatFactor::RepeatFactor() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcOneDirectionRepeatFactor::is(Type::Enum v) { return v == Type::IfcOneDirectionRepeatFactor || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcOneDirectionRepeatFactor::type() { return Type::IfcOneDirectionRepeatFactor; } Type::Enum IfcOneDirectionRepeatFactor::Class() { return Type::IfcOneDirectionRepeatFactor; } -IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcOneDirectionRepeatFactor)) throw; entity = e; } +IfcOneDirectionRepeatFactor::IfcOneDirectionRepeatFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcOneDirectionRepeatFactor)) throw; entity = e; } // IfcOpenShell bool IfcOpenShell::is(Type::Enum v) { return v == Type::IfcOpenShell || IfcConnectedFaceSet::is(v); } Type::Enum IfcOpenShell::type() { return Type::IfcOpenShell; } Type::Enum IfcOpenShell::Class() { return Type::IfcOpenShell; } -IfcOpenShell::IfcOpenShell(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpenShell)) throw; entity = e; } +IfcOpenShell::IfcOpenShell(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpenShell)) throw; entity = e; } // IfcOpeningElement IfcRelFillsElement::list IfcOpeningElement::HasFillings() { RETURN_INVERSE(IfcRelFillsElement) } bool IfcOpeningElement::is(Type::Enum v) { return v == Type::IfcOpeningElement || IfcFeatureElementSubtraction::is(v); } Type::Enum IfcOpeningElement::type() { return Type::IfcOpeningElement; } Type::Enum IfcOpeningElement::Class() { return Type::IfcOpeningElement; } -IfcOpeningElement::IfcOpeningElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpeningElement)) throw; entity = e; } +IfcOpeningElement::IfcOpeningElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpeningElement)) throw; entity = e; } // IfcOpticalMaterialProperties bool IfcOpticalMaterialProperties::hasVisibleTransmittance() { return !entity->getArgument(1)->isNull(); } IfcPositiveRatioMeasure IfcOpticalMaterialProperties::VisibleTransmittance() { return *entity->getArgument(1); } @@ -6826,13 +6825,13 @@ IfcPositiveRatioMeasure IfcOpticalMaterialProperties::SolarReflectanceBack() { r bool IfcOpticalMaterialProperties::is(Type::Enum v) { return v == Type::IfcOpticalMaterialProperties || IfcMaterialProperties::is(v); } Type::Enum IfcOpticalMaterialProperties::type() { return Type::IfcOpticalMaterialProperties; } Type::Enum IfcOpticalMaterialProperties::Class() { return Type::IfcOpticalMaterialProperties; } -IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpticalMaterialProperties)) throw; entity = e; } +IfcOpticalMaterialProperties::IfcOpticalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcOpticalMaterialProperties)) throw; entity = e; } // IfcOrderAction IfcIdentifier IfcOrderAction::ActionID() { return *entity->getArgument(10); } bool IfcOrderAction::is(Type::Enum v) { return v == Type::IfcOrderAction || IfcTask::is(v); } Type::Enum IfcOrderAction::type() { return Type::IfcOrderAction; } Type::Enum IfcOrderAction::Class() { return Type::IfcOrderAction; } -IfcOrderAction::IfcOrderAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrderAction)) throw; entity = e; } +IfcOrderAction::IfcOrderAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrderAction)) throw; entity = e; } // IfcOrganization bool IfcOrganization::hasId() { return !entity->getArgument(0)->isNull(); } IfcIdentifier IfcOrganization::Id() { return *entity->getArgument(0); } @@ -6849,7 +6848,7 @@ IfcPersonAndOrganization::list IfcOrganization::Engages() { RETURN_INVERSE(IfcPe bool IfcOrganization::is(Type::Enum v) { return v == Type::IfcOrganization; } Type::Enum IfcOrganization::type() { return Type::IfcOrganization; } Type::Enum IfcOrganization::Class() { return Type::IfcOrganization; } -IfcOrganization::IfcOrganization(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrganization)) throw; entity = e; } +IfcOrganization::IfcOrganization(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrganization)) throw; entity = e; } // IfcOrganizationRelationship IfcLabel IfcOrganizationRelationship::Name() { return *entity->getArgument(0); } bool IfcOrganizationRelationship::hasDescription() { return !entity->getArgument(1)->isNull(); } @@ -6859,20 +6858,20 @@ SHARED_PTR< IfcTemplatedEntityList > IfcOrganizationRelationshi bool IfcOrganizationRelationship::is(Type::Enum v) { return v == Type::IfcOrganizationRelationship; } Type::Enum IfcOrganizationRelationship::type() { return Type::IfcOrganizationRelationship; } Type::Enum IfcOrganizationRelationship::Class() { return Type::IfcOrganizationRelationship; } -IfcOrganizationRelationship::IfcOrganizationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrganizationRelationship)) throw; entity = e; } +IfcOrganizationRelationship::IfcOrganizationRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrganizationRelationship)) throw; entity = e; } // IfcOrientedEdge SHARED_PTR IfcOrientedEdge::EdgeElement() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcOrientedEdge::Orientation() { return *entity->getArgument(3); } bool IfcOrientedEdge::is(Type::Enum v) { return v == Type::IfcOrientedEdge || IfcEdge::is(v); } Type::Enum IfcOrientedEdge::type() { return Type::IfcOrientedEdge; } Type::Enum IfcOrientedEdge::Class() { return Type::IfcOrientedEdge; } -IfcOrientedEdge::IfcOrientedEdge(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrientedEdge)) throw; entity = e; } +IfcOrientedEdge::IfcOrientedEdge(IfcAbstractEntityPtr e) { if (!is(Type::IfcOrientedEdge)) throw; entity = e; } // IfcOutletType IfcOutletTypeEnum::IfcOutletTypeEnum IfcOutletType::PredefinedType() { return IfcOutletTypeEnum::FromString(*entity->getArgument(9)); } bool IfcOutletType::is(Type::Enum v) { return v == Type::IfcOutletType || IfcFlowTerminalType::is(v); } Type::Enum IfcOutletType::type() { return Type::IfcOutletType; } Type::Enum IfcOutletType::Class() { return Type::IfcOutletType; } -IfcOutletType::IfcOutletType(IfcAbstractEntityPtr e) { if (!is(Type::IfcOutletType)) throw; entity = e; } +IfcOutletType::IfcOutletType(IfcAbstractEntityPtr e) { if (!is(Type::IfcOutletType)) throw; entity = e; } // IfcOwnerHistory SHARED_PTR IfcOwnerHistory::OwningUser() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcOwnerHistory::OwningApplication() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -6889,25 +6888,25 @@ IfcTimeStamp IfcOwnerHistory::CreationDate() { return *entity->getArgument(7); } bool IfcOwnerHistory::is(Type::Enum v) { return v == Type::IfcOwnerHistory; } Type::Enum IfcOwnerHistory::type() { return Type::IfcOwnerHistory; } Type::Enum IfcOwnerHistory::Class() { return Type::IfcOwnerHistory; } -IfcOwnerHistory::IfcOwnerHistory(IfcAbstractEntityPtr e) { if (!is(Type::IfcOwnerHistory)) throw; entity = e; } +IfcOwnerHistory::IfcOwnerHistory(IfcAbstractEntityPtr e) { if (!is(Type::IfcOwnerHistory)) throw; entity = e; } // IfcParameterizedProfileDef SHARED_PTR IfcParameterizedProfileDef::Position() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcParameterizedProfileDef::is(Type::Enum v) { return v == Type::IfcParameterizedProfileDef || IfcProfileDef::is(v); } Type::Enum IfcParameterizedProfileDef::type() { return Type::IfcParameterizedProfileDef; } Type::Enum IfcParameterizedProfileDef::Class() { return Type::IfcParameterizedProfileDef; } -IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcParameterizedProfileDef)) throw; entity = e; } +IfcParameterizedProfileDef::IfcParameterizedProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcParameterizedProfileDef)) throw; entity = e; } // IfcPath SHARED_PTR< IfcTemplatedEntityList > IfcPath::EdgeList() { RETURN_AS_LIST(IfcOrientedEdge,0) } bool IfcPath::is(Type::Enum v) { return v == Type::IfcPath || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcPath::type() { return Type::IfcPath; } Type::Enum IfcPath::Class() { return Type::IfcPath; } -IfcPath::IfcPath(IfcAbstractEntityPtr e) { if (!is(Type::IfcPath)) throw; entity = e; } +IfcPath::IfcPath(IfcAbstractEntityPtr e) { if (!is(Type::IfcPath)) throw; entity = e; } // IfcPerformanceHistory IfcLabel IfcPerformanceHistory::LifeCyclePhase() { return *entity->getArgument(5); } bool IfcPerformanceHistory::is(Type::Enum v) { return v == Type::IfcPerformanceHistory || IfcControl::is(v); } Type::Enum IfcPerformanceHistory::type() { return Type::IfcPerformanceHistory; } Type::Enum IfcPerformanceHistory::Class() { return Type::IfcPerformanceHistory; } -IfcPerformanceHistory::IfcPerformanceHistory(IfcAbstractEntityPtr e) { if (!is(Type::IfcPerformanceHistory)) throw; entity = e; } +IfcPerformanceHistory::IfcPerformanceHistory(IfcAbstractEntityPtr e) { if (!is(Type::IfcPerformanceHistory)) throw; entity = e; } // IfcPermeableCoveringProperties IfcPermeableCoveringOperationEnum::IfcPermeableCoveringOperationEnum IfcPermeableCoveringProperties::OperationType() { return IfcPermeableCoveringOperationEnum::FromString(*entity->getArgument(4)); } IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcPermeableCoveringProperties::PanelPosition() { return IfcWindowPanelPositionEnum::FromString(*entity->getArgument(5)); } @@ -6920,13 +6919,13 @@ SHARED_PTR IfcPermeableCoveringProperties::ShapeAspectStyle() { bool IfcPermeableCoveringProperties::is(Type::Enum v) { return v == Type::IfcPermeableCoveringProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcPermeableCoveringProperties::type() { return Type::IfcPermeableCoveringProperties; } Type::Enum IfcPermeableCoveringProperties::Class() { return Type::IfcPermeableCoveringProperties; } -IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcPermeableCoveringProperties)) throw; entity = e; } +IfcPermeableCoveringProperties::IfcPermeableCoveringProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcPermeableCoveringProperties)) throw; entity = e; } // IfcPermit IfcIdentifier IfcPermit::PermitID() { return *entity->getArgument(5); } bool IfcPermit::is(Type::Enum v) { return v == Type::IfcPermit || IfcControl::is(v); } Type::Enum IfcPermit::type() { return Type::IfcPermit; } Type::Enum IfcPermit::Class() { return Type::IfcPermit; } -IfcPermit::IfcPermit(IfcAbstractEntityPtr e) { if (!is(Type::IfcPermit)) throw; entity = e; } +IfcPermit::IfcPermit(IfcAbstractEntityPtr e) { if (!is(Type::IfcPermit)) throw; entity = e; } // IfcPerson bool IfcPerson::hasId() { return !entity->getArgument(0)->isNull(); } IfcIdentifier IfcPerson::Id() { return *entity->getArgument(0); } @@ -6935,11 +6934,11 @@ IfcLabel IfcPerson::FamilyName() { return *entity->getArgument(1); } bool IfcPerson::hasGivenName() { return !entity->getArgument(2)->isNull(); } IfcLabel IfcPerson::GivenName() { return *entity->getArgument(2); } bool IfcPerson::hasMiddleNames() { return !entity->getArgument(3)->isNull(); } -std::vector IfcPerson::MiddleNames() { return *entity->getArgument(3); } +std::vector /*[1:?]*/ IfcPerson::MiddleNames() { return *entity->getArgument(3); } bool IfcPerson::hasPrefixTitles() { return !entity->getArgument(4)->isNull(); } -std::vector IfcPerson::PrefixTitles() { return *entity->getArgument(4); } +std::vector /*[1:?]*/ IfcPerson::PrefixTitles() { return *entity->getArgument(4); } bool IfcPerson::hasSuffixTitles() { return !entity->getArgument(5)->isNull(); } -std::vector IfcPerson::SuffixTitles() { return *entity->getArgument(5); } +std::vector /*[1:?]*/ IfcPerson::SuffixTitles() { return *entity->getArgument(5); } bool IfcPerson::hasRoles() { return !entity->getArgument(6)->isNull(); } SHARED_PTR< IfcTemplatedEntityList > IfcPerson::Roles() { RETURN_AS_LIST(IfcActorRole,6) } bool IfcPerson::hasAddresses() { return !entity->getArgument(7)->isNull(); } @@ -6948,7 +6947,7 @@ IfcPersonAndOrganization::list IfcPerson::EngagedIn() { RETURN_INVERSE(IfcPerson bool IfcPerson::is(Type::Enum v) { return v == Type::IfcPerson; } Type::Enum IfcPerson::type() { return Type::IfcPerson; } Type::Enum IfcPerson::Class() { return Type::IfcPerson; } -IfcPerson::IfcPerson(IfcAbstractEntityPtr e) { if (!is(Type::IfcPerson)) throw; entity = e; } +IfcPerson::IfcPerson(IfcAbstractEntityPtr e) { if (!is(Type::IfcPerson)) throw; entity = e; } // IfcPersonAndOrganization SHARED_PTR IfcPersonAndOrganization::ThePerson() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcPersonAndOrganization::TheOrganization() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -6957,7 +6956,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcPersonAndOrganization::Rol bool IfcPersonAndOrganization::is(Type::Enum v) { return v == Type::IfcPersonAndOrganization; } Type::Enum IfcPersonAndOrganization::type() { return Type::IfcPersonAndOrganization; } Type::Enum IfcPersonAndOrganization::Class() { return Type::IfcPersonAndOrganization; } -IfcPersonAndOrganization::IfcPersonAndOrganization(IfcAbstractEntityPtr e) { if (!is(Type::IfcPersonAndOrganization)) throw; entity = e; } +IfcPersonAndOrganization::IfcPersonAndOrganization(IfcAbstractEntityPtr e) { if (!is(Type::IfcPersonAndOrganization)) throw; entity = e; } // IfcPhysicalComplexQuantity SHARED_PTR< IfcTemplatedEntityList > IfcPhysicalComplexQuantity::HasQuantities() { RETURN_AS_LIST(IfcPhysicalQuantity,2) } IfcLabel IfcPhysicalComplexQuantity::Discrimination() { return *entity->getArgument(3); } @@ -6968,7 +6967,7 @@ IfcLabel IfcPhysicalComplexQuantity::Usage() { return *entity->getArgument(5); } bool IfcPhysicalComplexQuantity::is(Type::Enum v) { return v == Type::IfcPhysicalComplexQuantity || IfcPhysicalQuantity::is(v); } Type::Enum IfcPhysicalComplexQuantity::type() { return Type::IfcPhysicalComplexQuantity; } Type::Enum IfcPhysicalComplexQuantity::Class() { return Type::IfcPhysicalComplexQuantity; } -IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalComplexQuantity)) throw; entity = e; } +IfcPhysicalComplexQuantity::IfcPhysicalComplexQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalComplexQuantity)) throw; entity = e; } // IfcPhysicalQuantity IfcLabel IfcPhysicalQuantity::Name() { return *entity->getArgument(0); } bool IfcPhysicalQuantity::hasDescription() { return !entity->getArgument(1)->isNull(); } @@ -6977,14 +6976,14 @@ IfcPhysicalComplexQuantity::list IfcPhysicalQuantity::PartOfComplex() { RETURN_I bool IfcPhysicalQuantity::is(Type::Enum v) { return v == Type::IfcPhysicalQuantity; } Type::Enum IfcPhysicalQuantity::type() { return Type::IfcPhysicalQuantity; } Type::Enum IfcPhysicalQuantity::Class() { return Type::IfcPhysicalQuantity; } -IfcPhysicalQuantity::IfcPhysicalQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalQuantity)) throw; entity = e; } +IfcPhysicalQuantity::IfcPhysicalQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalQuantity)) throw; entity = e; } // IfcPhysicalSimpleQuantity bool IfcPhysicalSimpleQuantity::hasUnit() { return !entity->getArgument(2)->isNull(); } SHARED_PTR IfcPhysicalSimpleQuantity::Unit() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcPhysicalSimpleQuantity::is(Type::Enum v) { return v == Type::IfcPhysicalSimpleQuantity || IfcPhysicalQuantity::is(v); } Type::Enum IfcPhysicalSimpleQuantity::type() { return Type::IfcPhysicalSimpleQuantity; } Type::Enum IfcPhysicalSimpleQuantity::Class() { return Type::IfcPhysicalSimpleQuantity; } -IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalSimpleQuantity)) throw; entity = e; } +IfcPhysicalSimpleQuantity::IfcPhysicalSimpleQuantity(IfcAbstractEntityPtr e) { if (!is(Type::IfcPhysicalSimpleQuantity)) throw; entity = e; } // IfcPile IfcPileTypeEnum::IfcPileTypeEnum IfcPile::PredefinedType() { return IfcPileTypeEnum::FromString(*entity->getArgument(8)); } bool IfcPile::hasConstructionType() { return !entity->getArgument(9)->isNull(); } @@ -6992,75 +6991,75 @@ IfcPileConstructionEnum::IfcPileConstructionEnum IfcPile::ConstructionType() { r bool IfcPile::is(Type::Enum v) { return v == Type::IfcPile || IfcBuildingElement::is(v); } Type::Enum IfcPile::type() { return Type::IfcPile; } Type::Enum IfcPile::Class() { return Type::IfcPile; } -IfcPile::IfcPile(IfcAbstractEntityPtr e) { if (!is(Type::IfcPile)) throw; entity = e; } +IfcPile::IfcPile(IfcAbstractEntityPtr e) { if (!is(Type::IfcPile)) throw; entity = e; } // IfcPipeFittingType IfcPipeFittingTypeEnum::IfcPipeFittingTypeEnum IfcPipeFittingType::PredefinedType() { return IfcPipeFittingTypeEnum::FromString(*entity->getArgument(9)); } bool IfcPipeFittingType::is(Type::Enum v) { return v == Type::IfcPipeFittingType || IfcFlowFittingType::is(v); } Type::Enum IfcPipeFittingType::type() { return Type::IfcPipeFittingType; } Type::Enum IfcPipeFittingType::Class() { return Type::IfcPipeFittingType; } -IfcPipeFittingType::IfcPipeFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPipeFittingType)) throw; entity = e; } +IfcPipeFittingType::IfcPipeFittingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPipeFittingType)) throw; entity = e; } // IfcPipeSegmentType IfcPipeSegmentTypeEnum::IfcPipeSegmentTypeEnum IfcPipeSegmentType::PredefinedType() { return IfcPipeSegmentTypeEnum::FromString(*entity->getArgument(9)); } bool IfcPipeSegmentType::is(Type::Enum v) { return v == Type::IfcPipeSegmentType || IfcFlowSegmentType::is(v); } Type::Enum IfcPipeSegmentType::type() { return Type::IfcPipeSegmentType; } Type::Enum IfcPipeSegmentType::Class() { return Type::IfcPipeSegmentType; } -IfcPipeSegmentType::IfcPipeSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPipeSegmentType)) throw; entity = e; } +IfcPipeSegmentType::IfcPipeSegmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPipeSegmentType)) throw; entity = e; } // IfcPixelTexture IfcInteger IfcPixelTexture::Width() { return *entity->getArgument(4); } IfcInteger IfcPixelTexture::Height() { return *entity->getArgument(5); } IfcInteger IfcPixelTexture::ColourComponents() { return *entity->getArgument(6); } -std::vector IfcPixelTexture::Pixel() { throw; /* Not implemented argument 7 */ } +std::vector /*[1:?]*/ IfcPixelTexture::Pixel() { throw; /* Not implemented argument 7 */ } bool IfcPixelTexture::is(Type::Enum v) { return v == Type::IfcPixelTexture || IfcSurfaceTexture::is(v); } Type::Enum IfcPixelTexture::type() { return Type::IfcPixelTexture; } Type::Enum IfcPixelTexture::Class() { return Type::IfcPixelTexture; } -IfcPixelTexture::IfcPixelTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcPixelTexture)) throw; entity = e; } +IfcPixelTexture::IfcPixelTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcPixelTexture)) throw; entity = e; } // IfcPlacement SHARED_PTR IfcPlacement::Location() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcPlacement::is(Type::Enum v) { return v == Type::IfcPlacement || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcPlacement::type() { return Type::IfcPlacement; } Type::Enum IfcPlacement::Class() { return Type::IfcPlacement; } -IfcPlacement::IfcPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlacement)) throw; entity = e; } +IfcPlacement::IfcPlacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlacement)) throw; entity = e; } // IfcPlanarBox IfcAxis2Placement IfcPlanarBox::Placement() { return *entity->getArgument(2); } bool IfcPlanarBox::is(Type::Enum v) { return v == Type::IfcPlanarBox || IfcPlanarExtent::is(v); } Type::Enum IfcPlanarBox::type() { return Type::IfcPlanarBox; } Type::Enum IfcPlanarBox::Class() { return Type::IfcPlanarBox; } -IfcPlanarBox::IfcPlanarBox(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlanarBox)) throw; entity = e; } +IfcPlanarBox::IfcPlanarBox(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlanarBox)) throw; entity = e; } // IfcPlanarExtent IfcLengthMeasure IfcPlanarExtent::SizeInX() { return *entity->getArgument(0); } IfcLengthMeasure IfcPlanarExtent::SizeInY() { return *entity->getArgument(1); } bool IfcPlanarExtent::is(Type::Enum v) { return v == Type::IfcPlanarExtent || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcPlanarExtent::type() { return Type::IfcPlanarExtent; } Type::Enum IfcPlanarExtent::Class() { return Type::IfcPlanarExtent; } -IfcPlanarExtent::IfcPlanarExtent(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlanarExtent)) throw; entity = e; } +IfcPlanarExtent::IfcPlanarExtent(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlanarExtent)) throw; entity = e; } // IfcPlane bool IfcPlane::is(Type::Enum v) { return v == Type::IfcPlane || IfcElementarySurface::is(v); } Type::Enum IfcPlane::type() { return Type::IfcPlane; } Type::Enum IfcPlane::Class() { return Type::IfcPlane; } -IfcPlane::IfcPlane(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlane)) throw; entity = e; } +IfcPlane::IfcPlane(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlane)) throw; entity = e; } // IfcPlate bool IfcPlate::is(Type::Enum v) { return v == Type::IfcPlate || IfcBuildingElement::is(v); } Type::Enum IfcPlate::type() { return Type::IfcPlate; } Type::Enum IfcPlate::Class() { return Type::IfcPlate; } -IfcPlate::IfcPlate(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlate)) throw; entity = e; } +IfcPlate::IfcPlate(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlate)) throw; entity = e; } // IfcPlateType IfcPlateTypeEnum::IfcPlateTypeEnum IfcPlateType::PredefinedType() { return IfcPlateTypeEnum::FromString(*entity->getArgument(9)); } bool IfcPlateType::is(Type::Enum v) { return v == Type::IfcPlateType || IfcBuildingElementType::is(v); } Type::Enum IfcPlateType::type() { return Type::IfcPlateType; } Type::Enum IfcPlateType::Class() { return Type::IfcPlateType; } -IfcPlateType::IfcPlateType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlateType)) throw; entity = e; } +IfcPlateType::IfcPlateType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPlateType)) throw; entity = e; } // IfcPoint bool IfcPoint::is(Type::Enum v) { return v == Type::IfcPoint || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcPoint::type() { return Type::IfcPoint; } Type::Enum IfcPoint::Class() { return Type::IfcPoint; } -IfcPoint::IfcPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcPoint)) throw; entity = e; } +IfcPoint::IfcPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcPoint)) throw; entity = e; } // IfcPointOnCurve SHARED_PTR IfcPointOnCurve::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcParameterValue IfcPointOnCurve::PointParameter() { return *entity->getArgument(1); } bool IfcPointOnCurve::is(Type::Enum v) { return v == Type::IfcPointOnCurve || IfcPoint::is(v); } Type::Enum IfcPointOnCurve::type() { return Type::IfcPointOnCurve; } Type::Enum IfcPointOnCurve::Class() { return Type::IfcPointOnCurve; } -IfcPointOnCurve::IfcPointOnCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcPointOnCurve)) throw; entity = e; } +IfcPointOnCurve::IfcPointOnCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcPointOnCurve)) throw; entity = e; } // IfcPointOnSurface SHARED_PTR IfcPointOnSurface::BasisSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcParameterValue IfcPointOnSurface::PointParameterU() { return *entity->getArgument(1); } @@ -7068,26 +7067,26 @@ IfcParameterValue IfcPointOnSurface::PointParameterV() { return *entity->getArgu bool IfcPointOnSurface::is(Type::Enum v) { return v == Type::IfcPointOnSurface || IfcPoint::is(v); } Type::Enum IfcPointOnSurface::type() { return Type::IfcPointOnSurface; } Type::Enum IfcPointOnSurface::Class() { return Type::IfcPointOnSurface; } -IfcPointOnSurface::IfcPointOnSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcPointOnSurface)) throw; entity = e; } +IfcPointOnSurface::IfcPointOnSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcPointOnSurface)) throw; entity = e; } // IfcPolyLoop SHARED_PTR< IfcTemplatedEntityList > IfcPolyLoop::Polygon() { RETURN_AS_LIST(IfcCartesianPoint,0) } bool IfcPolyLoop::is(Type::Enum v) { return v == Type::IfcPolyLoop || IfcLoop::is(v); } Type::Enum IfcPolyLoop::type() { return Type::IfcPolyLoop; } Type::Enum IfcPolyLoop::Class() { return Type::IfcPolyLoop; } -IfcPolyLoop::IfcPolyLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolyLoop)) throw; entity = e; } +IfcPolyLoop::IfcPolyLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolyLoop)) throw; entity = e; } // IfcPolygonalBoundedHalfSpace SHARED_PTR IfcPolygonalBoundedHalfSpace::Position() { return reinterpret_pointer_cast(*entity->getArgument(2)); } SHARED_PTR IfcPolygonalBoundedHalfSpace::PolygonalBoundary() { return reinterpret_pointer_cast(*entity->getArgument(3)); } bool IfcPolygonalBoundedHalfSpace::is(Type::Enum v) { return v == Type::IfcPolygonalBoundedHalfSpace || IfcHalfSpaceSolid::is(v); } Type::Enum IfcPolygonalBoundedHalfSpace::type() { return Type::IfcPolygonalBoundedHalfSpace; } Type::Enum IfcPolygonalBoundedHalfSpace::Class() { return Type::IfcPolygonalBoundedHalfSpace; } -IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolygonalBoundedHalfSpace)) throw; entity = e; } +IfcPolygonalBoundedHalfSpace::IfcPolygonalBoundedHalfSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolygonalBoundedHalfSpace)) throw; entity = e; } // IfcPolyline SHARED_PTR< IfcTemplatedEntityList > IfcPolyline::Points() { RETURN_AS_LIST(IfcCartesianPoint,0) } bool IfcPolyline::is(Type::Enum v) { return v == Type::IfcPolyline || IfcBoundedCurve::is(v); } Type::Enum IfcPolyline::type() { return Type::IfcPolyline; } Type::Enum IfcPolyline::Class() { return Type::IfcPolyline; } -IfcPolyline::IfcPolyline(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolyline)) throw; entity = e; } +IfcPolyline::IfcPolyline(IfcAbstractEntityPtr e) { if (!is(Type::IfcPolyline)) throw; entity = e; } // IfcPort IfcRelConnectsPortToElement::list IfcPort::ContainedIn() { RETURN_INVERSE(IfcRelConnectsPortToElement) } IfcRelConnectsPorts::list IfcPort::ConnectedFrom() { RETURN_INVERSE(IfcRelConnectsPorts) } @@ -7095,12 +7094,12 @@ IfcRelConnectsPorts::list IfcPort::ConnectedTo() { RETURN_INVERSE(IfcRelConnects bool IfcPort::is(Type::Enum v) { return v == Type::IfcPort || IfcProduct::is(v); } Type::Enum IfcPort::type() { return Type::IfcPort; } Type::Enum IfcPort::Class() { return Type::IfcPort; } -IfcPort::IfcPort(IfcAbstractEntityPtr e) { if (!is(Type::IfcPort)) throw; entity = e; } +IfcPort::IfcPort(IfcAbstractEntityPtr e) { if (!is(Type::IfcPort)) throw; entity = e; } // IfcPostalAddress bool IfcPostalAddress::hasInternalLocation() { return !entity->getArgument(3)->isNull(); } IfcLabel IfcPostalAddress::InternalLocation() { return *entity->getArgument(3); } bool IfcPostalAddress::hasAddressLines() { return !entity->getArgument(4)->isNull(); } -std::vector IfcPostalAddress::AddressLines() { return *entity->getArgument(4); } +std::vector /*[1:?]*/ IfcPostalAddress::AddressLines() { return *entity->getArgument(4); } bool IfcPostalAddress::hasPostalBox() { return !entity->getArgument(5)->isNull(); } IfcLabel IfcPostalAddress::PostalBox() { return *entity->getArgument(5); } bool IfcPostalAddress::hasTown() { return !entity->getArgument(6)->isNull(); } @@ -7114,48 +7113,48 @@ IfcLabel IfcPostalAddress::Country() { return *entity->getArgument(9); } bool IfcPostalAddress::is(Type::Enum v) { return v == Type::IfcPostalAddress || IfcAddress::is(v); } Type::Enum IfcPostalAddress::type() { return Type::IfcPostalAddress; } Type::Enum IfcPostalAddress::Class() { return Type::IfcPostalAddress; } -IfcPostalAddress::IfcPostalAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcPostalAddress)) throw; entity = e; } +IfcPostalAddress::IfcPostalAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcPostalAddress)) throw; entity = e; } // IfcPreDefinedColour bool IfcPreDefinedColour::is(Type::Enum v) { return v == Type::IfcPreDefinedColour || IfcPreDefinedItem::is(v); } Type::Enum IfcPreDefinedColour::type() { return Type::IfcPreDefinedColour; } Type::Enum IfcPreDefinedColour::Class() { return Type::IfcPreDefinedColour; } -IfcPreDefinedColour::IfcPreDefinedColour(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedColour)) throw; entity = e; } +IfcPreDefinedColour::IfcPreDefinedColour(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedColour)) throw; entity = e; } // IfcPreDefinedCurveFont bool IfcPreDefinedCurveFont::is(Type::Enum v) { return v == Type::IfcPreDefinedCurveFont || IfcPreDefinedItem::is(v); } Type::Enum IfcPreDefinedCurveFont::type() { return Type::IfcPreDefinedCurveFont; } Type::Enum IfcPreDefinedCurveFont::Class() { return Type::IfcPreDefinedCurveFont; } -IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedCurveFont)) throw; entity = e; } +IfcPreDefinedCurveFont::IfcPreDefinedCurveFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedCurveFont)) throw; entity = e; } // IfcPreDefinedDimensionSymbol bool IfcPreDefinedDimensionSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedDimensionSymbol || IfcPreDefinedSymbol::is(v); } Type::Enum IfcPreDefinedDimensionSymbol::type() { return Type::IfcPreDefinedDimensionSymbol; } Type::Enum IfcPreDefinedDimensionSymbol::Class() { return Type::IfcPreDefinedDimensionSymbol; } -IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedDimensionSymbol)) throw; entity = e; } +IfcPreDefinedDimensionSymbol::IfcPreDefinedDimensionSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedDimensionSymbol)) throw; entity = e; } // IfcPreDefinedItem IfcLabel IfcPreDefinedItem::Name() { return *entity->getArgument(0); } bool IfcPreDefinedItem::is(Type::Enum v) { return v == Type::IfcPreDefinedItem; } Type::Enum IfcPreDefinedItem::type() { return Type::IfcPreDefinedItem; } Type::Enum IfcPreDefinedItem::Class() { return Type::IfcPreDefinedItem; } -IfcPreDefinedItem::IfcPreDefinedItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedItem)) throw; entity = e; } +IfcPreDefinedItem::IfcPreDefinedItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedItem)) throw; entity = e; } // IfcPreDefinedPointMarkerSymbol bool IfcPreDefinedPointMarkerSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedPointMarkerSymbol || IfcPreDefinedSymbol::is(v); } Type::Enum IfcPreDefinedPointMarkerSymbol::type() { return Type::IfcPreDefinedPointMarkerSymbol; } Type::Enum IfcPreDefinedPointMarkerSymbol::Class() { return Type::IfcPreDefinedPointMarkerSymbol; } -IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedPointMarkerSymbol)) throw; entity = e; } +IfcPreDefinedPointMarkerSymbol::IfcPreDefinedPointMarkerSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedPointMarkerSymbol)) throw; entity = e; } // IfcPreDefinedSymbol bool IfcPreDefinedSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedSymbol || IfcPreDefinedItem::is(v); } Type::Enum IfcPreDefinedSymbol::type() { return Type::IfcPreDefinedSymbol; } Type::Enum IfcPreDefinedSymbol::Class() { return Type::IfcPreDefinedSymbol; } -IfcPreDefinedSymbol::IfcPreDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedSymbol)) throw; entity = e; } +IfcPreDefinedSymbol::IfcPreDefinedSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedSymbol)) throw; entity = e; } // IfcPreDefinedTerminatorSymbol bool IfcPreDefinedTerminatorSymbol::is(Type::Enum v) { return v == Type::IfcPreDefinedTerminatorSymbol || IfcPreDefinedSymbol::is(v); } Type::Enum IfcPreDefinedTerminatorSymbol::type() { return Type::IfcPreDefinedTerminatorSymbol; } Type::Enum IfcPreDefinedTerminatorSymbol::Class() { return Type::IfcPreDefinedTerminatorSymbol; } -IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedTerminatorSymbol)) throw; entity = e; } +IfcPreDefinedTerminatorSymbol::IfcPreDefinedTerminatorSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedTerminatorSymbol)) throw; entity = e; } // IfcPreDefinedTextFont bool IfcPreDefinedTextFont::is(Type::Enum v) { return v == Type::IfcPreDefinedTextFont || IfcPreDefinedItem::is(v); } Type::Enum IfcPreDefinedTextFont::type() { return Type::IfcPreDefinedTextFont; } Type::Enum IfcPreDefinedTextFont::Class() { return Type::IfcPreDefinedTextFont; } -IfcPreDefinedTextFont::IfcPreDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedTextFont)) throw; entity = e; } +IfcPreDefinedTextFont::IfcPreDefinedTextFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcPreDefinedTextFont)) throw; entity = e; } // IfcPresentationLayerAssignment IfcLabel IfcPresentationLayerAssignment::Name() { return *entity->getArgument(0); } bool IfcPresentationLayerAssignment::hasDescription() { return !entity->getArgument(1)->isNull(); } @@ -7166,7 +7165,7 @@ IfcIdentifier IfcPresentationLayerAssignment::Identifier() { return *entity->get bool IfcPresentationLayerAssignment::is(Type::Enum v) { return v == Type::IfcPresentationLayerAssignment; } Type::Enum IfcPresentationLayerAssignment::type() { return Type::IfcPresentationLayerAssignment; } Type::Enum IfcPresentationLayerAssignment::Class() { return Type::IfcPresentationLayerAssignment; } -IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationLayerAssignment)) throw; entity = e; } +IfcPresentationLayerAssignment::IfcPresentationLayerAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationLayerAssignment)) throw; entity = e; } // IfcPresentationLayerWithStyle bool IfcPresentationLayerWithStyle::LayerOn() { return *entity->getArgument(4); } bool IfcPresentationLayerWithStyle::LayerFrozen() { return *entity->getArgument(5); } @@ -7175,20 +7174,20 @@ SHARED_PTR< IfcTemplatedEntityList > IfcPresentationLayerWith bool IfcPresentationLayerWithStyle::is(Type::Enum v) { return v == Type::IfcPresentationLayerWithStyle || IfcPresentationLayerAssignment::is(v); } Type::Enum IfcPresentationLayerWithStyle::type() { return Type::IfcPresentationLayerWithStyle; } Type::Enum IfcPresentationLayerWithStyle::Class() { return Type::IfcPresentationLayerWithStyle; } -IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationLayerWithStyle)) throw; entity = e; } +IfcPresentationLayerWithStyle::IfcPresentationLayerWithStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationLayerWithStyle)) throw; entity = e; } // IfcPresentationStyle bool IfcPresentationStyle::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcPresentationStyle::Name() { return *entity->getArgument(0); } bool IfcPresentationStyle::is(Type::Enum v) { return v == Type::IfcPresentationStyle; } Type::Enum IfcPresentationStyle::type() { return Type::IfcPresentationStyle; } Type::Enum IfcPresentationStyle::Class() { return Type::IfcPresentationStyle; } -IfcPresentationStyle::IfcPresentationStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationStyle)) throw; entity = e; } +IfcPresentationStyle::IfcPresentationStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationStyle)) throw; entity = e; } // IfcPresentationStyleAssignment SHARED_PTR< IfcTemplatedEntityList > IfcPresentationStyleAssignment::Styles() { RETURN_AS_LIST(IfcAbstractSelect,0) } bool IfcPresentationStyleAssignment::is(Type::Enum v) { return v == Type::IfcPresentationStyleAssignment; } Type::Enum IfcPresentationStyleAssignment::type() { return Type::IfcPresentationStyleAssignment; } Type::Enum IfcPresentationStyleAssignment::Class() { return Type::IfcPresentationStyleAssignment; } -IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationStyleAssignment)) throw; entity = e; } +IfcPresentationStyleAssignment::IfcPresentationStyleAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcPresentationStyleAssignment)) throw; entity = e; } // IfcProcedure IfcIdentifier IfcProcedure::ProcedureID() { return *entity->getArgument(5); } IfcProcedureTypeEnum::IfcProcedureTypeEnum IfcProcedure::ProcedureType() { return IfcProcedureTypeEnum::FromString(*entity->getArgument(6)); } @@ -7197,7 +7196,7 @@ IfcLabel IfcProcedure::UserDefinedProcedureType() { return *entity->getArgument( bool IfcProcedure::is(Type::Enum v) { return v == Type::IfcProcedure || IfcProcess::is(v); } Type::Enum IfcProcedure::type() { return Type::IfcProcedure; } Type::Enum IfcProcedure::Class() { return Type::IfcProcedure; } -IfcProcedure::IfcProcedure(IfcAbstractEntityPtr e) { if (!is(Type::IfcProcedure)) throw; entity = e; } +IfcProcedure::IfcProcedure(IfcAbstractEntityPtr e) { if (!is(Type::IfcProcedure)) throw; entity = e; } // IfcProcess IfcRelAssignsToProcess::list IfcProcess::OperatesOn() { RETURN_INVERSE(IfcRelAssignsToProcess) } IfcRelSequence::list IfcProcess::IsSuccessorFrom() { RETURN_INVERSE(IfcRelSequence) } @@ -7205,7 +7204,7 @@ IfcRelSequence::list IfcProcess::IsPredecessorTo() { RETURN_INVERSE(IfcRelSequen bool IfcProcess::is(Type::Enum v) { return v == Type::IfcProcess || IfcObject::is(v); } Type::Enum IfcProcess::type() { return Type::IfcProcess; } Type::Enum IfcProcess::Class() { return Type::IfcProcess; } -IfcProcess::IfcProcess(IfcAbstractEntityPtr e) { if (!is(Type::IfcProcess)) throw; entity = e; } +IfcProcess::IfcProcess(IfcAbstractEntityPtr e) { if (!is(Type::IfcProcess)) throw; entity = e; } // IfcProduct bool IfcProduct::hasObjectPlacement() { return !entity->getArgument(5)->isNull(); } SHARED_PTR IfcProduct::ObjectPlacement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } @@ -7215,14 +7214,14 @@ IfcRelAssignsToProduct::list IfcProduct::ReferencedBy() { RETURN_INVERSE(IfcRelA bool IfcProduct::is(Type::Enum v) { return v == Type::IfcProduct || IfcObject::is(v); } Type::Enum IfcProduct::type() { return Type::IfcProduct; } Type::Enum IfcProduct::Class() { return Type::IfcProduct; } -IfcProduct::IfcProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcProduct)) throw; entity = e; } +IfcProduct::IfcProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcProduct)) throw; entity = e; } // IfcProductDefinitionShape IfcProduct::list IfcProductDefinitionShape::ShapeOfProduct() { RETURN_INVERSE(IfcProduct) } IfcShapeAspect::list IfcProductDefinitionShape::HasShapeAspects() { RETURN_INVERSE(IfcShapeAspect) } bool IfcProductDefinitionShape::is(Type::Enum v) { return v == Type::IfcProductDefinitionShape || IfcProductRepresentation::is(v); } Type::Enum IfcProductDefinitionShape::type() { return Type::IfcProductDefinitionShape; } Type::Enum IfcProductDefinitionShape::Class() { return Type::IfcProductDefinitionShape; } -IfcProductDefinitionShape::IfcProductDefinitionShape(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductDefinitionShape)) throw; entity = e; } +IfcProductDefinitionShape::IfcProductDefinitionShape(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductDefinitionShape)) throw; entity = e; } // IfcProductRepresentation bool IfcProductRepresentation::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcProductRepresentation::Name() { return *entity->getArgument(0); } @@ -7232,7 +7231,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcProductRepresentation bool IfcProductRepresentation::is(Type::Enum v) { return v == Type::IfcProductRepresentation; } Type::Enum IfcProductRepresentation::type() { return Type::IfcProductRepresentation; } Type::Enum IfcProductRepresentation::Class() { return Type::IfcProductRepresentation; } -IfcProductRepresentation::IfcProductRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductRepresentation)) throw; entity = e; } +IfcProductRepresentation::IfcProductRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductRepresentation)) throw; entity = e; } // IfcProductsOfCombustionProperties bool IfcProductsOfCombustionProperties::hasSpecificHeatCapacity() { return !entity->getArgument(1)->isNull(); } IfcSpecificHeatCapacityMeasure IfcProductsOfCombustionProperties::SpecificHeatCapacity() { return *entity->getArgument(1); } @@ -7245,7 +7244,7 @@ IfcPositiveRatioMeasure IfcProductsOfCombustionProperties::CO2Content() { return bool IfcProductsOfCombustionProperties::is(Type::Enum v) { return v == Type::IfcProductsOfCombustionProperties || IfcMaterialProperties::is(v); } Type::Enum IfcProductsOfCombustionProperties::type() { return Type::IfcProductsOfCombustionProperties; } Type::Enum IfcProductsOfCombustionProperties::Class() { return Type::IfcProductsOfCombustionProperties; } -IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductsOfCombustionProperties)) throw; entity = e; } +IfcProductsOfCombustionProperties::IfcProductsOfCombustionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcProductsOfCombustionProperties)) throw; entity = e; } // IfcProfileDef IfcProfileTypeEnum::IfcProfileTypeEnum IfcProfileDef::ProfileType() { return IfcProfileTypeEnum::FromString(*entity->getArgument(0)); } bool IfcProfileDef::hasProfileName() { return !entity->getArgument(1)->isNull(); } @@ -7253,7 +7252,7 @@ IfcLabel IfcProfileDef::ProfileName() { return *entity->getArgument(1); } bool IfcProfileDef::is(Type::Enum v) { return v == Type::IfcProfileDef; } Type::Enum IfcProfileDef::type() { return Type::IfcProfileDef; } Type::Enum IfcProfileDef::Class() { return Type::IfcProfileDef; } -IfcProfileDef::IfcProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcProfileDef)) throw; entity = e; } +IfcProfileDef::IfcProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcProfileDef)) throw; entity = e; } // IfcProfileProperties bool IfcProfileProperties::hasProfileName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcProfileProperties::ProfileName() { return *entity->getArgument(0); } @@ -7262,7 +7261,7 @@ SHARED_PTR IfcProfileProperties::ProfileDefinition() { return rei bool IfcProfileProperties::is(Type::Enum v) { return v == Type::IfcProfileProperties; } Type::Enum IfcProfileProperties::type() { return Type::IfcProfileProperties; } Type::Enum IfcProfileProperties::Class() { return Type::IfcProfileProperties; } -IfcProfileProperties::IfcProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcProfileProperties)) throw; entity = e; } +IfcProfileProperties::IfcProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcProfileProperties)) throw; entity = e; } // IfcProject bool IfcProject::hasLongName() { return !entity->getArgument(5)->isNull(); } IfcLabel IfcProject::LongName() { return *entity->getArgument(5); } @@ -7273,7 +7272,7 @@ SHARED_PTR IfcProject::UnitsInContext() { return reinterpret_ bool IfcProject::is(Type::Enum v) { return v == Type::IfcProject || IfcObject::is(v); } Type::Enum IfcProject::type() { return Type::IfcProject; } Type::Enum IfcProject::Class() { return Type::IfcProject; } -IfcProject::IfcProject(IfcAbstractEntityPtr e) { if (!is(Type::IfcProject)) throw; entity = e; } +IfcProject::IfcProject(IfcAbstractEntityPtr e) { if (!is(Type::IfcProject)) throw; entity = e; } // IfcProjectOrder IfcIdentifier IfcProjectOrder::ID() { return *entity->getArgument(5); } IfcProjectOrderTypeEnum::IfcProjectOrderTypeEnum IfcProjectOrder::PredefinedType() { return IfcProjectOrderTypeEnum::FromString(*entity->getArgument(6)); } @@ -7282,24 +7281,24 @@ IfcLabel IfcProjectOrder::Status() { return *entity->getArgument(7); } bool IfcProjectOrder::is(Type::Enum v) { return v == Type::IfcProjectOrder || IfcControl::is(v); } Type::Enum IfcProjectOrder::type() { return Type::IfcProjectOrder; } Type::Enum IfcProjectOrder::Class() { return Type::IfcProjectOrder; } -IfcProjectOrder::IfcProjectOrder(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectOrder)) throw; entity = e; } +IfcProjectOrder::IfcProjectOrder(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectOrder)) throw; entity = e; } // IfcProjectOrderRecord SHARED_PTR< IfcTemplatedEntityList > IfcProjectOrderRecord::Records() { RETURN_AS_LIST(IfcRelAssignsToProjectOrder,5) } IfcProjectOrderRecordTypeEnum::IfcProjectOrderRecordTypeEnum IfcProjectOrderRecord::PredefinedType() { return IfcProjectOrderRecordTypeEnum::FromString(*entity->getArgument(6)); } bool IfcProjectOrderRecord::is(Type::Enum v) { return v == Type::IfcProjectOrderRecord || IfcControl::is(v); } Type::Enum IfcProjectOrderRecord::type() { return Type::IfcProjectOrderRecord; } Type::Enum IfcProjectOrderRecord::Class() { return Type::IfcProjectOrderRecord; } -IfcProjectOrderRecord::IfcProjectOrderRecord(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectOrderRecord)) throw; entity = e; } +IfcProjectOrderRecord::IfcProjectOrderRecord(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectOrderRecord)) throw; entity = e; } // IfcProjectionCurve bool IfcProjectionCurve::is(Type::Enum v) { return v == Type::IfcProjectionCurve || IfcAnnotationCurveOccurrence::is(v); } Type::Enum IfcProjectionCurve::type() { return Type::IfcProjectionCurve; } Type::Enum IfcProjectionCurve::Class() { return Type::IfcProjectionCurve; } -IfcProjectionCurve::IfcProjectionCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectionCurve)) throw; entity = e; } +IfcProjectionCurve::IfcProjectionCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectionCurve)) throw; entity = e; } // IfcProjectionElement bool IfcProjectionElement::is(Type::Enum v) { return v == Type::IfcProjectionElement || IfcFeatureElementAddition::is(v); } Type::Enum IfcProjectionElement::type() { return Type::IfcProjectionElement; } Type::Enum IfcProjectionElement::Class() { return Type::IfcProjectionElement; } -IfcProjectionElement::IfcProjectionElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectionElement)) throw; entity = e; } +IfcProjectionElement::IfcProjectionElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcProjectionElement)) throw; entity = e; } // IfcProperty IfcIdentifier IfcProperty::Name() { return *entity->getArgument(0); } bool IfcProperty::hasDescription() { return !entity->getArgument(1)->isNull(); } @@ -7310,7 +7309,7 @@ IfcComplexProperty::list IfcProperty::PartOfComplex() { RETURN_INVERSE(IfcComple bool IfcProperty::is(Type::Enum v) { return v == Type::IfcProperty; } Type::Enum IfcProperty::type() { return Type::IfcProperty; } Type::Enum IfcProperty::Class() { return Type::IfcProperty; } -IfcProperty::IfcProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcProperty)) throw; entity = e; } +IfcProperty::IfcProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcProperty)) throw; entity = e; } // IfcPropertyBoundedValue bool IfcPropertyBoundedValue::hasUpperBoundValue() { return !entity->getArgument(2)->isNull(); } IfcValue IfcPropertyBoundedValue::UpperBoundValue() { return *entity->getArgument(2); } @@ -7321,7 +7320,7 @@ IfcUnit IfcPropertyBoundedValue::Unit() { return *entity->getArgument(4); } bool IfcPropertyBoundedValue::is(Type::Enum v) { return v == Type::IfcPropertyBoundedValue || IfcSimpleProperty::is(v); } Type::Enum IfcPropertyBoundedValue::type() { return Type::IfcPropertyBoundedValue; } Type::Enum IfcPropertyBoundedValue::Class() { return Type::IfcPropertyBoundedValue; } -IfcPropertyBoundedValue::IfcPropertyBoundedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyBoundedValue)) throw; entity = e; } +IfcPropertyBoundedValue::IfcPropertyBoundedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyBoundedValue)) throw; entity = e; } // IfcPropertyConstraintRelationship SHARED_PTR IfcPropertyConstraintRelationship::RelatingConstraint() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcPropertyConstraintRelationship::RelatedProperties() { RETURN_AS_LIST(IfcProperty,1) } @@ -7332,13 +7331,13 @@ IfcText IfcPropertyConstraintRelationship::Description() { return *entity->getAr bool IfcPropertyConstraintRelationship::is(Type::Enum v) { return v == Type::IfcPropertyConstraintRelationship; } Type::Enum IfcPropertyConstraintRelationship::type() { return Type::IfcPropertyConstraintRelationship; } Type::Enum IfcPropertyConstraintRelationship::Class() { return Type::IfcPropertyConstraintRelationship; } -IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyConstraintRelationship)) throw; entity = e; } +IfcPropertyConstraintRelationship::IfcPropertyConstraintRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyConstraintRelationship)) throw; entity = e; } // IfcPropertyDefinition IfcRelAssociates::list IfcPropertyDefinition::HasAssociations() { RETURN_INVERSE(IfcRelAssociates) } bool IfcPropertyDefinition::is(Type::Enum v) { return v == Type::IfcPropertyDefinition || IfcRoot::is(v); } Type::Enum IfcPropertyDefinition::type() { return Type::IfcPropertyDefinition; } Type::Enum IfcPropertyDefinition::Class() { return Type::IfcPropertyDefinition; } -IfcPropertyDefinition::IfcPropertyDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyDefinition)) throw; entity = e; } +IfcPropertyDefinition::IfcPropertyDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyDefinition)) throw; entity = e; } // IfcPropertyDependencyRelationship SHARED_PTR IfcPropertyDependencyRelationship::DependingProperty() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcPropertyDependencyRelationship::DependantProperty() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -7351,7 +7350,7 @@ IfcText IfcPropertyDependencyRelationship::Expression() { return *entity->getArg bool IfcPropertyDependencyRelationship::is(Type::Enum v) { return v == Type::IfcPropertyDependencyRelationship; } Type::Enum IfcPropertyDependencyRelationship::type() { return Type::IfcPropertyDependencyRelationship; } Type::Enum IfcPropertyDependencyRelationship::Class() { return Type::IfcPropertyDependencyRelationship; } -IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyDependencyRelationship)) throw; entity = e; } +IfcPropertyDependencyRelationship::IfcPropertyDependencyRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyDependencyRelationship)) throw; entity = e; } // IfcPropertyEnumeratedValue SHARED_PTR< IfcTemplatedEntityList > IfcPropertyEnumeratedValue::EnumerationValues() { RETURN_AS_LIST(IfcAbstractSelect,2) } bool IfcPropertyEnumeratedValue::hasEnumerationReference() { return !entity->getArgument(3)->isNull(); } @@ -7359,7 +7358,7 @@ SHARED_PTR IfcPropertyEnumeratedValue::EnumerationRefere bool IfcPropertyEnumeratedValue::is(Type::Enum v) { return v == Type::IfcPropertyEnumeratedValue || IfcSimpleProperty::is(v); } Type::Enum IfcPropertyEnumeratedValue::type() { return Type::IfcPropertyEnumeratedValue; } Type::Enum IfcPropertyEnumeratedValue::Class() { return Type::IfcPropertyEnumeratedValue; } -IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyEnumeratedValue)) throw; entity = e; } +IfcPropertyEnumeratedValue::IfcPropertyEnumeratedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyEnumeratedValue)) throw; entity = e; } // IfcPropertyEnumeration IfcLabel IfcPropertyEnumeration::Name() { return *entity->getArgument(0); } SHARED_PTR< IfcTemplatedEntityList > IfcPropertyEnumeration::EnumerationValues() { RETURN_AS_LIST(IfcAbstractSelect,1) } @@ -7368,7 +7367,7 @@ IfcUnit IfcPropertyEnumeration::Unit() { return *entity->getArgument(2); } bool IfcPropertyEnumeration::is(Type::Enum v) { return v == Type::IfcPropertyEnumeration; } Type::Enum IfcPropertyEnumeration::type() { return Type::IfcPropertyEnumeration; } Type::Enum IfcPropertyEnumeration::Class() { return Type::IfcPropertyEnumeration; } -IfcPropertyEnumeration::IfcPropertyEnumeration(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyEnumeration)) throw; entity = e; } +IfcPropertyEnumeration::IfcPropertyEnumeration(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyEnumeration)) throw; entity = e; } // IfcPropertyListValue SHARED_PTR< IfcTemplatedEntityList > IfcPropertyListValue::ListValues() { RETURN_AS_LIST(IfcAbstractSelect,2) } bool IfcPropertyListValue::hasUnit() { return !entity->getArgument(3)->isNull(); } @@ -7376,7 +7375,7 @@ IfcUnit IfcPropertyListValue::Unit() { return *entity->getArgument(3); } bool IfcPropertyListValue::is(Type::Enum v) { return v == Type::IfcPropertyListValue || IfcSimpleProperty::is(v); } Type::Enum IfcPropertyListValue::type() { return Type::IfcPropertyListValue; } Type::Enum IfcPropertyListValue::Class() { return Type::IfcPropertyListValue; } -IfcPropertyListValue::IfcPropertyListValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyListValue)) throw; entity = e; } +IfcPropertyListValue::IfcPropertyListValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyListValue)) throw; entity = e; } // IfcPropertyReferenceValue bool IfcPropertyReferenceValue::hasUsageName() { return !entity->getArgument(2)->isNull(); } IfcLabel IfcPropertyReferenceValue::UsageName() { return *entity->getArgument(2); } @@ -7384,20 +7383,20 @@ IfcObjectReferenceSelect IfcPropertyReferenceValue::PropertyReference() { return bool IfcPropertyReferenceValue::is(Type::Enum v) { return v == Type::IfcPropertyReferenceValue || IfcSimpleProperty::is(v); } Type::Enum IfcPropertyReferenceValue::type() { return Type::IfcPropertyReferenceValue; } Type::Enum IfcPropertyReferenceValue::Class() { return Type::IfcPropertyReferenceValue; } -IfcPropertyReferenceValue::IfcPropertyReferenceValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyReferenceValue)) throw; entity = e; } +IfcPropertyReferenceValue::IfcPropertyReferenceValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyReferenceValue)) throw; entity = e; } // IfcPropertySet SHARED_PTR< IfcTemplatedEntityList > IfcPropertySet::HasProperties() { RETURN_AS_LIST(IfcProperty,4) } bool IfcPropertySet::is(Type::Enum v) { return v == Type::IfcPropertySet || IfcPropertySetDefinition::is(v); } Type::Enum IfcPropertySet::type() { return Type::IfcPropertySet; } Type::Enum IfcPropertySet::Class() { return Type::IfcPropertySet; } -IfcPropertySet::IfcPropertySet(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySet)) throw; entity = e; } +IfcPropertySet::IfcPropertySet(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySet)) throw; entity = e; } // IfcPropertySetDefinition IfcRelDefinesByProperties::list IfcPropertySetDefinition::PropertyDefinitionOf() { RETURN_INVERSE(IfcRelDefinesByProperties) } IfcTypeObject::list IfcPropertySetDefinition::DefinesType() { RETURN_INVERSE(IfcTypeObject) } bool IfcPropertySetDefinition::is(Type::Enum v) { return v == Type::IfcPropertySetDefinition || IfcPropertyDefinition::is(v); } Type::Enum IfcPropertySetDefinition::type() { return Type::IfcPropertySetDefinition; } Type::Enum IfcPropertySetDefinition::Class() { return Type::IfcPropertySetDefinition; } -IfcPropertySetDefinition::IfcPropertySetDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySetDefinition)) throw; entity = e; } +IfcPropertySetDefinition::IfcPropertySetDefinition(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySetDefinition)) throw; entity = e; } // IfcPropertySingleValue bool IfcPropertySingleValue::hasNominalValue() { return !entity->getArgument(2)->isNull(); } IfcValue IfcPropertySingleValue::NominalValue() { return *entity->getArgument(2); } @@ -7406,7 +7405,7 @@ IfcUnit IfcPropertySingleValue::Unit() { return *entity->getArgument(3); } bool IfcPropertySingleValue::is(Type::Enum v) { return v == Type::IfcPropertySingleValue || IfcSimpleProperty::is(v); } Type::Enum IfcPropertySingleValue::type() { return Type::IfcPropertySingleValue; } Type::Enum IfcPropertySingleValue::Class() { return Type::IfcPropertySingleValue; } -IfcPropertySingleValue::IfcPropertySingleValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySingleValue)) throw; entity = e; } +IfcPropertySingleValue::IfcPropertySingleValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertySingleValue)) throw; entity = e; } // IfcPropertyTableValue SHARED_PTR< IfcTemplatedEntityList > IfcPropertyTableValue::DefiningValues() { RETURN_AS_LIST(IfcAbstractSelect,2) } SHARED_PTR< IfcTemplatedEntityList > IfcPropertyTableValue::DefinedValues() { RETURN_AS_LIST(IfcAbstractSelect,3) } @@ -7419,13 +7418,13 @@ IfcUnit IfcPropertyTableValue::DefinedUnit() { return *entity->getArgument(6); } bool IfcPropertyTableValue::is(Type::Enum v) { return v == Type::IfcPropertyTableValue || IfcSimpleProperty::is(v); } Type::Enum IfcPropertyTableValue::type() { return Type::IfcPropertyTableValue; } Type::Enum IfcPropertyTableValue::Class() { return Type::IfcPropertyTableValue; } -IfcPropertyTableValue::IfcPropertyTableValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyTableValue)) throw; entity = e; } +IfcPropertyTableValue::IfcPropertyTableValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcPropertyTableValue)) throw; entity = e; } // IfcProtectiveDeviceType IfcProtectiveDeviceTypeEnum::IfcProtectiveDeviceTypeEnum IfcProtectiveDeviceType::PredefinedType() { return IfcProtectiveDeviceTypeEnum::FromString(*entity->getArgument(9)); } bool IfcProtectiveDeviceType::is(Type::Enum v) { return v == Type::IfcProtectiveDeviceType || IfcFlowControllerType::is(v); } Type::Enum IfcProtectiveDeviceType::type() { return Type::IfcProtectiveDeviceType; } Type::Enum IfcProtectiveDeviceType::Class() { return Type::IfcProtectiveDeviceType; } -IfcProtectiveDeviceType::IfcProtectiveDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcProtectiveDeviceType)) throw; entity = e; } +IfcProtectiveDeviceType::IfcProtectiveDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcProtectiveDeviceType)) throw; entity = e; } // IfcProxy IfcObjectTypeEnum::IfcObjectTypeEnum IfcProxy::ProxyType() { return IfcObjectTypeEnum::FromString(*entity->getArgument(7)); } bool IfcProxy::hasTag() { return !entity->getArgument(8)->isNull(); } @@ -7433,90 +7432,90 @@ IfcLabel IfcProxy::Tag() { return *entity->getArgument(8); } bool IfcProxy::is(Type::Enum v) { return v == Type::IfcProxy || IfcProduct::is(v); } Type::Enum IfcProxy::type() { return Type::IfcProxy; } Type::Enum IfcProxy::Class() { return Type::IfcProxy; } -IfcProxy::IfcProxy(IfcAbstractEntityPtr e) { if (!is(Type::IfcProxy)) throw; entity = e; } +IfcProxy::IfcProxy(IfcAbstractEntityPtr e) { if (!is(Type::IfcProxy)) throw; entity = e; } // IfcPumpType IfcPumpTypeEnum::IfcPumpTypeEnum IfcPumpType::PredefinedType() { return IfcPumpTypeEnum::FromString(*entity->getArgument(9)); } bool IfcPumpType::is(Type::Enum v) { return v == Type::IfcPumpType || IfcFlowMovingDeviceType::is(v); } Type::Enum IfcPumpType::type() { return Type::IfcPumpType; } Type::Enum IfcPumpType::Class() { return Type::IfcPumpType; } -IfcPumpType::IfcPumpType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPumpType)) throw; entity = e; } +IfcPumpType::IfcPumpType(IfcAbstractEntityPtr e) { if (!is(Type::IfcPumpType)) throw; entity = e; } // IfcQuantityArea IfcAreaMeasure IfcQuantityArea::AreaValue() { return *entity->getArgument(3); } bool IfcQuantityArea::is(Type::Enum v) { return v == Type::IfcQuantityArea || IfcPhysicalSimpleQuantity::is(v); } Type::Enum IfcQuantityArea::type() { return Type::IfcQuantityArea; } Type::Enum IfcQuantityArea::Class() { return Type::IfcQuantityArea; } -IfcQuantityArea::IfcQuantityArea(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityArea)) throw; entity = e; } +IfcQuantityArea::IfcQuantityArea(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityArea)) throw; entity = e; } // IfcQuantityCount IfcCountMeasure IfcQuantityCount::CountValue() { return *entity->getArgument(3); } bool IfcQuantityCount::is(Type::Enum v) { return v == Type::IfcQuantityCount || IfcPhysicalSimpleQuantity::is(v); } Type::Enum IfcQuantityCount::type() { return Type::IfcQuantityCount; } Type::Enum IfcQuantityCount::Class() { return Type::IfcQuantityCount; } -IfcQuantityCount::IfcQuantityCount(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityCount)) throw; entity = e; } +IfcQuantityCount::IfcQuantityCount(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityCount)) throw; entity = e; } // IfcQuantityLength IfcLengthMeasure IfcQuantityLength::LengthValue() { return *entity->getArgument(3); } bool IfcQuantityLength::is(Type::Enum v) { return v == Type::IfcQuantityLength || IfcPhysicalSimpleQuantity::is(v); } Type::Enum IfcQuantityLength::type() { return Type::IfcQuantityLength; } Type::Enum IfcQuantityLength::Class() { return Type::IfcQuantityLength; } -IfcQuantityLength::IfcQuantityLength(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityLength)) throw; entity = e; } +IfcQuantityLength::IfcQuantityLength(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityLength)) throw; entity = e; } // IfcQuantityTime IfcTimeMeasure IfcQuantityTime::TimeValue() { return *entity->getArgument(3); } bool IfcQuantityTime::is(Type::Enum v) { return v == Type::IfcQuantityTime || IfcPhysicalSimpleQuantity::is(v); } Type::Enum IfcQuantityTime::type() { return Type::IfcQuantityTime; } Type::Enum IfcQuantityTime::Class() { return Type::IfcQuantityTime; } -IfcQuantityTime::IfcQuantityTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityTime)) throw; entity = e; } +IfcQuantityTime::IfcQuantityTime(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityTime)) throw; entity = e; } // IfcQuantityVolume IfcVolumeMeasure IfcQuantityVolume::VolumeValue() { return *entity->getArgument(3); } bool IfcQuantityVolume::is(Type::Enum v) { return v == Type::IfcQuantityVolume || IfcPhysicalSimpleQuantity::is(v); } Type::Enum IfcQuantityVolume::type() { return Type::IfcQuantityVolume; } Type::Enum IfcQuantityVolume::Class() { return Type::IfcQuantityVolume; } -IfcQuantityVolume::IfcQuantityVolume(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityVolume)) throw; entity = e; } +IfcQuantityVolume::IfcQuantityVolume(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityVolume)) throw; entity = e; } // IfcQuantityWeight IfcMassMeasure IfcQuantityWeight::WeightValue() { return *entity->getArgument(3); } bool IfcQuantityWeight::is(Type::Enum v) { return v == Type::IfcQuantityWeight || IfcPhysicalSimpleQuantity::is(v); } Type::Enum IfcQuantityWeight::type() { return Type::IfcQuantityWeight; } Type::Enum IfcQuantityWeight::Class() { return Type::IfcQuantityWeight; } -IfcQuantityWeight::IfcQuantityWeight(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityWeight)) throw; entity = e; } +IfcQuantityWeight::IfcQuantityWeight(IfcAbstractEntityPtr e) { if (!is(Type::IfcQuantityWeight)) throw; entity = e; } // IfcRadiusDimension bool IfcRadiusDimension::is(Type::Enum v) { return v == Type::IfcRadiusDimension || IfcDimensionCurveDirectedCallout::is(v); } Type::Enum IfcRadiusDimension::type() { return Type::IfcRadiusDimension; } Type::Enum IfcRadiusDimension::Class() { return Type::IfcRadiusDimension; } -IfcRadiusDimension::IfcRadiusDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcRadiusDimension)) throw; entity = e; } +IfcRadiusDimension::IfcRadiusDimension(IfcAbstractEntityPtr e) { if (!is(Type::IfcRadiusDimension)) throw; entity = e; } // IfcRailing bool IfcRailing::hasPredefinedType() { return !entity->getArgument(8)->isNull(); } IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailing::PredefinedType() { return IfcRailingTypeEnum::FromString(*entity->getArgument(8)); } bool IfcRailing::is(Type::Enum v) { return v == Type::IfcRailing || IfcBuildingElement::is(v); } Type::Enum IfcRailing::type() { return Type::IfcRailing; } Type::Enum IfcRailing::Class() { return Type::IfcRailing; } -IfcRailing::IfcRailing(IfcAbstractEntityPtr e) { if (!is(Type::IfcRailing)) throw; entity = e; } +IfcRailing::IfcRailing(IfcAbstractEntityPtr e) { if (!is(Type::IfcRailing)) throw; entity = e; } // IfcRailingType IfcRailingTypeEnum::IfcRailingTypeEnum IfcRailingType::PredefinedType() { return IfcRailingTypeEnum::FromString(*entity->getArgument(9)); } bool IfcRailingType::is(Type::Enum v) { return v == Type::IfcRailingType || IfcBuildingElementType::is(v); } Type::Enum IfcRailingType::type() { return Type::IfcRailingType; } Type::Enum IfcRailingType::Class() { return Type::IfcRailingType; } -IfcRailingType::IfcRailingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRailingType)) throw; entity = e; } +IfcRailingType::IfcRailingType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRailingType)) throw; entity = e; } // IfcRamp IfcRampTypeEnum::IfcRampTypeEnum IfcRamp::ShapeType() { return IfcRampTypeEnum::FromString(*entity->getArgument(8)); } bool IfcRamp::is(Type::Enum v) { return v == Type::IfcRamp || IfcBuildingElement::is(v); } Type::Enum IfcRamp::type() { return Type::IfcRamp; } Type::Enum IfcRamp::Class() { return Type::IfcRamp; } -IfcRamp::IfcRamp(IfcAbstractEntityPtr e) { if (!is(Type::IfcRamp)) throw; entity = e; } +IfcRamp::IfcRamp(IfcAbstractEntityPtr e) { if (!is(Type::IfcRamp)) throw; entity = e; } // IfcRampFlight bool IfcRampFlight::is(Type::Enum v) { return v == Type::IfcRampFlight || IfcBuildingElement::is(v); } Type::Enum IfcRampFlight::type() { return Type::IfcRampFlight; } Type::Enum IfcRampFlight::Class() { return Type::IfcRampFlight; } -IfcRampFlight::IfcRampFlight(IfcAbstractEntityPtr e) { if (!is(Type::IfcRampFlight)) throw; entity = e; } +IfcRampFlight::IfcRampFlight(IfcAbstractEntityPtr e) { if (!is(Type::IfcRampFlight)) throw; entity = e; } // IfcRampFlightType IfcRampFlightTypeEnum::IfcRampFlightTypeEnum IfcRampFlightType::PredefinedType() { return IfcRampFlightTypeEnum::FromString(*entity->getArgument(9)); } bool IfcRampFlightType::is(Type::Enum v) { return v == Type::IfcRampFlightType || IfcBuildingElementType::is(v); } Type::Enum IfcRampFlightType::type() { return Type::IfcRampFlightType; } Type::Enum IfcRampFlightType::Class() { return Type::IfcRampFlightType; } -IfcRampFlightType::IfcRampFlightType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRampFlightType)) throw; entity = e; } +IfcRampFlightType::IfcRampFlightType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRampFlightType)) throw; entity = e; } // IfcRationalBezierCurve -std::vector IfcRationalBezierCurve::WeightsData() { return *entity->getArgument(5); } +std::vector /*[2:?]*/ IfcRationalBezierCurve::WeightsData() { return *entity->getArgument(5); } bool IfcRationalBezierCurve::is(Type::Enum v) { return v == Type::IfcRationalBezierCurve || IfcBezierCurve::is(v); } Type::Enum IfcRationalBezierCurve::type() { return Type::IfcRationalBezierCurve; } Type::Enum IfcRationalBezierCurve::Class() { return Type::IfcRationalBezierCurve; } -IfcRationalBezierCurve::IfcRationalBezierCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcRationalBezierCurve)) throw; entity = e; } +IfcRationalBezierCurve::IfcRationalBezierCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcRationalBezierCurve)) throw; entity = e; } // IfcRectangleHollowProfileDef IfcPositiveLengthMeasure IfcRectangleHollowProfileDef::WallThickness() { return *entity->getArgument(5); } bool IfcRectangleHollowProfileDef::hasInnerFilletRadius() { return !entity->getArgument(6)->isNull(); } @@ -7526,14 +7525,14 @@ IfcPositiveLengthMeasure IfcRectangleHollowProfileDef::OuterFilletRadius() { ret bool IfcRectangleHollowProfileDef::is(Type::Enum v) { return v == Type::IfcRectangleHollowProfileDef || IfcRectangleProfileDef::is(v); } Type::Enum IfcRectangleHollowProfileDef::type() { return Type::IfcRectangleHollowProfileDef; } Type::Enum IfcRectangleHollowProfileDef::Class() { return Type::IfcRectangleHollowProfileDef; } -IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangleHollowProfileDef)) throw; entity = e; } +IfcRectangleHollowProfileDef::IfcRectangleHollowProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangleHollowProfileDef)) throw; entity = e; } // IfcRectangleProfileDef IfcPositiveLengthMeasure IfcRectangleProfileDef::XDim() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcRectangleProfileDef::YDim() { return *entity->getArgument(4); } bool IfcRectangleProfileDef::is(Type::Enum v) { return v == Type::IfcRectangleProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcRectangleProfileDef::type() { return Type::IfcRectangleProfileDef; } Type::Enum IfcRectangleProfileDef::Class() { return Type::IfcRectangleProfileDef; } -IfcRectangleProfileDef::IfcRectangleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangleProfileDef)) throw; entity = e; } +IfcRectangleProfileDef::IfcRectangleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangleProfileDef)) throw; entity = e; } // IfcRectangularPyramid IfcPositiveLengthMeasure IfcRectangularPyramid::XLength() { return *entity->getArgument(1); } IfcPositiveLengthMeasure IfcRectangularPyramid::YLength() { return *entity->getArgument(2); } @@ -7541,7 +7540,7 @@ IfcPositiveLengthMeasure IfcRectangularPyramid::Height() { return *entity->getAr bool IfcRectangularPyramid::is(Type::Enum v) { return v == Type::IfcRectangularPyramid || IfcCsgPrimitive3D::is(v); } Type::Enum IfcRectangularPyramid::type() { return Type::IfcRectangularPyramid; } Type::Enum IfcRectangularPyramid::Class() { return Type::IfcRectangularPyramid; } -IfcRectangularPyramid::IfcRectangularPyramid(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangularPyramid)) throw; entity = e; } +IfcRectangularPyramid::IfcRectangularPyramid(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangularPyramid)) throw; entity = e; } // IfcRectangularTrimmedSurface SHARED_PTR IfcRectangularTrimmedSurface::BasisSurface() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcParameterValue IfcRectangularTrimmedSurface::U1() { return *entity->getArgument(1); } @@ -7553,7 +7552,7 @@ bool IfcRectangularTrimmedSurface::Vsense() { return *entity->getArgument(6); } bool IfcRectangularTrimmedSurface::is(Type::Enum v) { return v == Type::IfcRectangularTrimmedSurface || IfcBoundedSurface::is(v); } Type::Enum IfcRectangularTrimmedSurface::type() { return Type::IfcRectangularTrimmedSurface; } Type::Enum IfcRectangularTrimmedSurface::Class() { return Type::IfcRectangularTrimmedSurface; } -IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangularTrimmedSurface)) throw; entity = e; } +IfcRectangularTrimmedSurface::IfcRectangularTrimmedSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcRectangularTrimmedSurface)) throw; entity = e; } // IfcReferencesValueDocument IfcDocumentSelect IfcReferencesValueDocument::ReferencedDocument() { return *entity->getArgument(0); } SHARED_PTR< IfcTemplatedEntityList > IfcReferencesValueDocument::ReferencingValues() { RETURN_AS_LIST(IfcAppliedValue,1) } @@ -7564,14 +7563,14 @@ IfcText IfcReferencesValueDocument::Description() { return *entity->getArgument( bool IfcReferencesValueDocument::is(Type::Enum v) { return v == Type::IfcReferencesValueDocument; } Type::Enum IfcReferencesValueDocument::type() { return Type::IfcReferencesValueDocument; } Type::Enum IfcReferencesValueDocument::Class() { return Type::IfcReferencesValueDocument; } -IfcReferencesValueDocument::IfcReferencesValueDocument(IfcAbstractEntityPtr e) { if (!is(Type::IfcReferencesValueDocument)) throw; entity = e; } +IfcReferencesValueDocument::IfcReferencesValueDocument(IfcAbstractEntityPtr e) { if (!is(Type::IfcReferencesValueDocument)) throw; entity = e; } // IfcRegularTimeSeries IfcTimeMeasure IfcRegularTimeSeries::TimeStep() { return *entity->getArgument(8); } SHARED_PTR< IfcTemplatedEntityList > IfcRegularTimeSeries::Values() { RETURN_AS_LIST(IfcTimeSeriesValue,9) } bool IfcRegularTimeSeries::is(Type::Enum v) { return v == Type::IfcRegularTimeSeries || IfcTimeSeries::is(v); } Type::Enum IfcRegularTimeSeries::type() { return Type::IfcRegularTimeSeries; } Type::Enum IfcRegularTimeSeries::Class() { return Type::IfcRegularTimeSeries; } -IfcRegularTimeSeries::IfcRegularTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcRegularTimeSeries)) throw; entity = e; } +IfcRegularTimeSeries::IfcRegularTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcRegularTimeSeries)) throw; entity = e; } // IfcReinforcementBarProperties IfcAreaMeasure IfcReinforcementBarProperties::TotalCrossSectionArea() { return *entity->getArgument(0); } IfcLabel IfcReinforcementBarProperties::SteelGrade() { return *entity->getArgument(1); } @@ -7586,7 +7585,7 @@ IfcCountMeasure IfcReinforcementBarProperties::BarCount() { return *entity->getA bool IfcReinforcementBarProperties::is(Type::Enum v) { return v == Type::IfcReinforcementBarProperties; } Type::Enum IfcReinforcementBarProperties::type() { return Type::IfcReinforcementBarProperties; } Type::Enum IfcReinforcementBarProperties::Class() { return Type::IfcReinforcementBarProperties; } -IfcReinforcementBarProperties::IfcReinforcementBarProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcementBarProperties)) throw; entity = e; } +IfcReinforcementBarProperties::IfcReinforcementBarProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcementBarProperties)) throw; entity = e; } // IfcReinforcementDefinitionProperties bool IfcReinforcementDefinitionProperties::hasDefinitionType() { return !entity->getArgument(4)->isNull(); } IfcLabel IfcReinforcementDefinitionProperties::DefinitionType() { return *entity->getArgument(4); } @@ -7594,7 +7593,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcReinf bool IfcReinforcementDefinitionProperties::is(Type::Enum v) { return v == Type::IfcReinforcementDefinitionProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcReinforcementDefinitionProperties::type() { return Type::IfcReinforcementDefinitionProperties; } Type::Enum IfcReinforcementDefinitionProperties::Class() { return Type::IfcReinforcementDefinitionProperties; } -IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcementDefinitionProperties)) throw; entity = e; } +IfcReinforcementDefinitionProperties::IfcReinforcementDefinitionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcementDefinitionProperties)) throw; entity = e; } // IfcReinforcingBar IfcPositiveLengthMeasure IfcReinforcingBar::NominalDiameter() { return *entity->getArgument(9); } IfcAreaMeasure IfcReinforcingBar::CrossSectionArea() { return *entity->getArgument(10); } @@ -7606,14 +7605,14 @@ IfcReinforcingBarSurfaceEnum::IfcReinforcingBarSurfaceEnum IfcReinforcingBar::Ba bool IfcReinforcingBar::is(Type::Enum v) { return v == Type::IfcReinforcingBar || IfcReinforcingElement::is(v); } Type::Enum IfcReinforcingBar::type() { return Type::IfcReinforcingBar; } Type::Enum IfcReinforcingBar::Class() { return Type::IfcReinforcingBar; } -IfcReinforcingBar::IfcReinforcingBar(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingBar)) throw; entity = e; } +IfcReinforcingBar::IfcReinforcingBar(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingBar)) throw; entity = e; } // IfcReinforcingElement bool IfcReinforcingElement::hasSteelGrade() { return !entity->getArgument(8)->isNull(); } IfcLabel IfcReinforcingElement::SteelGrade() { return *entity->getArgument(8); } bool IfcReinforcingElement::is(Type::Enum v) { return v == Type::IfcReinforcingElement || IfcBuildingElementComponent::is(v); } Type::Enum IfcReinforcingElement::type() { return Type::IfcReinforcingElement; } Type::Enum IfcReinforcingElement::Class() { return Type::IfcReinforcingElement; } -IfcReinforcingElement::IfcReinforcingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingElement)) throw; entity = e; } +IfcReinforcingElement::IfcReinforcingElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingElement)) throw; entity = e; } // IfcReinforcingMesh bool IfcReinforcingMesh::hasMeshLength() { return !entity->getArgument(9)->isNull(); } IfcPositiveLengthMeasure IfcReinforcingMesh::MeshLength() { return *entity->getArgument(9); } @@ -7628,12 +7627,12 @@ IfcPositiveLengthMeasure IfcReinforcingMesh::TransverseBarSpacing() { return *en bool IfcReinforcingMesh::is(Type::Enum v) { return v == Type::IfcReinforcingMesh || IfcReinforcingElement::is(v); } Type::Enum IfcReinforcingMesh::type() { return Type::IfcReinforcingMesh; } Type::Enum IfcReinforcingMesh::Class() { return Type::IfcReinforcingMesh; } -IfcReinforcingMesh::IfcReinforcingMesh(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingMesh)) throw; entity = e; } +IfcReinforcingMesh::IfcReinforcingMesh(IfcAbstractEntityPtr e) { if (!is(Type::IfcReinforcingMesh)) throw; entity = e; } // IfcRelAggregates bool IfcRelAggregates::is(Type::Enum v) { return v == Type::IfcRelAggregates || IfcRelDecomposes::is(v); } Type::Enum IfcRelAggregates::type() { return Type::IfcRelAggregates; } Type::Enum IfcRelAggregates::Class() { return Type::IfcRelAggregates; } -IfcRelAggregates::IfcRelAggregates(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAggregates)) throw; entity = e; } +IfcRelAggregates::IfcRelAggregates(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAggregates)) throw; entity = e; } // IfcRelAssigns SHARED_PTR< IfcTemplatedEntityList > IfcRelAssigns::RelatedObjects() { RETURN_AS_LIST(IfcObjectDefinition,4) } bool IfcRelAssigns::hasRelatedObjectsType() { return !entity->getArgument(5)->isNull(); } @@ -7641,14 +7640,14 @@ IfcObjectTypeEnum::IfcObjectTypeEnum IfcRelAssigns::RelatedObjectsType() { retur bool IfcRelAssigns::is(Type::Enum v) { return v == Type::IfcRelAssigns || IfcRelationship::is(v); } Type::Enum IfcRelAssigns::type() { return Type::IfcRelAssigns; } Type::Enum IfcRelAssigns::Class() { return Type::IfcRelAssigns; } -IfcRelAssigns::IfcRelAssigns(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssigns)) throw; entity = e; } +IfcRelAssigns::IfcRelAssigns(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssigns)) throw; entity = e; } // IfcRelAssignsTasks bool IfcRelAssignsTasks::hasTimeForTask() { return !entity->getArgument(7)->isNull(); } SHARED_PTR IfcRelAssignsTasks::TimeForTask() { return reinterpret_pointer_cast(*entity->getArgument(7)); } bool IfcRelAssignsTasks::is(Type::Enum v) { return v == Type::IfcRelAssignsTasks || IfcRelAssignsToControl::is(v); } Type::Enum IfcRelAssignsTasks::type() { return Type::IfcRelAssignsTasks; } Type::Enum IfcRelAssignsTasks::Class() { return Type::IfcRelAssignsTasks; } -IfcRelAssignsTasks::IfcRelAssignsTasks(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsTasks)) throw; entity = e; } +IfcRelAssignsTasks::IfcRelAssignsTasks(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsTasks)) throw; entity = e; } // IfcRelAssignsToActor SHARED_PTR IfcRelAssignsToActor::RelatingActor() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssignsToActor::hasActingRole() { return !entity->getArgument(7)->isNull(); } @@ -7656,19 +7655,19 @@ SHARED_PTR IfcRelAssignsToActor::ActingRole() { return reinterpret bool IfcRelAssignsToActor::is(Type::Enum v) { return v == Type::IfcRelAssignsToActor || IfcRelAssigns::is(v); } Type::Enum IfcRelAssignsToActor::type() { return Type::IfcRelAssignsToActor; } Type::Enum IfcRelAssignsToActor::Class() { return Type::IfcRelAssignsToActor; } -IfcRelAssignsToActor::IfcRelAssignsToActor(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToActor)) throw; entity = e; } +IfcRelAssignsToActor::IfcRelAssignsToActor(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToActor)) throw; entity = e; } // IfcRelAssignsToControl SHARED_PTR IfcRelAssignsToControl::RelatingControl() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssignsToControl::is(Type::Enum v) { return v == Type::IfcRelAssignsToControl || IfcRelAssigns::is(v); } Type::Enum IfcRelAssignsToControl::type() { return Type::IfcRelAssignsToControl; } Type::Enum IfcRelAssignsToControl::Class() { return Type::IfcRelAssignsToControl; } -IfcRelAssignsToControl::IfcRelAssignsToControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToControl)) throw; entity = e; } +IfcRelAssignsToControl::IfcRelAssignsToControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToControl)) throw; entity = e; } // IfcRelAssignsToGroup SHARED_PTR IfcRelAssignsToGroup::RelatingGroup() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssignsToGroup::is(Type::Enum v) { return v == Type::IfcRelAssignsToGroup || IfcRelAssigns::is(v); } Type::Enum IfcRelAssignsToGroup::type() { return Type::IfcRelAssignsToGroup; } Type::Enum IfcRelAssignsToGroup::Class() { return Type::IfcRelAssignsToGroup; } -IfcRelAssignsToGroup::IfcRelAssignsToGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToGroup)) throw; entity = e; } +IfcRelAssignsToGroup::IfcRelAssignsToGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToGroup)) throw; entity = e; } // IfcRelAssignsToProcess SHARED_PTR IfcRelAssignsToProcess::RelatingProcess() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssignsToProcess::hasQuantityInProcess() { return !entity->getArgument(7)->isNull(); } @@ -7676,73 +7675,73 @@ SHARED_PTR IfcRelAssignsToProcess::QuantityInProcess() { ret bool IfcRelAssignsToProcess::is(Type::Enum v) { return v == Type::IfcRelAssignsToProcess || IfcRelAssigns::is(v); } Type::Enum IfcRelAssignsToProcess::type() { return Type::IfcRelAssignsToProcess; } Type::Enum IfcRelAssignsToProcess::Class() { return Type::IfcRelAssignsToProcess; } -IfcRelAssignsToProcess::IfcRelAssignsToProcess(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProcess)) throw; entity = e; } +IfcRelAssignsToProcess::IfcRelAssignsToProcess(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProcess)) throw; entity = e; } // IfcRelAssignsToProduct SHARED_PTR IfcRelAssignsToProduct::RelatingProduct() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssignsToProduct::is(Type::Enum v) { return v == Type::IfcRelAssignsToProduct || IfcRelAssigns::is(v); } Type::Enum IfcRelAssignsToProduct::type() { return Type::IfcRelAssignsToProduct; } Type::Enum IfcRelAssignsToProduct::Class() { return Type::IfcRelAssignsToProduct; } -IfcRelAssignsToProduct::IfcRelAssignsToProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProduct)) throw; entity = e; } +IfcRelAssignsToProduct::IfcRelAssignsToProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProduct)) throw; entity = e; } // IfcRelAssignsToProjectOrder bool IfcRelAssignsToProjectOrder::is(Type::Enum v) { return v == Type::IfcRelAssignsToProjectOrder || IfcRelAssignsToControl::is(v); } Type::Enum IfcRelAssignsToProjectOrder::type() { return Type::IfcRelAssignsToProjectOrder; } Type::Enum IfcRelAssignsToProjectOrder::Class() { return Type::IfcRelAssignsToProjectOrder; } -IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProjectOrder)) throw; entity = e; } +IfcRelAssignsToProjectOrder::IfcRelAssignsToProjectOrder(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToProjectOrder)) throw; entity = e; } // IfcRelAssignsToResource SHARED_PTR IfcRelAssignsToResource::RelatingResource() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssignsToResource::is(Type::Enum v) { return v == Type::IfcRelAssignsToResource || IfcRelAssigns::is(v); } Type::Enum IfcRelAssignsToResource::type() { return Type::IfcRelAssignsToResource; } Type::Enum IfcRelAssignsToResource::Class() { return Type::IfcRelAssignsToResource; } -IfcRelAssignsToResource::IfcRelAssignsToResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToResource)) throw; entity = e; } +IfcRelAssignsToResource::IfcRelAssignsToResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssignsToResource)) throw; entity = e; } // IfcRelAssociates SHARED_PTR< IfcTemplatedEntityList > IfcRelAssociates::RelatedObjects() { RETURN_AS_LIST(IfcRoot,4) } bool IfcRelAssociates::is(Type::Enum v) { return v == Type::IfcRelAssociates || IfcRelationship::is(v); } Type::Enum IfcRelAssociates::type() { return Type::IfcRelAssociates; } Type::Enum IfcRelAssociates::Class() { return Type::IfcRelAssociates; } -IfcRelAssociates::IfcRelAssociates(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociates)) throw; entity = e; } +IfcRelAssociates::IfcRelAssociates(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociates)) throw; entity = e; } // IfcRelAssociatesAppliedValue SHARED_PTR IfcRelAssociatesAppliedValue::RelatingAppliedValue() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelAssociatesAppliedValue::is(Type::Enum v) { return v == Type::IfcRelAssociatesAppliedValue || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesAppliedValue::type() { return Type::IfcRelAssociatesAppliedValue; } Type::Enum IfcRelAssociatesAppliedValue::Class() { return Type::IfcRelAssociatesAppliedValue; } -IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesAppliedValue)) throw; entity = e; } +IfcRelAssociatesAppliedValue::IfcRelAssociatesAppliedValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesAppliedValue)) throw; entity = e; } // IfcRelAssociatesApproval SHARED_PTR IfcRelAssociatesApproval::RelatingApproval() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelAssociatesApproval::is(Type::Enum v) { return v == Type::IfcRelAssociatesApproval || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesApproval::type() { return Type::IfcRelAssociatesApproval; } Type::Enum IfcRelAssociatesApproval::Class() { return Type::IfcRelAssociatesApproval; } -IfcRelAssociatesApproval::IfcRelAssociatesApproval(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesApproval)) throw; entity = e; } +IfcRelAssociatesApproval::IfcRelAssociatesApproval(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesApproval)) throw; entity = e; } // IfcRelAssociatesClassification IfcClassificationNotationSelect IfcRelAssociatesClassification::RelatingClassification() { return *entity->getArgument(5); } bool IfcRelAssociatesClassification::is(Type::Enum v) { return v == Type::IfcRelAssociatesClassification || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesClassification::type() { return Type::IfcRelAssociatesClassification; } Type::Enum IfcRelAssociatesClassification::Class() { return Type::IfcRelAssociatesClassification; } -IfcRelAssociatesClassification::IfcRelAssociatesClassification(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesClassification)) throw; entity = e; } +IfcRelAssociatesClassification::IfcRelAssociatesClassification(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesClassification)) throw; entity = e; } // IfcRelAssociatesConstraint IfcLabel IfcRelAssociatesConstraint::Intent() { return *entity->getArgument(5); } SHARED_PTR IfcRelAssociatesConstraint::RelatingConstraint() { return reinterpret_pointer_cast(*entity->getArgument(6)); } bool IfcRelAssociatesConstraint::is(Type::Enum v) { return v == Type::IfcRelAssociatesConstraint || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesConstraint::type() { return Type::IfcRelAssociatesConstraint; } Type::Enum IfcRelAssociatesConstraint::Class() { return Type::IfcRelAssociatesConstraint; } -IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesConstraint)) throw; entity = e; } +IfcRelAssociatesConstraint::IfcRelAssociatesConstraint(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesConstraint)) throw; entity = e; } // IfcRelAssociatesDocument IfcDocumentSelect IfcRelAssociatesDocument::RelatingDocument() { return *entity->getArgument(5); } bool IfcRelAssociatesDocument::is(Type::Enum v) { return v == Type::IfcRelAssociatesDocument || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesDocument::type() { return Type::IfcRelAssociatesDocument; } Type::Enum IfcRelAssociatesDocument::Class() { return Type::IfcRelAssociatesDocument; } -IfcRelAssociatesDocument::IfcRelAssociatesDocument(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesDocument)) throw; entity = e; } +IfcRelAssociatesDocument::IfcRelAssociatesDocument(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesDocument)) throw; entity = e; } // IfcRelAssociatesLibrary IfcLibrarySelect IfcRelAssociatesLibrary::RelatingLibrary() { return *entity->getArgument(5); } bool IfcRelAssociatesLibrary::is(Type::Enum v) { return v == Type::IfcRelAssociatesLibrary || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesLibrary::type() { return Type::IfcRelAssociatesLibrary; } Type::Enum IfcRelAssociatesLibrary::Class() { return Type::IfcRelAssociatesLibrary; } -IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesLibrary)) throw; entity = e; } +IfcRelAssociatesLibrary::IfcRelAssociatesLibrary(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesLibrary)) throw; entity = e; } // IfcRelAssociatesMaterial IfcMaterialSelect IfcRelAssociatesMaterial::RelatingMaterial() { return *entity->getArgument(5); } bool IfcRelAssociatesMaterial::is(Type::Enum v) { return v == Type::IfcRelAssociatesMaterial || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesMaterial::type() { return Type::IfcRelAssociatesMaterial; } Type::Enum IfcRelAssociatesMaterial::Class() { return Type::IfcRelAssociatesMaterial; } -IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesMaterial)) throw; entity = e; } +IfcRelAssociatesMaterial::IfcRelAssociatesMaterial(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesMaterial)) throw; entity = e; } // IfcRelAssociatesProfileProperties SHARED_PTR IfcRelAssociatesProfileProperties::RelatingProfileProperties() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelAssociatesProfileProperties::hasProfileSectionLocation() { return !entity->getArgument(6)->isNull(); } @@ -7752,12 +7751,12 @@ IfcOrientationSelect IfcRelAssociatesProfileProperties::ProfileOrientation() { r bool IfcRelAssociatesProfileProperties::is(Type::Enum v) { return v == Type::IfcRelAssociatesProfileProperties || IfcRelAssociates::is(v); } Type::Enum IfcRelAssociatesProfileProperties::type() { return Type::IfcRelAssociatesProfileProperties; } Type::Enum IfcRelAssociatesProfileProperties::Class() { return Type::IfcRelAssociatesProfileProperties; } -IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesProfileProperties)) throw; entity = e; } +IfcRelAssociatesProfileProperties::IfcRelAssociatesProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelAssociatesProfileProperties)) throw; entity = e; } // IfcRelConnects bool IfcRelConnects::is(Type::Enum v) { return v == Type::IfcRelConnects || IfcRelationship::is(v); } Type::Enum IfcRelConnects::type() { return Type::IfcRelConnects; } Type::Enum IfcRelConnects::Class() { return Type::IfcRelConnects; } -IfcRelConnects::IfcRelConnects(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnects)) throw; entity = e; } +IfcRelConnects::IfcRelConnects(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnects)) throw; entity = e; } // IfcRelConnectsElements bool IfcRelConnectsElements::hasConnectionGeometry() { return !entity->getArgument(4)->isNull(); } SHARED_PTR IfcRelConnectsElements::ConnectionGeometry() { return reinterpret_pointer_cast(*entity->getArgument(4)); } @@ -7766,23 +7765,23 @@ SHARED_PTR IfcRelConnectsElements::RelatedElement() { return reinter bool IfcRelConnectsElements::is(Type::Enum v) { return v == Type::IfcRelConnectsElements || IfcRelConnects::is(v); } Type::Enum IfcRelConnectsElements::type() { return Type::IfcRelConnectsElements; } Type::Enum IfcRelConnectsElements::Class() { return Type::IfcRelConnectsElements; } -IfcRelConnectsElements::IfcRelConnectsElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsElements)) throw; entity = e; } +IfcRelConnectsElements::IfcRelConnectsElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsElements)) throw; entity = e; } // IfcRelConnectsPathElements -std::vector IfcRelConnectsPathElements::RelatingPriorities() { return *entity->getArgument(7); } -std::vector IfcRelConnectsPathElements::RelatedPriorities() { return *entity->getArgument(8); } +std::vector /*[0:?]*/ IfcRelConnectsPathElements::RelatingPriorities() { return *entity->getArgument(7); } +std::vector /*[0:?]*/ IfcRelConnectsPathElements::RelatedPriorities() { return *entity->getArgument(8); } IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatedConnectionType() { return IfcConnectionTypeEnum::FromString(*entity->getArgument(9)); } IfcConnectionTypeEnum::IfcConnectionTypeEnum IfcRelConnectsPathElements::RelatingConnectionType() { return IfcConnectionTypeEnum::FromString(*entity->getArgument(10)); } bool IfcRelConnectsPathElements::is(Type::Enum v) { return v == Type::IfcRelConnectsPathElements || IfcRelConnectsElements::is(v); } Type::Enum IfcRelConnectsPathElements::type() { return Type::IfcRelConnectsPathElements; } Type::Enum IfcRelConnectsPathElements::Class() { return Type::IfcRelConnectsPathElements; } -IfcRelConnectsPathElements::IfcRelConnectsPathElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPathElements)) throw; entity = e; } +IfcRelConnectsPathElements::IfcRelConnectsPathElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPathElements)) throw; entity = e; } // IfcRelConnectsPortToElement SHARED_PTR IfcRelConnectsPortToElement::RelatingPort() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelConnectsPortToElement::RelatedElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelConnectsPortToElement::is(Type::Enum v) { return v == Type::IfcRelConnectsPortToElement || IfcRelConnects::is(v); } Type::Enum IfcRelConnectsPortToElement::type() { return Type::IfcRelConnectsPortToElement; } Type::Enum IfcRelConnectsPortToElement::Class() { return Type::IfcRelConnectsPortToElement; } -IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPortToElement)) throw; entity = e; } +IfcRelConnectsPortToElement::IfcRelConnectsPortToElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPortToElement)) throw; entity = e; } // IfcRelConnectsPorts SHARED_PTR IfcRelConnectsPorts::RelatingPort() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelConnectsPorts::RelatedPort() { return reinterpret_pointer_cast(*entity->getArgument(5)); } @@ -7791,21 +7790,21 @@ SHARED_PTR IfcRelConnectsPorts::RealizingElement() { return reinterp bool IfcRelConnectsPorts::is(Type::Enum v) { return v == Type::IfcRelConnectsPorts || IfcRelConnects::is(v); } Type::Enum IfcRelConnectsPorts::type() { return Type::IfcRelConnectsPorts; } Type::Enum IfcRelConnectsPorts::Class() { return Type::IfcRelConnectsPorts; } -IfcRelConnectsPorts::IfcRelConnectsPorts(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPorts)) throw; entity = e; } +IfcRelConnectsPorts::IfcRelConnectsPorts(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsPorts)) throw; entity = e; } // IfcRelConnectsStructuralActivity IfcStructuralActivityAssignmentSelect IfcRelConnectsStructuralActivity::RelatingElement() { return *entity->getArgument(4); } SHARED_PTR IfcRelConnectsStructuralActivity::RelatedStructuralActivity() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelConnectsStructuralActivity::is(Type::Enum v) { return v == Type::IfcRelConnectsStructuralActivity || IfcRelConnects::is(v); } Type::Enum IfcRelConnectsStructuralActivity::type() { return Type::IfcRelConnectsStructuralActivity; } Type::Enum IfcRelConnectsStructuralActivity::Class() { return Type::IfcRelConnectsStructuralActivity; } -IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralActivity)) throw; entity = e; } +IfcRelConnectsStructuralActivity::IfcRelConnectsStructuralActivity(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralActivity)) throw; entity = e; } // IfcRelConnectsStructuralElement SHARED_PTR IfcRelConnectsStructuralElement::RelatingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelConnectsStructuralElement::RelatedStructuralMember() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelConnectsStructuralElement::is(Type::Enum v) { return v == Type::IfcRelConnectsStructuralElement || IfcRelConnects::is(v); } Type::Enum IfcRelConnectsStructuralElement::type() { return Type::IfcRelConnectsStructuralElement; } Type::Enum IfcRelConnectsStructuralElement::Class() { return Type::IfcRelConnectsStructuralElement; } -IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralElement)) throw; entity = e; } +IfcRelConnectsStructuralElement::IfcRelConnectsStructuralElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralElement)) throw; entity = e; } // IfcRelConnectsStructuralMember SHARED_PTR IfcRelConnectsStructuralMember::RelatingStructuralMember() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelConnectsStructuralMember::RelatedStructuralConnection() { return reinterpret_pointer_cast(*entity->getArgument(5)); } @@ -7820,13 +7819,13 @@ SHARED_PTR IfcRelConnectsStructuralMember::ConditionCoordin bool IfcRelConnectsStructuralMember::is(Type::Enum v) { return v == Type::IfcRelConnectsStructuralMember || IfcRelConnects::is(v); } Type::Enum IfcRelConnectsStructuralMember::type() { return Type::IfcRelConnectsStructuralMember; } Type::Enum IfcRelConnectsStructuralMember::Class() { return Type::IfcRelConnectsStructuralMember; } -IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralMember)) throw; entity = e; } +IfcRelConnectsStructuralMember::IfcRelConnectsStructuralMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsStructuralMember)) throw; entity = e; } // IfcRelConnectsWithEccentricity SHARED_PTR IfcRelConnectsWithEccentricity::ConnectionConstraint() { return reinterpret_pointer_cast(*entity->getArgument(10)); } bool IfcRelConnectsWithEccentricity::is(Type::Enum v) { return v == Type::IfcRelConnectsWithEccentricity || IfcRelConnectsStructuralMember::is(v); } Type::Enum IfcRelConnectsWithEccentricity::type() { return Type::IfcRelConnectsWithEccentricity; } Type::Enum IfcRelConnectsWithEccentricity::Class() { return Type::IfcRelConnectsWithEccentricity; } -IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsWithEccentricity)) throw; entity = e; } +IfcRelConnectsWithEccentricity::IfcRelConnectsWithEccentricity(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsWithEccentricity)) throw; entity = e; } // IfcRelConnectsWithRealizingElements SHARED_PTR< IfcTemplatedEntityList > IfcRelConnectsWithRealizingElements::RealizingElements() { RETURN_AS_LIST(IfcElement,7) } bool IfcRelConnectsWithRealizingElements::hasConnectionType() { return !entity->getArgument(8)->isNull(); } @@ -7834,67 +7833,67 @@ IfcLabel IfcRelConnectsWithRealizingElements::ConnectionType() { return *entity- bool IfcRelConnectsWithRealizingElements::is(Type::Enum v) { return v == Type::IfcRelConnectsWithRealizingElements || IfcRelConnectsElements::is(v); } Type::Enum IfcRelConnectsWithRealizingElements::type() { return Type::IfcRelConnectsWithRealizingElements; } Type::Enum IfcRelConnectsWithRealizingElements::Class() { return Type::IfcRelConnectsWithRealizingElements; } -IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsWithRealizingElements)) throw; entity = e; } +IfcRelConnectsWithRealizingElements::IfcRelConnectsWithRealizingElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelConnectsWithRealizingElements)) throw; entity = e; } // IfcRelContainedInSpatialStructure SHARED_PTR< IfcTemplatedEntityList > IfcRelContainedInSpatialStructure::RelatedElements() { RETURN_AS_LIST(IfcProduct,4) } SHARED_PTR IfcRelContainedInSpatialStructure::RelatingStructure() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelContainedInSpatialStructure::is(Type::Enum v) { return v == Type::IfcRelContainedInSpatialStructure || IfcRelConnects::is(v); } Type::Enum IfcRelContainedInSpatialStructure::type() { return Type::IfcRelContainedInSpatialStructure; } Type::Enum IfcRelContainedInSpatialStructure::Class() { return Type::IfcRelContainedInSpatialStructure; } -IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelContainedInSpatialStructure)) throw; entity = e; } +IfcRelContainedInSpatialStructure::IfcRelContainedInSpatialStructure(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelContainedInSpatialStructure)) throw; entity = e; } // IfcRelCoversBldgElements SHARED_PTR IfcRelCoversBldgElements::RelatingBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR< IfcTemplatedEntityList > IfcRelCoversBldgElements::RelatedCoverings() { RETURN_AS_LIST(IfcCovering,5) } bool IfcRelCoversBldgElements::is(Type::Enum v) { return v == Type::IfcRelCoversBldgElements || IfcRelConnects::is(v); } Type::Enum IfcRelCoversBldgElements::type() { return Type::IfcRelCoversBldgElements; } Type::Enum IfcRelCoversBldgElements::Class() { return Type::IfcRelCoversBldgElements; } -IfcRelCoversBldgElements::IfcRelCoversBldgElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelCoversBldgElements)) throw; entity = e; } +IfcRelCoversBldgElements::IfcRelCoversBldgElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelCoversBldgElements)) throw; entity = e; } // IfcRelCoversSpaces SHARED_PTR IfcRelCoversSpaces::RelatedSpace() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR< IfcTemplatedEntityList > IfcRelCoversSpaces::RelatedCoverings() { RETURN_AS_LIST(IfcCovering,5) } bool IfcRelCoversSpaces::is(Type::Enum v) { return v == Type::IfcRelCoversSpaces || IfcRelConnects::is(v); } Type::Enum IfcRelCoversSpaces::type() { return Type::IfcRelCoversSpaces; } Type::Enum IfcRelCoversSpaces::Class() { return Type::IfcRelCoversSpaces; } -IfcRelCoversSpaces::IfcRelCoversSpaces(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelCoversSpaces)) throw; entity = e; } +IfcRelCoversSpaces::IfcRelCoversSpaces(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelCoversSpaces)) throw; entity = e; } // IfcRelDecomposes SHARED_PTR IfcRelDecomposes::RelatingObject() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR< IfcTemplatedEntityList > IfcRelDecomposes::RelatedObjects() { RETURN_AS_LIST(IfcObjectDefinition,5) } bool IfcRelDecomposes::is(Type::Enum v) { return v == Type::IfcRelDecomposes || IfcRelationship::is(v); } Type::Enum IfcRelDecomposes::type() { return Type::IfcRelDecomposes; } Type::Enum IfcRelDecomposes::Class() { return Type::IfcRelDecomposes; } -IfcRelDecomposes::IfcRelDecomposes(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDecomposes)) throw; entity = e; } +IfcRelDecomposes::IfcRelDecomposes(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDecomposes)) throw; entity = e; } // IfcRelDefines SHARED_PTR< IfcTemplatedEntityList > IfcRelDefines::RelatedObjects() { RETURN_AS_LIST(IfcObject,4) } bool IfcRelDefines::is(Type::Enum v) { return v == Type::IfcRelDefines || IfcRelationship::is(v); } Type::Enum IfcRelDefines::type() { return Type::IfcRelDefines; } Type::Enum IfcRelDefines::Class() { return Type::IfcRelDefines; } -IfcRelDefines::IfcRelDefines(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefines)) throw; entity = e; } +IfcRelDefines::IfcRelDefines(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefines)) throw; entity = e; } // IfcRelDefinesByProperties SHARED_PTR IfcRelDefinesByProperties::RelatingPropertyDefinition() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelDefinesByProperties::is(Type::Enum v) { return v == Type::IfcRelDefinesByProperties || IfcRelDefines::is(v); } Type::Enum IfcRelDefinesByProperties::type() { return Type::IfcRelDefinesByProperties; } Type::Enum IfcRelDefinesByProperties::Class() { return Type::IfcRelDefinesByProperties; } -IfcRelDefinesByProperties::IfcRelDefinesByProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefinesByProperties)) throw; entity = e; } +IfcRelDefinesByProperties::IfcRelDefinesByProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefinesByProperties)) throw; entity = e; } // IfcRelDefinesByType SHARED_PTR IfcRelDefinesByType::RelatingType() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelDefinesByType::is(Type::Enum v) { return v == Type::IfcRelDefinesByType || IfcRelDefines::is(v); } Type::Enum IfcRelDefinesByType::type() { return Type::IfcRelDefinesByType; } Type::Enum IfcRelDefinesByType::Class() { return Type::IfcRelDefinesByType; } -IfcRelDefinesByType::IfcRelDefinesByType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefinesByType)) throw; entity = e; } +IfcRelDefinesByType::IfcRelDefinesByType(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelDefinesByType)) throw; entity = e; } // IfcRelFillsElement SHARED_PTR IfcRelFillsElement::RelatingOpeningElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelFillsElement::RelatedBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelFillsElement::is(Type::Enum v) { return v == Type::IfcRelFillsElement || IfcRelConnects::is(v); } Type::Enum IfcRelFillsElement::type() { return Type::IfcRelFillsElement; } Type::Enum IfcRelFillsElement::Class() { return Type::IfcRelFillsElement; } -IfcRelFillsElement::IfcRelFillsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelFillsElement)) throw; entity = e; } +IfcRelFillsElement::IfcRelFillsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelFillsElement)) throw; entity = e; } // IfcRelFlowControlElements SHARED_PTR< IfcTemplatedEntityList > IfcRelFlowControlElements::RelatedControlElements() { RETURN_AS_LIST(IfcDistributionControlElement,4) } SHARED_PTR IfcRelFlowControlElements::RelatingFlowElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelFlowControlElements::is(Type::Enum v) { return v == Type::IfcRelFlowControlElements || IfcRelConnects::is(v); } Type::Enum IfcRelFlowControlElements::type() { return Type::IfcRelFlowControlElements; } Type::Enum IfcRelFlowControlElements::Class() { return Type::IfcRelFlowControlElements; } -IfcRelFlowControlElements::IfcRelFlowControlElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelFlowControlElements)) throw; entity = e; } +IfcRelFlowControlElements::IfcRelFlowControlElements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelFlowControlElements)) throw; entity = e; } // IfcRelInteractionRequirements bool IfcRelInteractionRequirements::hasDailyInteraction() { return !entity->getArgument(4)->isNull(); } IfcCountMeasure IfcRelInteractionRequirements::DailyInteraction() { return *entity->getArgument(4); } @@ -7907,42 +7906,42 @@ SHARED_PTR IfcRelInteractionRequirements::RelatingSpaceProgram( bool IfcRelInteractionRequirements::is(Type::Enum v) { return v == Type::IfcRelInteractionRequirements || IfcRelConnects::is(v); } Type::Enum IfcRelInteractionRequirements::type() { return Type::IfcRelInteractionRequirements; } Type::Enum IfcRelInteractionRequirements::Class() { return Type::IfcRelInteractionRequirements; } -IfcRelInteractionRequirements::IfcRelInteractionRequirements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelInteractionRequirements)) throw; entity = e; } +IfcRelInteractionRequirements::IfcRelInteractionRequirements(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelInteractionRequirements)) throw; entity = e; } // IfcRelNests bool IfcRelNests::is(Type::Enum v) { return v == Type::IfcRelNests || IfcRelDecomposes::is(v); } Type::Enum IfcRelNests::type() { return Type::IfcRelNests; } Type::Enum IfcRelNests::Class() { return Type::IfcRelNests; } -IfcRelNests::IfcRelNests(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelNests)) throw; entity = e; } +IfcRelNests::IfcRelNests(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelNests)) throw; entity = e; } // IfcRelOccupiesSpaces bool IfcRelOccupiesSpaces::is(Type::Enum v) { return v == Type::IfcRelOccupiesSpaces || IfcRelAssignsToActor::is(v); } Type::Enum IfcRelOccupiesSpaces::type() { return Type::IfcRelOccupiesSpaces; } Type::Enum IfcRelOccupiesSpaces::Class() { return Type::IfcRelOccupiesSpaces; } -IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelOccupiesSpaces)) throw; entity = e; } +IfcRelOccupiesSpaces::IfcRelOccupiesSpaces(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelOccupiesSpaces)) throw; entity = e; } // IfcRelOverridesProperties SHARED_PTR< IfcTemplatedEntityList > IfcRelOverridesProperties::OverridingProperties() { RETURN_AS_LIST(IfcProperty,6) } bool IfcRelOverridesProperties::is(Type::Enum v) { return v == Type::IfcRelOverridesProperties || IfcRelDefinesByProperties::is(v); } Type::Enum IfcRelOverridesProperties::type() { return Type::IfcRelOverridesProperties; } Type::Enum IfcRelOverridesProperties::Class() { return Type::IfcRelOverridesProperties; } -IfcRelOverridesProperties::IfcRelOverridesProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelOverridesProperties)) throw; entity = e; } +IfcRelOverridesProperties::IfcRelOverridesProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelOverridesProperties)) throw; entity = e; } // IfcRelProjectsElement SHARED_PTR IfcRelProjectsElement::RelatingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelProjectsElement::RelatedFeatureElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelProjectsElement::is(Type::Enum v) { return v == Type::IfcRelProjectsElement || IfcRelConnects::is(v); } Type::Enum IfcRelProjectsElement::type() { return Type::IfcRelProjectsElement; } Type::Enum IfcRelProjectsElement::Class() { return Type::IfcRelProjectsElement; } -IfcRelProjectsElement::IfcRelProjectsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelProjectsElement)) throw; entity = e; } +IfcRelProjectsElement::IfcRelProjectsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelProjectsElement)) throw; entity = e; } // IfcRelReferencedInSpatialStructure SHARED_PTR< IfcTemplatedEntityList > IfcRelReferencedInSpatialStructure::RelatedElements() { RETURN_AS_LIST(IfcProduct,4) } SHARED_PTR IfcRelReferencedInSpatialStructure::RelatingStructure() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelReferencedInSpatialStructure::is(Type::Enum v) { return v == Type::IfcRelReferencedInSpatialStructure || IfcRelConnects::is(v); } Type::Enum IfcRelReferencedInSpatialStructure::type() { return Type::IfcRelReferencedInSpatialStructure; } Type::Enum IfcRelReferencedInSpatialStructure::Class() { return Type::IfcRelReferencedInSpatialStructure; } -IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelReferencedInSpatialStructure)) throw; entity = e; } +IfcRelReferencedInSpatialStructure::IfcRelReferencedInSpatialStructure(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelReferencedInSpatialStructure)) throw; entity = e; } // IfcRelSchedulesCostItems bool IfcRelSchedulesCostItems::is(Type::Enum v) { return v == Type::IfcRelSchedulesCostItems || IfcRelAssignsToControl::is(v); } Type::Enum IfcRelSchedulesCostItems::type() { return Type::IfcRelSchedulesCostItems; } Type::Enum IfcRelSchedulesCostItems::Class() { return Type::IfcRelSchedulesCostItems; } -IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSchedulesCostItems)) throw; entity = e; } +IfcRelSchedulesCostItems::IfcRelSchedulesCostItems(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSchedulesCostItems)) throw; entity = e; } // IfcRelSequence SHARED_PTR IfcRelSequence::RelatingProcess() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelSequence::RelatedProcess() { return reinterpret_pointer_cast(*entity->getArgument(5)); } @@ -7951,14 +7950,14 @@ IfcSequenceEnum::IfcSequenceEnum IfcRelSequence::SequenceType() { return IfcSequ bool IfcRelSequence::is(Type::Enum v) { return v == Type::IfcRelSequence || IfcRelConnects::is(v); } Type::Enum IfcRelSequence::type() { return Type::IfcRelSequence; } Type::Enum IfcRelSequence::Class() { return Type::IfcRelSequence; } -IfcRelSequence::IfcRelSequence(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSequence)) throw; entity = e; } +IfcRelSequence::IfcRelSequence(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSequence)) throw; entity = e; } // IfcRelServicesBuildings SHARED_PTR IfcRelServicesBuildings::RelatingSystem() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR< IfcTemplatedEntityList > IfcRelServicesBuildings::RelatedBuildings() { RETURN_AS_LIST(IfcSpatialStructureElement,5) } bool IfcRelServicesBuildings::is(Type::Enum v) { return v == Type::IfcRelServicesBuildings || IfcRelConnects::is(v); } Type::Enum IfcRelServicesBuildings::type() { return Type::IfcRelServicesBuildings; } Type::Enum IfcRelServicesBuildings::Class() { return Type::IfcRelServicesBuildings; } -IfcRelServicesBuildings::IfcRelServicesBuildings(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelServicesBuildings)) throw; entity = e; } +IfcRelServicesBuildings::IfcRelServicesBuildings(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelServicesBuildings)) throw; entity = e; } // IfcRelSpaceBoundary SHARED_PTR IfcRelSpaceBoundary::RelatingSpace() { return reinterpret_pointer_cast(*entity->getArgument(4)); } bool IfcRelSpaceBoundary::hasRelatedBuildingElement() { return !entity->getArgument(5)->isNull(); } @@ -7970,26 +7969,26 @@ IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcRelSpaceBoundary::Intern bool IfcRelSpaceBoundary::is(Type::Enum v) { return v == Type::IfcRelSpaceBoundary || IfcRelConnects::is(v); } Type::Enum IfcRelSpaceBoundary::type() { return Type::IfcRelSpaceBoundary; } Type::Enum IfcRelSpaceBoundary::Class() { return Type::IfcRelSpaceBoundary; } -IfcRelSpaceBoundary::IfcRelSpaceBoundary(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSpaceBoundary)) throw; entity = e; } +IfcRelSpaceBoundary::IfcRelSpaceBoundary(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelSpaceBoundary)) throw; entity = e; } // IfcRelVoidsElement SHARED_PTR IfcRelVoidsElement::RelatingBuildingElement() { return reinterpret_pointer_cast(*entity->getArgument(4)); } SHARED_PTR IfcRelVoidsElement::RelatedOpeningElement() { return reinterpret_pointer_cast(*entity->getArgument(5)); } bool IfcRelVoidsElement::is(Type::Enum v) { return v == Type::IfcRelVoidsElement || IfcRelConnects::is(v); } Type::Enum IfcRelVoidsElement::type() { return Type::IfcRelVoidsElement; } Type::Enum IfcRelVoidsElement::Class() { return Type::IfcRelVoidsElement; } -IfcRelVoidsElement::IfcRelVoidsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelVoidsElement)) throw; entity = e; } +IfcRelVoidsElement::IfcRelVoidsElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelVoidsElement)) throw; entity = e; } // IfcRelationship bool IfcRelationship::is(Type::Enum v) { return v == Type::IfcRelationship || IfcRoot::is(v); } Type::Enum IfcRelationship::type() { return Type::IfcRelationship; } Type::Enum IfcRelationship::Class() { return Type::IfcRelationship; } -IfcRelationship::IfcRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelationship)) throw; entity = e; } +IfcRelationship::IfcRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelationship)) throw; entity = e; } // IfcRelaxation IfcNormalisedRatioMeasure IfcRelaxation::RelaxationValue() { return *entity->getArgument(0); } IfcNormalisedRatioMeasure IfcRelaxation::InitialStress() { return *entity->getArgument(1); } bool IfcRelaxation::is(Type::Enum v) { return v == Type::IfcRelaxation; } Type::Enum IfcRelaxation::type() { return Type::IfcRelaxation; } Type::Enum IfcRelaxation::Class() { return Type::IfcRelaxation; } -IfcRelaxation::IfcRelaxation(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelaxation)) throw; entity = e; } +IfcRelaxation::IfcRelaxation(IfcAbstractEntityPtr e) { if (!is(Type::IfcRelaxation)) throw; entity = e; } // IfcRepresentation SHARED_PTR IfcRepresentation::ContextOfItems() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcRepresentation::hasRepresentationIdentifier() { return !entity->getArgument(1)->isNull(); } @@ -8003,7 +8002,7 @@ IfcProductRepresentation::list IfcRepresentation::OfProductRepresentation() { RE bool IfcRepresentation::is(Type::Enum v) { return v == Type::IfcRepresentation; } Type::Enum IfcRepresentation::type() { return Type::IfcRepresentation; } Type::Enum IfcRepresentation::Class() { return Type::IfcRepresentation; } -IfcRepresentation::IfcRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentation)) throw; entity = e; } +IfcRepresentation::IfcRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentation)) throw; entity = e; } // IfcRepresentationContext bool IfcRepresentationContext::hasContextIdentifier() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcRepresentationContext::ContextIdentifier() { return *entity->getArgument(0); } @@ -8013,14 +8012,14 @@ IfcRepresentation::list IfcRepresentationContext::RepresentationsInContext() { R bool IfcRepresentationContext::is(Type::Enum v) { return v == Type::IfcRepresentationContext; } Type::Enum IfcRepresentationContext::type() { return Type::IfcRepresentationContext; } Type::Enum IfcRepresentationContext::Class() { return Type::IfcRepresentationContext; } -IfcRepresentationContext::IfcRepresentationContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationContext)) throw; entity = e; } +IfcRepresentationContext::IfcRepresentationContext(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationContext)) throw; entity = e; } // IfcRepresentationItem IfcPresentationLayerAssignment::list IfcRepresentationItem::LayerAssignments() { RETURN_INVERSE(IfcPresentationLayerAssignment) } IfcStyledItem::list IfcRepresentationItem::StyledByItem() { RETURN_INVERSE(IfcStyledItem) } bool IfcRepresentationItem::is(Type::Enum v) { return v == Type::IfcRepresentationItem; } Type::Enum IfcRepresentationItem::type() { return Type::IfcRepresentationItem; } Type::Enum IfcRepresentationItem::Class() { return Type::IfcRepresentationItem; } -IfcRepresentationItem::IfcRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationItem)) throw; entity = e; } +IfcRepresentationItem::IfcRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationItem)) throw; entity = e; } // IfcRepresentationMap IfcAxis2Placement IfcRepresentationMap::MappingOrigin() { return *entity->getArgument(0); } SHARED_PTR IfcRepresentationMap::MappedRepresentation() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -8028,20 +8027,20 @@ IfcMappedItem::list IfcRepresentationMap::MapUsage() { RETURN_INVERSE(IfcMappedI bool IfcRepresentationMap::is(Type::Enum v) { return v == Type::IfcRepresentationMap; } Type::Enum IfcRepresentationMap::type() { return Type::IfcRepresentationMap; } Type::Enum IfcRepresentationMap::Class() { return Type::IfcRepresentationMap; } -IfcRepresentationMap::IfcRepresentationMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationMap)) throw; entity = e; } +IfcRepresentationMap::IfcRepresentationMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcRepresentationMap)) throw; entity = e; } // IfcResource IfcRelAssignsToResource::list IfcResource::ResourceOf() { RETURN_INVERSE(IfcRelAssignsToResource) } bool IfcResource::is(Type::Enum v) { return v == Type::IfcResource || IfcObject::is(v); } Type::Enum IfcResource::type() { return Type::IfcResource; } Type::Enum IfcResource::Class() { return Type::IfcResource; } -IfcResource::IfcResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcResource)) throw; entity = e; } +IfcResource::IfcResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcResource)) throw; entity = e; } // IfcRevolvedAreaSolid SHARED_PTR IfcRevolvedAreaSolid::Axis() { return reinterpret_pointer_cast(*entity->getArgument(2)); } IfcPlaneAngleMeasure IfcRevolvedAreaSolid::Angle() { return *entity->getArgument(3); } bool IfcRevolvedAreaSolid::is(Type::Enum v) { return v == Type::IfcRevolvedAreaSolid || IfcSweptAreaSolid::is(v); } Type::Enum IfcRevolvedAreaSolid::type() { return Type::IfcRevolvedAreaSolid; } Type::Enum IfcRevolvedAreaSolid::Class() { return Type::IfcRevolvedAreaSolid; } -IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcRevolvedAreaSolid)) throw; entity = e; } +IfcRevolvedAreaSolid::IfcRevolvedAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcRevolvedAreaSolid)) throw; entity = e; } // IfcRibPlateProfileProperties bool IfcRibPlateProfileProperties::hasThickness() { return !entity->getArgument(2)->isNull(); } IfcPositiveLengthMeasure IfcRibPlateProfileProperties::Thickness() { return *entity->getArgument(2); } @@ -8055,27 +8054,27 @@ IfcRibPlateDirectionEnum::IfcRibPlateDirectionEnum IfcRibPlateProfileProperties: bool IfcRibPlateProfileProperties::is(Type::Enum v) { return v == Type::IfcRibPlateProfileProperties || IfcProfileProperties::is(v); } Type::Enum IfcRibPlateProfileProperties::type() { return Type::IfcRibPlateProfileProperties; } Type::Enum IfcRibPlateProfileProperties::Class() { return Type::IfcRibPlateProfileProperties; } -IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRibPlateProfileProperties)) throw; entity = e; } +IfcRibPlateProfileProperties::IfcRibPlateProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcRibPlateProfileProperties)) throw; entity = e; } // IfcRightCircularCone IfcPositiveLengthMeasure IfcRightCircularCone::Height() { return *entity->getArgument(1); } IfcPositiveLengthMeasure IfcRightCircularCone::BottomRadius() { return *entity->getArgument(2); } bool IfcRightCircularCone::is(Type::Enum v) { return v == Type::IfcRightCircularCone || IfcCsgPrimitive3D::is(v); } Type::Enum IfcRightCircularCone::type() { return Type::IfcRightCircularCone; } Type::Enum IfcRightCircularCone::Class() { return Type::IfcRightCircularCone; } -IfcRightCircularCone::IfcRightCircularCone(IfcAbstractEntityPtr e) { if (!is(Type::IfcRightCircularCone)) throw; entity = e; } +IfcRightCircularCone::IfcRightCircularCone(IfcAbstractEntityPtr e) { if (!is(Type::IfcRightCircularCone)) throw; entity = e; } // IfcRightCircularCylinder IfcPositiveLengthMeasure IfcRightCircularCylinder::Height() { return *entity->getArgument(1); } IfcPositiveLengthMeasure IfcRightCircularCylinder::Radius() { return *entity->getArgument(2); } bool IfcRightCircularCylinder::is(Type::Enum v) { return v == Type::IfcRightCircularCylinder || IfcCsgPrimitive3D::is(v); } Type::Enum IfcRightCircularCylinder::type() { return Type::IfcRightCircularCylinder; } Type::Enum IfcRightCircularCylinder::Class() { return Type::IfcRightCircularCylinder; } -IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAbstractEntityPtr e) { if (!is(Type::IfcRightCircularCylinder)) throw; entity = e; } +IfcRightCircularCylinder::IfcRightCircularCylinder(IfcAbstractEntityPtr e) { if (!is(Type::IfcRightCircularCylinder)) throw; entity = e; } // IfcRoof IfcRoofTypeEnum::IfcRoofTypeEnum IfcRoof::ShapeType() { return IfcRoofTypeEnum::FromString(*entity->getArgument(8)); } bool IfcRoof::is(Type::Enum v) { return v == Type::IfcRoof || IfcBuildingElement::is(v); } Type::Enum IfcRoof::type() { return Type::IfcRoof; } Type::Enum IfcRoof::Class() { return Type::IfcRoof; } -IfcRoof::IfcRoof(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoof)) throw; entity = e; } +IfcRoof::IfcRoof(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoof)) throw; entity = e; } // IfcRoot IfcGloballyUniqueId IfcRoot::GlobalId() { return *entity->getArgument(0); } SHARED_PTR IfcRoot::OwnerHistory() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -8086,20 +8085,20 @@ IfcText IfcRoot::Description() { return *entity->getArgument(3); } bool IfcRoot::is(Type::Enum v) { return v == Type::IfcRoot; } Type::Enum IfcRoot::type() { return Type::IfcRoot; } Type::Enum IfcRoot::Class() { return Type::IfcRoot; } -IfcRoot::IfcRoot(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoot)) throw; entity = e; } +IfcRoot::IfcRoot(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoot)) throw; entity = e; } // IfcRoundedEdgeFeature bool IfcRoundedEdgeFeature::hasRadius() { return !entity->getArgument(9)->isNull(); } IfcPositiveLengthMeasure IfcRoundedEdgeFeature::Radius() { return *entity->getArgument(9); } bool IfcRoundedEdgeFeature::is(Type::Enum v) { return v == Type::IfcRoundedEdgeFeature || IfcEdgeFeature::is(v); } Type::Enum IfcRoundedEdgeFeature::type() { return Type::IfcRoundedEdgeFeature; } Type::Enum IfcRoundedEdgeFeature::Class() { return Type::IfcRoundedEdgeFeature; } -IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoundedEdgeFeature)) throw; entity = e; } +IfcRoundedEdgeFeature::IfcRoundedEdgeFeature(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoundedEdgeFeature)) throw; entity = e; } // IfcRoundedRectangleProfileDef IfcPositiveLengthMeasure IfcRoundedRectangleProfileDef::RoundingRadius() { return *entity->getArgument(5); } bool IfcRoundedRectangleProfileDef::is(Type::Enum v) { return v == Type::IfcRoundedRectangleProfileDef || IfcRectangleProfileDef::is(v); } Type::Enum IfcRoundedRectangleProfileDef::type() { return Type::IfcRoundedRectangleProfileDef; } Type::Enum IfcRoundedRectangleProfileDef::Class() { return Type::IfcRoundedRectangleProfileDef; } -IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoundedRectangleProfileDef)) throw; entity = e; } +IfcRoundedRectangleProfileDef::IfcRoundedRectangleProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcRoundedRectangleProfileDef)) throw; entity = e; } // IfcSIUnit bool IfcSIUnit::hasPrefix() { return !entity->getArgument(2)->isNull(); } IfcSIPrefix::IfcSIPrefix IfcSIUnit::Prefix() { return IfcSIPrefix::FromString(*entity->getArgument(2)); } @@ -8107,13 +8106,13 @@ IfcSIUnitName::IfcSIUnitName IfcSIUnit::Name() { return IfcSIUnitName::FromStrin bool IfcSIUnit::is(Type::Enum v) { return v == Type::IfcSIUnit || IfcNamedUnit::is(v); } Type::Enum IfcSIUnit::type() { return Type::IfcSIUnit; } Type::Enum IfcSIUnit::Class() { return Type::IfcSIUnit; } -IfcSIUnit::IfcSIUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcSIUnit)) throw; entity = e; } +IfcSIUnit::IfcSIUnit(IfcAbstractEntityPtr e) { if (!is(Type::IfcSIUnit)) throw; entity = e; } // IfcSanitaryTerminalType IfcSanitaryTerminalTypeEnum::IfcSanitaryTerminalTypeEnum IfcSanitaryTerminalType::PredefinedType() { return IfcSanitaryTerminalTypeEnum::FromString(*entity->getArgument(9)); } bool IfcSanitaryTerminalType::is(Type::Enum v) { return v == Type::IfcSanitaryTerminalType || IfcFlowTerminalType::is(v); } Type::Enum IfcSanitaryTerminalType::type() { return Type::IfcSanitaryTerminalType; } Type::Enum IfcSanitaryTerminalType::Class() { return Type::IfcSanitaryTerminalType; } -IfcSanitaryTerminalType::IfcSanitaryTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSanitaryTerminalType)) throw; entity = e; } +IfcSanitaryTerminalType::IfcSanitaryTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSanitaryTerminalType)) throw; entity = e; } // IfcScheduleTimeControl bool IfcScheduleTimeControl::hasActualStart() { return !entity->getArgument(5)->isNull(); } IfcDateTimeSelect IfcScheduleTimeControl::ActualStart() { return *entity->getArgument(5); } @@ -8155,7 +8154,7 @@ IfcRelAssignsTasks::list IfcScheduleTimeControl::ScheduleTimeControlAssigned() { bool IfcScheduleTimeControl::is(Type::Enum v) { return v == Type::IfcScheduleTimeControl || IfcControl::is(v); } Type::Enum IfcScheduleTimeControl::type() { return Type::IfcScheduleTimeControl; } Type::Enum IfcScheduleTimeControl::Class() { return Type::IfcScheduleTimeControl; } -IfcScheduleTimeControl::IfcScheduleTimeControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcScheduleTimeControl)) throw; entity = e; } +IfcScheduleTimeControl::IfcScheduleTimeControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcScheduleTimeControl)) throw; entity = e; } // IfcSectionProperties IfcSectionTypeEnum::IfcSectionTypeEnum IfcSectionProperties::SectionType() { return IfcSectionTypeEnum::FromString(*entity->getArgument(0)); } SHARED_PTR IfcSectionProperties::StartProfile() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -8164,7 +8163,7 @@ SHARED_PTR IfcSectionProperties::EndProfile() { return reinterpre bool IfcSectionProperties::is(Type::Enum v) { return v == Type::IfcSectionProperties; } Type::Enum IfcSectionProperties::type() { return Type::IfcSectionProperties; } Type::Enum IfcSectionProperties::Class() { return Type::IfcSectionProperties; } -IfcSectionProperties::IfcSectionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionProperties)) throw; entity = e; } +IfcSectionProperties::IfcSectionProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionProperties)) throw; entity = e; } // IfcSectionReinforcementProperties IfcLengthMeasure IfcSectionReinforcementProperties::LongitudinalStartPosition() { return *entity->getArgument(0); } IfcLengthMeasure IfcSectionReinforcementProperties::LongitudinalEndPosition() { return *entity->getArgument(1); } @@ -8176,7 +8175,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcSectionRe bool IfcSectionReinforcementProperties::is(Type::Enum v) { return v == Type::IfcSectionReinforcementProperties; } Type::Enum IfcSectionReinforcementProperties::type() { return Type::IfcSectionReinforcementProperties; } Type::Enum IfcSectionReinforcementProperties::Class() { return Type::IfcSectionReinforcementProperties; } -IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionReinforcementProperties)) throw; entity = e; } +IfcSectionReinforcementProperties::IfcSectionReinforcementProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionReinforcementProperties)) throw; entity = e; } // IfcSectionedSpine SHARED_PTR IfcSectionedSpine::SpineCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcSectionedSpine::CrossSections() { RETURN_AS_LIST(IfcProfileDef,1) } @@ -8184,20 +8183,20 @@ SHARED_PTR< IfcTemplatedEntityList > IfcSectionedSpine::Cro bool IfcSectionedSpine::is(Type::Enum v) { return v == Type::IfcSectionedSpine || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcSectionedSpine::type() { return Type::IfcSectionedSpine; } Type::Enum IfcSectionedSpine::Class() { return Type::IfcSectionedSpine; } -IfcSectionedSpine::IfcSectionedSpine(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionedSpine)) throw; entity = e; } +IfcSectionedSpine::IfcSectionedSpine(IfcAbstractEntityPtr e) { if (!is(Type::IfcSectionedSpine)) throw; entity = e; } // IfcSensorType IfcSensorTypeEnum::IfcSensorTypeEnum IfcSensorType::PredefinedType() { return IfcSensorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcSensorType::is(Type::Enum v) { return v == Type::IfcSensorType || IfcDistributionControlElementType::is(v); } Type::Enum IfcSensorType::type() { return Type::IfcSensorType; } Type::Enum IfcSensorType::Class() { return Type::IfcSensorType; } -IfcSensorType::IfcSensorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSensorType)) throw; entity = e; } +IfcSensorType::IfcSensorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSensorType)) throw; entity = e; } // IfcServiceLife IfcServiceLifeTypeEnum::IfcServiceLifeTypeEnum IfcServiceLife::ServiceLifeType() { return IfcServiceLifeTypeEnum::FromString(*entity->getArgument(5)); } IfcTimeMeasure IfcServiceLife::ServiceLifeDuration() { return *entity->getArgument(6); } bool IfcServiceLife::is(Type::Enum v) { return v == Type::IfcServiceLife || IfcControl::is(v); } Type::Enum IfcServiceLife::type() { return Type::IfcServiceLife; } Type::Enum IfcServiceLife::Class() { return Type::IfcServiceLife; } -IfcServiceLife::IfcServiceLife(IfcAbstractEntityPtr e) { if (!is(Type::IfcServiceLife)) throw; entity = e; } +IfcServiceLife::IfcServiceLife(IfcAbstractEntityPtr e) { if (!is(Type::IfcServiceLife)) throw; entity = e; } // IfcServiceLifeFactor IfcServiceLifeFactorTypeEnum::IfcServiceLifeFactorTypeEnum IfcServiceLifeFactor::PredefinedType() { return IfcServiceLifeFactorTypeEnum::FromString(*entity->getArgument(4)); } bool IfcServiceLifeFactor::hasUpperValue() { return !entity->getArgument(5)->isNull(); } @@ -8208,7 +8207,7 @@ IfcMeasureValue IfcServiceLifeFactor::LowerValue() { return *entity->getArgument bool IfcServiceLifeFactor::is(Type::Enum v) { return v == Type::IfcServiceLifeFactor || IfcPropertySetDefinition::is(v); } Type::Enum IfcServiceLifeFactor::type() { return Type::IfcServiceLifeFactor; } Type::Enum IfcServiceLifeFactor::Class() { return Type::IfcServiceLifeFactor; } -IfcServiceLifeFactor::IfcServiceLifeFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcServiceLifeFactor)) throw; entity = e; } +IfcServiceLifeFactor::IfcServiceLifeFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcServiceLifeFactor)) throw; entity = e; } // IfcShapeAspect SHARED_PTR< IfcTemplatedEntityList > IfcShapeAspect::ShapeRepresentations() { RETURN_AS_LIST(IfcShapeModel,0) } bool IfcShapeAspect::hasName() { return !entity->getArgument(1)->isNull(); } @@ -8220,29 +8219,29 @@ SHARED_PTR IfcShapeAspect::PartOfProductDefinitionSha bool IfcShapeAspect::is(Type::Enum v) { return v == Type::IfcShapeAspect; } Type::Enum IfcShapeAspect::type() { return Type::IfcShapeAspect; } Type::Enum IfcShapeAspect::Class() { return Type::IfcShapeAspect; } -IfcShapeAspect::IfcShapeAspect(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeAspect)) throw; entity = e; } +IfcShapeAspect::IfcShapeAspect(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeAspect)) throw; entity = e; } // IfcShapeModel IfcShapeAspect::list IfcShapeModel::OfShapeAspect() { RETURN_INVERSE(IfcShapeAspect) } bool IfcShapeModel::is(Type::Enum v) { return v == Type::IfcShapeModel || IfcRepresentation::is(v); } Type::Enum IfcShapeModel::type() { return Type::IfcShapeModel; } Type::Enum IfcShapeModel::Class() { return Type::IfcShapeModel; } -IfcShapeModel::IfcShapeModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeModel)) throw; entity = e; } +IfcShapeModel::IfcShapeModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeModel)) throw; entity = e; } // IfcShapeRepresentation bool IfcShapeRepresentation::is(Type::Enum v) { return v == Type::IfcShapeRepresentation || IfcShapeModel::is(v); } Type::Enum IfcShapeRepresentation::type() { return Type::IfcShapeRepresentation; } Type::Enum IfcShapeRepresentation::Class() { return Type::IfcShapeRepresentation; } -IfcShapeRepresentation::IfcShapeRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeRepresentation)) throw; entity = e; } +IfcShapeRepresentation::IfcShapeRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcShapeRepresentation)) throw; entity = e; } // IfcShellBasedSurfaceModel SHARED_PTR< IfcTemplatedEntityList > IfcShellBasedSurfaceModel::SbsmBoundary() { RETURN_AS_LIST(IfcAbstractSelect,0) } bool IfcShellBasedSurfaceModel::is(Type::Enum v) { return v == Type::IfcShellBasedSurfaceModel || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcShellBasedSurfaceModel::type() { return Type::IfcShellBasedSurfaceModel; } Type::Enum IfcShellBasedSurfaceModel::Class() { return Type::IfcShellBasedSurfaceModel; } -IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcShellBasedSurfaceModel)) throw; entity = e; } +IfcShellBasedSurfaceModel::IfcShellBasedSurfaceModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcShellBasedSurfaceModel)) throw; entity = e; } // IfcSimpleProperty bool IfcSimpleProperty::is(Type::Enum v) { return v == Type::IfcSimpleProperty || IfcProperty::is(v); } Type::Enum IfcSimpleProperty::type() { return Type::IfcSimpleProperty; } Type::Enum IfcSimpleProperty::Class() { return Type::IfcSimpleProperty; } -IfcSimpleProperty::IfcSimpleProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcSimpleProperty)) throw; entity = e; } +IfcSimpleProperty::IfcSimpleProperty(IfcAbstractEntityPtr e) { if (!is(Type::IfcSimpleProperty)) throw; entity = e; } // IfcSite bool IfcSite::hasRefLatitude() { return !entity->getArgument(9)->isNull(); } IfcCompoundPlaneAngleMeasure IfcSite::RefLatitude() { return *entity->getArgument(9); } @@ -8257,20 +8256,20 @@ SHARED_PTR IfcSite::SiteAddress() { return reinterpret_pointer bool IfcSite::is(Type::Enum v) { return v == Type::IfcSite || IfcSpatialStructureElement::is(v); } Type::Enum IfcSite::type() { return Type::IfcSite; } Type::Enum IfcSite::Class() { return Type::IfcSite; } -IfcSite::IfcSite(IfcAbstractEntityPtr e) { if (!is(Type::IfcSite)) throw; entity = e; } +IfcSite::IfcSite(IfcAbstractEntityPtr e) { if (!is(Type::IfcSite)) throw; entity = e; } // IfcSlab bool IfcSlab::hasPredefinedType() { return !entity->getArgument(8)->isNull(); } IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlab::PredefinedType() { return IfcSlabTypeEnum::FromString(*entity->getArgument(8)); } bool IfcSlab::is(Type::Enum v) { return v == Type::IfcSlab || IfcBuildingElement::is(v); } Type::Enum IfcSlab::type() { return Type::IfcSlab; } Type::Enum IfcSlab::Class() { return Type::IfcSlab; } -IfcSlab::IfcSlab(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlab)) throw; entity = e; } +IfcSlab::IfcSlab(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlab)) throw; entity = e; } // IfcSlabType IfcSlabTypeEnum::IfcSlabTypeEnum IfcSlabType::PredefinedType() { return IfcSlabTypeEnum::FromString(*entity->getArgument(9)); } bool IfcSlabType::is(Type::Enum v) { return v == Type::IfcSlabType || IfcBuildingElementType::is(v); } Type::Enum IfcSlabType::type() { return Type::IfcSlabType; } Type::Enum IfcSlabType::Class() { return Type::IfcSlabType; } -IfcSlabType::IfcSlabType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlabType)) throw; entity = e; } +IfcSlabType::IfcSlabType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlabType)) throw; entity = e; } // IfcSlippageConnectionCondition bool IfcSlippageConnectionCondition::hasSlippageX() { return !entity->getArgument(1)->isNull(); } IfcLengthMeasure IfcSlippageConnectionCondition::SlippageX() { return *entity->getArgument(1); } @@ -8281,12 +8280,12 @@ IfcLengthMeasure IfcSlippageConnectionCondition::SlippageZ() { return *entity->g bool IfcSlippageConnectionCondition::is(Type::Enum v) { return v == Type::IfcSlippageConnectionCondition || IfcStructuralConnectionCondition::is(v); } Type::Enum IfcSlippageConnectionCondition::type() { return Type::IfcSlippageConnectionCondition; } Type::Enum IfcSlippageConnectionCondition::Class() { return Type::IfcSlippageConnectionCondition; } -IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlippageConnectionCondition)) throw; entity = e; } +IfcSlippageConnectionCondition::IfcSlippageConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcSlippageConnectionCondition)) throw; entity = e; } // IfcSolidModel bool IfcSolidModel::is(Type::Enum v) { return v == Type::IfcSolidModel || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcSolidModel::type() { return Type::IfcSolidModel; } Type::Enum IfcSolidModel::Class() { return Type::IfcSolidModel; } -IfcSolidModel::IfcSolidModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcSolidModel)) throw; entity = e; } +IfcSolidModel::IfcSolidModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcSolidModel)) throw; entity = e; } // IfcSoundProperties IfcBoolean IfcSoundProperties::IsAttenuating() { return *entity->getArgument(4); } bool IfcSoundProperties::hasSoundScale() { return !entity->getArgument(5)->isNull(); } @@ -8295,7 +8294,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcSoundProperties::SoundVal bool IfcSoundProperties::is(Type::Enum v) { return v == Type::IfcSoundProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcSoundProperties::type() { return Type::IfcSoundProperties; } Type::Enum IfcSoundProperties::Class() { return Type::IfcSoundProperties; } -IfcSoundProperties::IfcSoundProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSoundProperties)) throw; entity = e; } +IfcSoundProperties::IfcSoundProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSoundProperties)) throw; entity = e; } // IfcSoundValue bool IfcSoundValue::hasSoundLevelTimeSeries() { return !entity->getArgument(4)->isNull(); } SHARED_PTR IfcSoundValue::SoundLevelTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(4)); } @@ -8305,7 +8304,7 @@ IfcDerivedMeasureValue IfcSoundValue::SoundLevelSingleValue() { return *entity-> bool IfcSoundValue::is(Type::Enum v) { return v == Type::IfcSoundValue || IfcPropertySetDefinition::is(v); } Type::Enum IfcSoundValue::type() { return Type::IfcSoundValue; } Type::Enum IfcSoundValue::Class() { return Type::IfcSoundValue; } -IfcSoundValue::IfcSoundValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcSoundValue)) throw; entity = e; } +IfcSoundValue::IfcSoundValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcSoundValue)) throw; entity = e; } // IfcSpace IfcInternalOrExternalEnum::IfcInternalOrExternalEnum IfcSpace::InteriorOrExteriorSpace() { return IfcInternalOrExternalEnum::FromString(*entity->getArgument(9)); } bool IfcSpace::hasElevationWithFlooring() { return !entity->getArgument(10)->isNull(); } @@ -8315,13 +8314,13 @@ IfcRelSpaceBoundary::list IfcSpace::BoundedBy() { RETURN_INVERSE(IfcRelSpaceBoun bool IfcSpace::is(Type::Enum v) { return v == Type::IfcSpace || IfcSpatialStructureElement::is(v); } Type::Enum IfcSpace::type() { return Type::IfcSpace; } Type::Enum IfcSpace::Class() { return Type::IfcSpace; } -IfcSpace::IfcSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpace)) throw; entity = e; } +IfcSpace::IfcSpace(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpace)) throw; entity = e; } // IfcSpaceHeaterType IfcSpaceHeaterTypeEnum::IfcSpaceHeaterTypeEnum IfcSpaceHeaterType::PredefinedType() { return IfcSpaceHeaterTypeEnum::FromString(*entity->getArgument(9)); } bool IfcSpaceHeaterType::is(Type::Enum v) { return v == Type::IfcSpaceHeaterType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcSpaceHeaterType::type() { return Type::IfcSpaceHeaterType; } Type::Enum IfcSpaceHeaterType::Class() { return Type::IfcSpaceHeaterType; } -IfcSpaceHeaterType::IfcSpaceHeaterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceHeaterType)) throw; entity = e; } +IfcSpaceHeaterType::IfcSpaceHeaterType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceHeaterType)) throw; entity = e; } // IfcSpaceProgram IfcIdentifier IfcSpaceProgram::SpaceProgramIdentifier() { return *entity->getArgument(5); } bool IfcSpaceProgram::hasMaxRequiredArea() { return !entity->getArgument(6)->isNull(); } @@ -8336,7 +8335,7 @@ IfcRelInteractionRequirements::list IfcSpaceProgram::HasInteractionReqsTo() { RE bool IfcSpaceProgram::is(Type::Enum v) { return v == Type::IfcSpaceProgram || IfcControl::is(v); } Type::Enum IfcSpaceProgram::type() { return Type::IfcSpaceProgram; } Type::Enum IfcSpaceProgram::Class() { return Type::IfcSpaceProgram; } -IfcSpaceProgram::IfcSpaceProgram(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceProgram)) throw; entity = e; } +IfcSpaceProgram::IfcSpaceProgram(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceProgram)) throw; entity = e; } // IfcSpaceThermalLoadProperties bool IfcSpaceThermalLoadProperties::hasApplicableValueRatio() { return !entity->getArgument(4)->isNull(); } IfcPositiveRatioMeasure IfcSpaceThermalLoadProperties::ApplicableValueRatio() { return *entity->getArgument(4); } @@ -8357,13 +8356,13 @@ IfcThermalLoadTypeEnum::IfcThermalLoadTypeEnum IfcSpaceThermalLoadProperties::Th bool IfcSpaceThermalLoadProperties::is(Type::Enum v) { return v == Type::IfcSpaceThermalLoadProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcSpaceThermalLoadProperties::type() { return Type::IfcSpaceThermalLoadProperties; } Type::Enum IfcSpaceThermalLoadProperties::Class() { return Type::IfcSpaceThermalLoadProperties; } -IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceThermalLoadProperties)) throw; entity = e; } +IfcSpaceThermalLoadProperties::IfcSpaceThermalLoadProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceThermalLoadProperties)) throw; entity = e; } // IfcSpaceType IfcSpaceTypeEnum::IfcSpaceTypeEnum IfcSpaceType::PredefinedType() { return IfcSpaceTypeEnum::FromString(*entity->getArgument(9)); } bool IfcSpaceType::is(Type::Enum v) { return v == Type::IfcSpaceType || IfcSpatialStructureElementType::is(v); } Type::Enum IfcSpaceType::type() { return Type::IfcSpaceType; } Type::Enum IfcSpaceType::Class() { return Type::IfcSpaceType; } -IfcSpaceType::IfcSpaceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceType)) throw; entity = e; } +IfcSpaceType::IfcSpaceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpaceType)) throw; entity = e; } // IfcSpatialStructureElement bool IfcSpatialStructureElement::hasLongName() { return !entity->getArgument(7)->isNull(); } IfcLabel IfcSpatialStructureElement::LongName() { return *entity->getArgument(7); } @@ -8374,30 +8373,30 @@ IfcRelContainedInSpatialStructure::list IfcSpatialStructureElement::ContainsElem bool IfcSpatialStructureElement::is(Type::Enum v) { return v == Type::IfcSpatialStructureElement || IfcProduct::is(v); } Type::Enum IfcSpatialStructureElement::type() { return Type::IfcSpatialStructureElement; } Type::Enum IfcSpatialStructureElement::Class() { return Type::IfcSpatialStructureElement; } -IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpatialStructureElement)) throw; entity = e; } +IfcSpatialStructureElement::IfcSpatialStructureElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpatialStructureElement)) throw; entity = e; } // IfcSpatialStructureElementType bool IfcSpatialStructureElementType::is(Type::Enum v) { return v == Type::IfcSpatialStructureElementType || IfcElementType::is(v); } Type::Enum IfcSpatialStructureElementType::type() { return Type::IfcSpatialStructureElementType; } Type::Enum IfcSpatialStructureElementType::Class() { return Type::IfcSpatialStructureElementType; } -IfcSpatialStructureElementType::IfcSpatialStructureElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpatialStructureElementType)) throw; entity = e; } +IfcSpatialStructureElementType::IfcSpatialStructureElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSpatialStructureElementType)) throw; entity = e; } // IfcSphere IfcPositiveLengthMeasure IfcSphere::Radius() { return *entity->getArgument(1); } bool IfcSphere::is(Type::Enum v) { return v == Type::IfcSphere || IfcCsgPrimitive3D::is(v); } Type::Enum IfcSphere::type() { return Type::IfcSphere; } Type::Enum IfcSphere::Class() { return Type::IfcSphere; } -IfcSphere::IfcSphere(IfcAbstractEntityPtr e) { if (!is(Type::IfcSphere)) throw; entity = e; } +IfcSphere::IfcSphere(IfcAbstractEntityPtr e) { if (!is(Type::IfcSphere)) throw; entity = e; } // IfcStackTerminalType IfcStackTerminalTypeEnum::IfcStackTerminalTypeEnum IfcStackTerminalType::PredefinedType() { return IfcStackTerminalTypeEnum::FromString(*entity->getArgument(9)); } bool IfcStackTerminalType::is(Type::Enum v) { return v == Type::IfcStackTerminalType || IfcFlowTerminalType::is(v); } Type::Enum IfcStackTerminalType::type() { return Type::IfcStackTerminalType; } Type::Enum IfcStackTerminalType::Class() { return Type::IfcStackTerminalType; } -IfcStackTerminalType::IfcStackTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcStackTerminalType)) throw; entity = e; } +IfcStackTerminalType::IfcStackTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcStackTerminalType)) throw; entity = e; } // IfcStair IfcStairTypeEnum::IfcStairTypeEnum IfcStair::ShapeType() { return IfcStairTypeEnum::FromString(*entity->getArgument(8)); } bool IfcStair::is(Type::Enum v) { return v == Type::IfcStair || IfcBuildingElement::is(v); } Type::Enum IfcStair::type() { return Type::IfcStair; } Type::Enum IfcStair::Class() { return Type::IfcStair; } -IfcStair::IfcStair(IfcAbstractEntityPtr e) { if (!is(Type::IfcStair)) throw; entity = e; } +IfcStair::IfcStair(IfcAbstractEntityPtr e) { if (!is(Type::IfcStair)) throw; entity = e; } // IfcStairFlight bool IfcStairFlight::hasNumberOfRiser() { return !entity->getArgument(8)->isNull(); } int IfcStairFlight::NumberOfRiser() { return *entity->getArgument(8); } @@ -8410,13 +8409,13 @@ IfcPositiveLengthMeasure IfcStairFlight::TreadLength() { return *entity->getArgu bool IfcStairFlight::is(Type::Enum v) { return v == Type::IfcStairFlight || IfcBuildingElement::is(v); } Type::Enum IfcStairFlight::type() { return Type::IfcStairFlight; } Type::Enum IfcStairFlight::Class() { return Type::IfcStairFlight; } -IfcStairFlight::IfcStairFlight(IfcAbstractEntityPtr e) { if (!is(Type::IfcStairFlight)) throw; entity = e; } +IfcStairFlight::IfcStairFlight(IfcAbstractEntityPtr e) { if (!is(Type::IfcStairFlight)) throw; entity = e; } // IfcStairFlightType IfcStairFlightTypeEnum::IfcStairFlightTypeEnum IfcStairFlightType::PredefinedType() { return IfcStairFlightTypeEnum::FromString(*entity->getArgument(9)); } bool IfcStairFlightType::is(Type::Enum v) { return v == Type::IfcStairFlightType || IfcBuildingElementType::is(v); } Type::Enum IfcStairFlightType::type() { return Type::IfcStairFlightType; } Type::Enum IfcStairFlightType::Class() { return Type::IfcStairFlightType; } -IfcStairFlightType::IfcStairFlightType(IfcAbstractEntityPtr e) { if (!is(Type::IfcStairFlightType)) throw; entity = e; } +IfcStairFlightType::IfcStairFlightType(IfcAbstractEntityPtr e) { if (!is(Type::IfcStairFlightType)) throw; entity = e; } // IfcStructuralAction bool IfcStructuralAction::DestabilizingLoad() { return *entity->getArgument(9); } bool IfcStructuralAction::hasCausedBy() { return !entity->getArgument(10)->isNull(); } @@ -8424,7 +8423,7 @@ SHARED_PTR IfcStructuralAction::CausedBy() { return reint bool IfcStructuralAction::is(Type::Enum v) { return v == Type::IfcStructuralAction || IfcStructuralActivity::is(v); } Type::Enum IfcStructuralAction::type() { return Type::IfcStructuralAction; } Type::Enum IfcStructuralAction::Class() { return Type::IfcStructuralAction; } -IfcStructuralAction::IfcStructuralAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralAction)) throw; entity = e; } +IfcStructuralAction::IfcStructuralAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralAction)) throw; entity = e; } // IfcStructuralActivity SHARED_PTR IfcStructuralActivity::AppliedLoad() { return reinterpret_pointer_cast(*entity->getArgument(7)); } IfcGlobalOrLocalEnum::IfcGlobalOrLocalEnum IfcStructuralActivity::GlobalOrLocal() { return IfcGlobalOrLocalEnum::FromString(*entity->getArgument(8)); } @@ -8432,7 +8431,7 @@ IfcRelConnectsStructuralActivity::list IfcStructuralActivity::AssignedToStructur bool IfcStructuralActivity::is(Type::Enum v) { return v == Type::IfcStructuralActivity || IfcProduct::is(v); } Type::Enum IfcStructuralActivity::type() { return Type::IfcStructuralActivity; } Type::Enum IfcStructuralActivity::Class() { return Type::IfcStructuralActivity; } -IfcStructuralActivity::IfcStructuralActivity(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralActivity)) throw; entity = e; } +IfcStructuralActivity::IfcStructuralActivity(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralActivity)) throw; entity = e; } // IfcStructuralAnalysisModel IfcAnalysisModelTypeEnum::IfcAnalysisModelTypeEnum IfcStructuralAnalysisModel::PredefinedType() { return IfcAnalysisModelTypeEnum::FromString(*entity->getArgument(5)); } bool IfcStructuralAnalysisModel::hasOrientationOf2DPlane() { return !entity->getArgument(6)->isNull(); } @@ -8444,7 +8443,7 @@ SHARED_PTR< IfcTemplatedEntityList > IfcStructuralAnal bool IfcStructuralAnalysisModel::is(Type::Enum v) { return v == Type::IfcStructuralAnalysisModel || IfcSystem::is(v); } Type::Enum IfcStructuralAnalysisModel::type() { return Type::IfcStructuralAnalysisModel; } Type::Enum IfcStructuralAnalysisModel::Class() { return Type::IfcStructuralAnalysisModel; } -IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralAnalysisModel)) throw; entity = e; } +IfcStructuralAnalysisModel::IfcStructuralAnalysisModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralAnalysisModel)) throw; entity = e; } // IfcStructuralConnection bool IfcStructuralConnection::hasAppliedCondition() { return !entity->getArgument(7)->isNull(); } SHARED_PTR IfcStructuralConnection::AppliedCondition() { return reinterpret_pointer_cast(*entity->getArgument(7)); } @@ -8452,56 +8451,56 @@ IfcRelConnectsStructuralMember::list IfcStructuralConnection::ConnectsStructural bool IfcStructuralConnection::is(Type::Enum v) { return v == Type::IfcStructuralConnection || IfcStructuralItem::is(v); } Type::Enum IfcStructuralConnection::type() { return Type::IfcStructuralConnection; } Type::Enum IfcStructuralConnection::Class() { return Type::IfcStructuralConnection; } -IfcStructuralConnection::IfcStructuralConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralConnection)) throw; entity = e; } +IfcStructuralConnection::IfcStructuralConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralConnection)) throw; entity = e; } // IfcStructuralConnectionCondition bool IfcStructuralConnectionCondition::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcStructuralConnectionCondition::Name() { return *entity->getArgument(0); } bool IfcStructuralConnectionCondition::is(Type::Enum v) { return v == Type::IfcStructuralConnectionCondition; } Type::Enum IfcStructuralConnectionCondition::type() { return Type::IfcStructuralConnectionCondition; } Type::Enum IfcStructuralConnectionCondition::Class() { return Type::IfcStructuralConnectionCondition; } -IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralConnectionCondition)) throw; entity = e; } +IfcStructuralConnectionCondition::IfcStructuralConnectionCondition(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralConnectionCondition)) throw; entity = e; } // IfcStructuralCurveConnection bool IfcStructuralCurveConnection::is(Type::Enum v) { return v == Type::IfcStructuralCurveConnection || IfcStructuralConnection::is(v); } Type::Enum IfcStructuralCurveConnection::type() { return Type::IfcStructuralCurveConnection; } Type::Enum IfcStructuralCurveConnection::Class() { return Type::IfcStructuralCurveConnection; } -IfcStructuralCurveConnection::IfcStructuralCurveConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveConnection)) throw; entity = e; } +IfcStructuralCurveConnection::IfcStructuralCurveConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveConnection)) throw; entity = e; } // IfcStructuralCurveMember IfcStructuralCurveTypeEnum::IfcStructuralCurveTypeEnum IfcStructuralCurveMember::PredefinedType() { return IfcStructuralCurveTypeEnum::FromString(*entity->getArgument(7)); } bool IfcStructuralCurveMember::is(Type::Enum v) { return v == Type::IfcStructuralCurveMember || IfcStructuralMember::is(v); } Type::Enum IfcStructuralCurveMember::type() { return Type::IfcStructuralCurveMember; } Type::Enum IfcStructuralCurveMember::Class() { return Type::IfcStructuralCurveMember; } -IfcStructuralCurveMember::IfcStructuralCurveMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveMember)) throw; entity = e; } +IfcStructuralCurveMember::IfcStructuralCurveMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveMember)) throw; entity = e; } // IfcStructuralCurveMemberVarying bool IfcStructuralCurveMemberVarying::is(Type::Enum v) { return v == Type::IfcStructuralCurveMemberVarying || IfcStructuralCurveMember::is(v); } Type::Enum IfcStructuralCurveMemberVarying::type() { return Type::IfcStructuralCurveMemberVarying; } Type::Enum IfcStructuralCurveMemberVarying::Class() { return Type::IfcStructuralCurveMemberVarying; } -IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveMemberVarying)) throw; entity = e; } +IfcStructuralCurveMemberVarying::IfcStructuralCurveMemberVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralCurveMemberVarying)) throw; entity = e; } // IfcStructuralItem IfcRelConnectsStructuralActivity::list IfcStructuralItem::AssignedStructuralActivity() { RETURN_INVERSE(IfcRelConnectsStructuralActivity) } bool IfcStructuralItem::is(Type::Enum v) { return v == Type::IfcStructuralItem || IfcProduct::is(v); } Type::Enum IfcStructuralItem::type() { return Type::IfcStructuralItem; } Type::Enum IfcStructuralItem::Class() { return Type::IfcStructuralItem; } -IfcStructuralItem::IfcStructuralItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralItem)) throw; entity = e; } +IfcStructuralItem::IfcStructuralItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralItem)) throw; entity = e; } // IfcStructuralLinearAction IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralLinearAction::ProjectedOrTrue() { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(11)); } bool IfcStructuralLinearAction::is(Type::Enum v) { return v == Type::IfcStructuralLinearAction || IfcStructuralAction::is(v); } Type::Enum IfcStructuralLinearAction::type() { return Type::IfcStructuralLinearAction; } Type::Enum IfcStructuralLinearAction::Class() { return Type::IfcStructuralLinearAction; } -IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLinearAction)) throw; entity = e; } +IfcStructuralLinearAction::IfcStructuralLinearAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLinearAction)) throw; entity = e; } // IfcStructuralLinearActionVarying SHARED_PTR IfcStructuralLinearActionVarying::VaryingAppliedLoadLocation() { return reinterpret_pointer_cast(*entity->getArgument(12)); } SHARED_PTR< IfcTemplatedEntityList > IfcStructuralLinearActionVarying::SubsequentAppliedLoads() { RETURN_AS_LIST(IfcStructuralLoad,13) } bool IfcStructuralLinearActionVarying::is(Type::Enum v) { return v == Type::IfcStructuralLinearActionVarying || IfcStructuralLinearAction::is(v); } Type::Enum IfcStructuralLinearActionVarying::type() { return Type::IfcStructuralLinearActionVarying; } Type::Enum IfcStructuralLinearActionVarying::Class() { return Type::IfcStructuralLinearActionVarying; } -IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLinearActionVarying)) throw; entity = e; } +IfcStructuralLinearActionVarying::IfcStructuralLinearActionVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLinearActionVarying)) throw; entity = e; } // IfcStructuralLoad bool IfcStructuralLoad::hasName() { return !entity->getArgument(0)->isNull(); } IfcLabel IfcStructuralLoad::Name() { return *entity->getArgument(0); } bool IfcStructuralLoad::is(Type::Enum v) { return v == Type::IfcStructuralLoad; } Type::Enum IfcStructuralLoad::type() { return Type::IfcStructuralLoad; } Type::Enum IfcStructuralLoad::Class() { return Type::IfcStructuralLoad; } -IfcStructuralLoad::IfcStructuralLoad(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoad)) throw; entity = e; } +IfcStructuralLoad::IfcStructuralLoad(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoad)) throw; entity = e; } // IfcStructuralLoadGroup IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcStructuralLoadGroup::PredefinedType() { return IfcLoadGroupTypeEnum::FromString(*entity->getArgument(5)); } IfcActionTypeEnum::IfcActionTypeEnum IfcStructuralLoadGroup::ActionType() { return IfcActionTypeEnum::FromString(*entity->getArgument(6)); } @@ -8515,7 +8514,7 @@ IfcStructuralAnalysisModel::list IfcStructuralLoadGroup::LoadGroupFor() { RETURN bool IfcStructuralLoadGroup::is(Type::Enum v) { return v == Type::IfcStructuralLoadGroup || IfcGroup::is(v); } Type::Enum IfcStructuralLoadGroup::type() { return Type::IfcStructuralLoadGroup; } Type::Enum IfcStructuralLoadGroup::Class() { return Type::IfcStructuralLoadGroup; } -IfcStructuralLoadGroup::IfcStructuralLoadGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadGroup)) throw; entity = e; } +IfcStructuralLoadGroup::IfcStructuralLoadGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadGroup)) throw; entity = e; } // IfcStructuralLoadLinearForce bool IfcStructuralLoadLinearForce::hasLinearForceX() { return !entity->getArgument(1)->isNull(); } IfcLinearForceMeasure IfcStructuralLoadLinearForce::LinearForceX() { return *entity->getArgument(1); } @@ -8532,7 +8531,7 @@ IfcLinearMomentMeasure IfcStructuralLoadLinearForce::LinearMomentZ() { return *e bool IfcStructuralLoadLinearForce::is(Type::Enum v) { return v == Type::IfcStructuralLoadLinearForce || IfcStructuralLoadStatic::is(v); } Type::Enum IfcStructuralLoadLinearForce::type() { return Type::IfcStructuralLoadLinearForce; } Type::Enum IfcStructuralLoadLinearForce::Class() { return Type::IfcStructuralLoadLinearForce; } -IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadLinearForce)) throw; entity = e; } +IfcStructuralLoadLinearForce::IfcStructuralLoadLinearForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadLinearForce)) throw; entity = e; } // IfcStructuralLoadPlanarForce bool IfcStructuralLoadPlanarForce::hasPlanarForceX() { return !entity->getArgument(1)->isNull(); } IfcPlanarForceMeasure IfcStructuralLoadPlanarForce::PlanarForceX() { return *entity->getArgument(1); } @@ -8543,7 +8542,7 @@ IfcPlanarForceMeasure IfcStructuralLoadPlanarForce::PlanarForceZ() { return *ent bool IfcStructuralLoadPlanarForce::is(Type::Enum v) { return v == Type::IfcStructuralLoadPlanarForce || IfcStructuralLoadStatic::is(v); } Type::Enum IfcStructuralLoadPlanarForce::type() { return Type::IfcStructuralLoadPlanarForce; } Type::Enum IfcStructuralLoadPlanarForce::Class() { return Type::IfcStructuralLoadPlanarForce; } -IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadPlanarForce)) throw; entity = e; } +IfcStructuralLoadPlanarForce::IfcStructuralLoadPlanarForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadPlanarForce)) throw; entity = e; } // IfcStructuralLoadSingleDisplacement bool IfcStructuralLoadSingleDisplacement::hasDisplacementX() { return !entity->getArgument(1)->isNull(); } IfcLengthMeasure IfcStructuralLoadSingleDisplacement::DisplacementX() { return *entity->getArgument(1); } @@ -8560,14 +8559,14 @@ IfcPlaneAngleMeasure IfcStructuralLoadSingleDisplacement::RotationalDisplacement bool IfcStructuralLoadSingleDisplacement::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleDisplacement || IfcStructuralLoadStatic::is(v); } Type::Enum IfcStructuralLoadSingleDisplacement::type() { return Type::IfcStructuralLoadSingleDisplacement; } Type::Enum IfcStructuralLoadSingleDisplacement::Class() { return Type::IfcStructuralLoadSingleDisplacement; } -IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleDisplacement)) throw; entity = e; } +IfcStructuralLoadSingleDisplacement::IfcStructuralLoadSingleDisplacement(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleDisplacement)) throw; entity = e; } // IfcStructuralLoadSingleDisplacementDistortion bool IfcStructuralLoadSingleDisplacementDistortion::hasDistortion() { return !entity->getArgument(7)->isNull(); } IfcCurvatureMeasure IfcStructuralLoadSingleDisplacementDistortion::Distortion() { return *entity->getArgument(7); } bool IfcStructuralLoadSingleDisplacementDistortion::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleDisplacementDistortion || IfcStructuralLoadSingleDisplacement::is(v); } Type::Enum IfcStructuralLoadSingleDisplacementDistortion::type() { return Type::IfcStructuralLoadSingleDisplacementDistortion; } Type::Enum IfcStructuralLoadSingleDisplacementDistortion::Class() { return Type::IfcStructuralLoadSingleDisplacementDistortion; } -IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleDisplacementDistortion)) throw; entity = e; } +IfcStructuralLoadSingleDisplacementDistortion::IfcStructuralLoadSingleDisplacementDistortion(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleDisplacementDistortion)) throw; entity = e; } // IfcStructuralLoadSingleForce bool IfcStructuralLoadSingleForce::hasForceX() { return !entity->getArgument(1)->isNull(); } IfcForceMeasure IfcStructuralLoadSingleForce::ForceX() { return *entity->getArgument(1); } @@ -8584,19 +8583,19 @@ IfcTorqueMeasure IfcStructuralLoadSingleForce::MomentZ() { return *entity->getAr bool IfcStructuralLoadSingleForce::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleForce || IfcStructuralLoadStatic::is(v); } Type::Enum IfcStructuralLoadSingleForce::type() { return Type::IfcStructuralLoadSingleForce; } Type::Enum IfcStructuralLoadSingleForce::Class() { return Type::IfcStructuralLoadSingleForce; } -IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleForce)) throw; entity = e; } +IfcStructuralLoadSingleForce::IfcStructuralLoadSingleForce(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleForce)) throw; entity = e; } // IfcStructuralLoadSingleForceWarping bool IfcStructuralLoadSingleForceWarping::hasWarpingMoment() { return !entity->getArgument(7)->isNull(); } IfcWarpingMomentMeasure IfcStructuralLoadSingleForceWarping::WarpingMoment() { return *entity->getArgument(7); } bool IfcStructuralLoadSingleForceWarping::is(Type::Enum v) { return v == Type::IfcStructuralLoadSingleForceWarping || IfcStructuralLoadSingleForce::is(v); } Type::Enum IfcStructuralLoadSingleForceWarping::type() { return Type::IfcStructuralLoadSingleForceWarping; } Type::Enum IfcStructuralLoadSingleForceWarping::Class() { return Type::IfcStructuralLoadSingleForceWarping; } -IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleForceWarping)) throw; entity = e; } +IfcStructuralLoadSingleForceWarping::IfcStructuralLoadSingleForceWarping(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadSingleForceWarping)) throw; entity = e; } // IfcStructuralLoadStatic bool IfcStructuralLoadStatic::is(Type::Enum v) { return v == Type::IfcStructuralLoadStatic || IfcStructuralLoad::is(v); } Type::Enum IfcStructuralLoadStatic::type() { return Type::IfcStructuralLoadStatic; } Type::Enum IfcStructuralLoadStatic::Class() { return Type::IfcStructuralLoadStatic; } -IfcStructuralLoadStatic::IfcStructuralLoadStatic(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadStatic)) throw; entity = e; } +IfcStructuralLoadStatic::IfcStructuralLoadStatic(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadStatic)) throw; entity = e; } // IfcStructuralLoadTemperature bool IfcStructuralLoadTemperature::hasDeltaT_Constant() { return !entity->getArgument(1)->isNull(); } IfcThermodynamicTemperatureMeasure IfcStructuralLoadTemperature::DeltaT_Constant() { return *entity->getArgument(1); } @@ -8607,42 +8606,42 @@ IfcThermodynamicTemperatureMeasure IfcStructuralLoadTemperature::DeltaT_Z() { re bool IfcStructuralLoadTemperature::is(Type::Enum v) { return v == Type::IfcStructuralLoadTemperature || IfcStructuralLoadStatic::is(v); } Type::Enum IfcStructuralLoadTemperature::type() { return Type::IfcStructuralLoadTemperature; } Type::Enum IfcStructuralLoadTemperature::Class() { return Type::IfcStructuralLoadTemperature; } -IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadTemperature)) throw; entity = e; } +IfcStructuralLoadTemperature::IfcStructuralLoadTemperature(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralLoadTemperature)) throw; entity = e; } // IfcStructuralMember IfcRelConnectsStructuralElement::list IfcStructuralMember::ReferencesElement() { RETURN_INVERSE(IfcRelConnectsStructuralElement) } IfcRelConnectsStructuralMember::list IfcStructuralMember::ConnectedBy() { RETURN_INVERSE(IfcRelConnectsStructuralMember) } bool IfcStructuralMember::is(Type::Enum v) { return v == Type::IfcStructuralMember || IfcStructuralItem::is(v); } Type::Enum IfcStructuralMember::type() { return Type::IfcStructuralMember; } Type::Enum IfcStructuralMember::Class() { return Type::IfcStructuralMember; } -IfcStructuralMember::IfcStructuralMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralMember)) throw; entity = e; } +IfcStructuralMember::IfcStructuralMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralMember)) throw; entity = e; } // IfcStructuralPlanarAction IfcProjectedOrTrueLengthEnum::IfcProjectedOrTrueLengthEnum IfcStructuralPlanarAction::ProjectedOrTrue() { return IfcProjectedOrTrueLengthEnum::FromString(*entity->getArgument(11)); } bool IfcStructuralPlanarAction::is(Type::Enum v) { return v == Type::IfcStructuralPlanarAction || IfcStructuralAction::is(v); } Type::Enum IfcStructuralPlanarAction::type() { return Type::IfcStructuralPlanarAction; } Type::Enum IfcStructuralPlanarAction::Class() { return Type::IfcStructuralPlanarAction; } -IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPlanarAction)) throw; entity = e; } +IfcStructuralPlanarAction::IfcStructuralPlanarAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPlanarAction)) throw; entity = e; } // IfcStructuralPlanarActionVarying SHARED_PTR IfcStructuralPlanarActionVarying::VaryingAppliedLoadLocation() { return reinterpret_pointer_cast(*entity->getArgument(12)); } SHARED_PTR< IfcTemplatedEntityList > IfcStructuralPlanarActionVarying::SubsequentAppliedLoads() { RETURN_AS_LIST(IfcStructuralLoad,13) } bool IfcStructuralPlanarActionVarying::is(Type::Enum v) { return v == Type::IfcStructuralPlanarActionVarying || IfcStructuralPlanarAction::is(v); } Type::Enum IfcStructuralPlanarActionVarying::type() { return Type::IfcStructuralPlanarActionVarying; } Type::Enum IfcStructuralPlanarActionVarying::Class() { return Type::IfcStructuralPlanarActionVarying; } -IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPlanarActionVarying)) throw; entity = e; } +IfcStructuralPlanarActionVarying::IfcStructuralPlanarActionVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPlanarActionVarying)) throw; entity = e; } // IfcStructuralPointAction bool IfcStructuralPointAction::is(Type::Enum v) { return v == Type::IfcStructuralPointAction || IfcStructuralAction::is(v); } Type::Enum IfcStructuralPointAction::type() { return Type::IfcStructuralPointAction; } Type::Enum IfcStructuralPointAction::Class() { return Type::IfcStructuralPointAction; } -IfcStructuralPointAction::IfcStructuralPointAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointAction)) throw; entity = e; } +IfcStructuralPointAction::IfcStructuralPointAction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointAction)) throw; entity = e; } // IfcStructuralPointConnection bool IfcStructuralPointConnection::is(Type::Enum v) { return v == Type::IfcStructuralPointConnection || IfcStructuralConnection::is(v); } Type::Enum IfcStructuralPointConnection::type() { return Type::IfcStructuralPointConnection; } Type::Enum IfcStructuralPointConnection::Class() { return Type::IfcStructuralPointConnection; } -IfcStructuralPointConnection::IfcStructuralPointConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointConnection)) throw; entity = e; } +IfcStructuralPointConnection::IfcStructuralPointConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointConnection)) throw; entity = e; } // IfcStructuralPointReaction bool IfcStructuralPointReaction::is(Type::Enum v) { return v == Type::IfcStructuralPointReaction || IfcStructuralReaction::is(v); } Type::Enum IfcStructuralPointReaction::type() { return Type::IfcStructuralPointReaction; } Type::Enum IfcStructuralPointReaction::Class() { return Type::IfcStructuralPointReaction; } -IfcStructuralPointReaction::IfcStructuralPointReaction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointReaction)) throw; entity = e; } +IfcStructuralPointReaction::IfcStructuralPointReaction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralPointReaction)) throw; entity = e; } // IfcStructuralProfileProperties bool IfcStructuralProfileProperties::hasTorsionalConstantX() { return !entity->getArgument(7)->isNull(); } IfcMomentOfInertiaMeasure IfcStructuralProfileProperties::TorsionalConstantX() { return *entity->getArgument(7); } @@ -8679,13 +8678,13 @@ IfcLengthMeasure IfcStructuralProfileProperties::CentreOfGravityInY() { return * bool IfcStructuralProfileProperties::is(Type::Enum v) { return v == Type::IfcStructuralProfileProperties || IfcGeneralProfileProperties::is(v); } Type::Enum IfcStructuralProfileProperties::type() { return Type::IfcStructuralProfileProperties; } Type::Enum IfcStructuralProfileProperties::Class() { return Type::IfcStructuralProfileProperties; } -IfcStructuralProfileProperties::IfcStructuralProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralProfileProperties)) throw; entity = e; } +IfcStructuralProfileProperties::IfcStructuralProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralProfileProperties)) throw; entity = e; } // IfcStructuralReaction IfcStructuralAction::list IfcStructuralReaction::Causes() { RETURN_INVERSE(IfcStructuralAction) } bool IfcStructuralReaction::is(Type::Enum v) { return v == Type::IfcStructuralReaction || IfcStructuralActivity::is(v); } Type::Enum IfcStructuralReaction::type() { return Type::IfcStructuralReaction; } Type::Enum IfcStructuralReaction::Class() { return Type::IfcStructuralReaction; } -IfcStructuralReaction::IfcStructuralReaction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralReaction)) throw; entity = e; } +IfcStructuralReaction::IfcStructuralReaction(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralReaction)) throw; entity = e; } // IfcStructuralResultGroup IfcAnalysisTheoryTypeEnum::IfcAnalysisTheoryTypeEnum IfcStructuralResultGroup::TheoryType() { return IfcAnalysisTheoryTypeEnum::FromString(*entity->getArgument(5)); } bool IfcStructuralResultGroup::hasResultForLoadGroup() { return !entity->getArgument(6)->isNull(); } @@ -8695,7 +8694,7 @@ IfcStructuralAnalysisModel::list IfcStructuralResultGroup::ResultGroupFor() { RE bool IfcStructuralResultGroup::is(Type::Enum v) { return v == Type::IfcStructuralResultGroup || IfcGroup::is(v); } Type::Enum IfcStructuralResultGroup::type() { return Type::IfcStructuralResultGroup; } Type::Enum IfcStructuralResultGroup::Class() { return Type::IfcStructuralResultGroup; } -IfcStructuralResultGroup::IfcStructuralResultGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralResultGroup)) throw; entity = e; } +IfcStructuralResultGroup::IfcStructuralResultGroup(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralResultGroup)) throw; entity = e; } // IfcStructuralSteelProfileProperties bool IfcStructuralSteelProfileProperties::hasShearAreaZ() { return !entity->getArgument(23)->isNull(); } IfcAreaMeasure IfcStructuralSteelProfileProperties::ShearAreaZ() { return *entity->getArgument(23); } @@ -8708,12 +8707,12 @@ IfcPositiveRatioMeasure IfcStructuralSteelProfileProperties::PlasticShapeFactorZ bool IfcStructuralSteelProfileProperties::is(Type::Enum v) { return v == Type::IfcStructuralSteelProfileProperties || IfcStructuralProfileProperties::is(v); } Type::Enum IfcStructuralSteelProfileProperties::type() { return Type::IfcStructuralSteelProfileProperties; } Type::Enum IfcStructuralSteelProfileProperties::Class() { return Type::IfcStructuralSteelProfileProperties; } -IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSteelProfileProperties)) throw; entity = e; } +IfcStructuralSteelProfileProperties::IfcStructuralSteelProfileProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSteelProfileProperties)) throw; entity = e; } // IfcStructuralSurfaceConnection bool IfcStructuralSurfaceConnection::is(Type::Enum v) { return v == Type::IfcStructuralSurfaceConnection || IfcStructuralConnection::is(v); } Type::Enum IfcStructuralSurfaceConnection::type() { return Type::IfcStructuralSurfaceConnection; } Type::Enum IfcStructuralSurfaceConnection::Class() { return Type::IfcStructuralSurfaceConnection; } -IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceConnection)) throw; entity = e; } +IfcStructuralSurfaceConnection::IfcStructuralSurfaceConnection(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceConnection)) throw; entity = e; } // IfcStructuralSurfaceMember IfcStructuralSurfaceTypeEnum::IfcStructuralSurfaceTypeEnum IfcStructuralSurfaceMember::PredefinedType() { return IfcStructuralSurfaceTypeEnum::FromString(*entity->getArgument(7)); } bool IfcStructuralSurfaceMember::hasThickness() { return !entity->getArgument(8)->isNull(); } @@ -8721,24 +8720,24 @@ IfcPositiveLengthMeasure IfcStructuralSurfaceMember::Thickness() { return *entit bool IfcStructuralSurfaceMember::is(Type::Enum v) { return v == Type::IfcStructuralSurfaceMember || IfcStructuralMember::is(v); } Type::Enum IfcStructuralSurfaceMember::type() { return Type::IfcStructuralSurfaceMember; } Type::Enum IfcStructuralSurfaceMember::Class() { return Type::IfcStructuralSurfaceMember; } -IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceMember)) throw; entity = e; } +IfcStructuralSurfaceMember::IfcStructuralSurfaceMember(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceMember)) throw; entity = e; } // IfcStructuralSurfaceMemberVarying -std::vector IfcStructuralSurfaceMemberVarying::SubsequentThickness() { return *entity->getArgument(9); } +std::vector /*[2:?]*/ IfcStructuralSurfaceMemberVarying::SubsequentThickness() { return *entity->getArgument(9); } SHARED_PTR IfcStructuralSurfaceMemberVarying::VaryingThicknessLocation() { return reinterpret_pointer_cast(*entity->getArgument(10)); } bool IfcStructuralSurfaceMemberVarying::is(Type::Enum v) { return v == Type::IfcStructuralSurfaceMemberVarying || IfcStructuralSurfaceMember::is(v); } Type::Enum IfcStructuralSurfaceMemberVarying::type() { return Type::IfcStructuralSurfaceMemberVarying; } Type::Enum IfcStructuralSurfaceMemberVarying::Class() { return Type::IfcStructuralSurfaceMemberVarying; } -IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceMemberVarying)) throw; entity = e; } +IfcStructuralSurfaceMemberVarying::IfcStructuralSurfaceMemberVarying(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuralSurfaceMemberVarying)) throw; entity = e; } // IfcStructuredDimensionCallout bool IfcStructuredDimensionCallout::is(Type::Enum v) { return v == Type::IfcStructuredDimensionCallout || IfcDraughtingCallout::is(v); } Type::Enum IfcStructuredDimensionCallout::type() { return Type::IfcStructuredDimensionCallout; } Type::Enum IfcStructuredDimensionCallout::Class() { return Type::IfcStructuredDimensionCallout; } -IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuredDimensionCallout)) throw; entity = e; } +IfcStructuredDimensionCallout::IfcStructuredDimensionCallout(IfcAbstractEntityPtr e) { if (!is(Type::IfcStructuredDimensionCallout)) throw; entity = e; } // IfcStyleModel bool IfcStyleModel::is(Type::Enum v) { return v == Type::IfcStyleModel || IfcRepresentation::is(v); } Type::Enum IfcStyleModel::type() { return Type::IfcStyleModel; } Type::Enum IfcStyleModel::Class() { return Type::IfcStyleModel; } -IfcStyleModel::IfcStyleModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyleModel)) throw; entity = e; } +IfcStyleModel::IfcStyleModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyleModel)) throw; entity = e; } // IfcStyledItem bool IfcStyledItem::hasItem() { return !entity->getArgument(0)->isNull(); } SHARED_PTR IfcStyledItem::Item() { return reinterpret_pointer_cast(*entity->getArgument(0)); } @@ -8748,12 +8747,12 @@ IfcLabel IfcStyledItem::Name() { return *entity->getArgument(2); } bool IfcStyledItem::is(Type::Enum v) { return v == Type::IfcStyledItem || IfcRepresentationItem::is(v); } Type::Enum IfcStyledItem::type() { return Type::IfcStyledItem; } Type::Enum IfcStyledItem::Class() { return Type::IfcStyledItem; } -IfcStyledItem::IfcStyledItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyledItem)) throw; entity = e; } +IfcStyledItem::IfcStyledItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyledItem)) throw; entity = e; } // IfcStyledRepresentation bool IfcStyledRepresentation::is(Type::Enum v) { return v == Type::IfcStyledRepresentation || IfcStyleModel::is(v); } Type::Enum IfcStyledRepresentation::type() { return Type::IfcStyledRepresentation; } Type::Enum IfcStyledRepresentation::Class() { return Type::IfcStyledRepresentation; } -IfcStyledRepresentation::IfcStyledRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyledRepresentation)) throw; entity = e; } +IfcStyledRepresentation::IfcStyledRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcStyledRepresentation)) throw; entity = e; } // IfcSubContractResource bool IfcSubContractResource::hasSubContractor() { return !entity->getArgument(9)->isNull(); } IfcActorSelect IfcSubContractResource::SubContractor() { return *entity->getArgument(9); } @@ -8762,18 +8761,18 @@ IfcText IfcSubContractResource::JobDescription() { return *entity->getArgument(1 bool IfcSubContractResource::is(Type::Enum v) { return v == Type::IfcSubContractResource || IfcConstructionResource::is(v); } Type::Enum IfcSubContractResource::type() { return Type::IfcSubContractResource; } Type::Enum IfcSubContractResource::Class() { return Type::IfcSubContractResource; } -IfcSubContractResource::IfcSubContractResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcSubContractResource)) throw; entity = e; } +IfcSubContractResource::IfcSubContractResource(IfcAbstractEntityPtr e) { if (!is(Type::IfcSubContractResource)) throw; entity = e; } // IfcSubedge SHARED_PTR IfcSubedge::ParentEdge() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcSubedge::is(Type::Enum v) { return v == Type::IfcSubedge || IfcEdge::is(v); } Type::Enum IfcSubedge::type() { return Type::IfcSubedge; } Type::Enum IfcSubedge::Class() { return Type::IfcSubedge; } -IfcSubedge::IfcSubedge(IfcAbstractEntityPtr e) { if (!is(Type::IfcSubedge)) throw; entity = e; } +IfcSubedge::IfcSubedge(IfcAbstractEntityPtr e) { if (!is(Type::IfcSubedge)) throw; entity = e; } // IfcSurface bool IfcSurface::is(Type::Enum v) { return v == Type::IfcSurface || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcSurface::type() { return Type::IfcSurface; } Type::Enum IfcSurface::Class() { return Type::IfcSurface; } -IfcSurface::IfcSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurface)) throw; entity = e; } +IfcSurface::IfcSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurface)) throw; entity = e; } // IfcSurfaceCurveSweptAreaSolid SHARED_PTR IfcSurfaceCurveSweptAreaSolid::Directrix() { return reinterpret_pointer_cast(*entity->getArgument(2)); } IfcParameterValue IfcSurfaceCurveSweptAreaSolid::StartParam() { return *entity->getArgument(3); } @@ -8782,27 +8781,27 @@ SHARED_PTR IfcSurfaceCurveSweptAreaSolid::ReferenceSurface() { retur bool IfcSurfaceCurveSweptAreaSolid::is(Type::Enum v) { return v == Type::IfcSurfaceCurveSweptAreaSolid || IfcSweptAreaSolid::is(v); } Type::Enum IfcSurfaceCurveSweptAreaSolid::type() { return Type::IfcSurfaceCurveSweptAreaSolid; } Type::Enum IfcSurfaceCurveSweptAreaSolid::Class() { return Type::IfcSurfaceCurveSweptAreaSolid; } -IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceCurveSweptAreaSolid)) throw; entity = e; } +IfcSurfaceCurveSweptAreaSolid::IfcSurfaceCurveSweptAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceCurveSweptAreaSolid)) throw; entity = e; } // IfcSurfaceOfLinearExtrusion SHARED_PTR IfcSurfaceOfLinearExtrusion::ExtrudedDirection() { return reinterpret_pointer_cast(*entity->getArgument(2)); } IfcLengthMeasure IfcSurfaceOfLinearExtrusion::Depth() { return *entity->getArgument(3); } bool IfcSurfaceOfLinearExtrusion::is(Type::Enum v) { return v == Type::IfcSurfaceOfLinearExtrusion || IfcSweptSurface::is(v); } Type::Enum IfcSurfaceOfLinearExtrusion::type() { return Type::IfcSurfaceOfLinearExtrusion; } Type::Enum IfcSurfaceOfLinearExtrusion::Class() { return Type::IfcSurfaceOfLinearExtrusion; } -IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceOfLinearExtrusion)) throw; entity = e; } +IfcSurfaceOfLinearExtrusion::IfcSurfaceOfLinearExtrusion(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceOfLinearExtrusion)) throw; entity = e; } // IfcSurfaceOfRevolution SHARED_PTR IfcSurfaceOfRevolution::AxisPosition() { return reinterpret_pointer_cast(*entity->getArgument(2)); } bool IfcSurfaceOfRevolution::is(Type::Enum v) { return v == Type::IfcSurfaceOfRevolution || IfcSweptSurface::is(v); } Type::Enum IfcSurfaceOfRevolution::type() { return Type::IfcSurfaceOfRevolution; } Type::Enum IfcSurfaceOfRevolution::Class() { return Type::IfcSurfaceOfRevolution; } -IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceOfRevolution)) throw; entity = e; } +IfcSurfaceOfRevolution::IfcSurfaceOfRevolution(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceOfRevolution)) throw; entity = e; } // IfcSurfaceStyle IfcSurfaceSide::IfcSurfaceSide IfcSurfaceStyle::Side() { return IfcSurfaceSide::FromString(*entity->getArgument(1)); } SHARED_PTR< IfcTemplatedEntityList > IfcSurfaceStyle::Styles() { RETURN_AS_LIST(IfcAbstractSelect,2) } bool IfcSurfaceStyle::is(Type::Enum v) { return v == Type::IfcSurfaceStyle || IfcPresentationStyle::is(v); } Type::Enum IfcSurfaceStyle::type() { return Type::IfcSurfaceStyle; } Type::Enum IfcSurfaceStyle::Class() { return Type::IfcSurfaceStyle; } -IfcSurfaceStyle::IfcSurfaceStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyle)) throw; entity = e; } +IfcSurfaceStyle::IfcSurfaceStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyle)) throw; entity = e; } // IfcSurfaceStyleLighting SHARED_PTR IfcSurfaceStyleLighting::DiffuseTransmissionColour() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcSurfaceStyleLighting::DiffuseReflectionColour() { return reinterpret_pointer_cast(*entity->getArgument(1)); } @@ -8811,7 +8810,7 @@ SHARED_PTR IfcSurfaceStyleLighting::ReflectanceColour() { return r bool IfcSurfaceStyleLighting::is(Type::Enum v) { return v == Type::IfcSurfaceStyleLighting; } Type::Enum IfcSurfaceStyleLighting::type() { return Type::IfcSurfaceStyleLighting; } Type::Enum IfcSurfaceStyleLighting::Class() { return Type::IfcSurfaceStyleLighting; } -IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleLighting)) throw; entity = e; } +IfcSurfaceStyleLighting::IfcSurfaceStyleLighting(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleLighting)) throw; entity = e; } // IfcSurfaceStyleRefraction bool IfcSurfaceStyleRefraction::hasRefractionIndex() { return !entity->getArgument(0)->isNull(); } IfcReal IfcSurfaceStyleRefraction::RefractionIndex() { return *entity->getArgument(0); } @@ -8820,7 +8819,7 @@ IfcReal IfcSurfaceStyleRefraction::DispersionFactor() { return *entity->getArgum bool IfcSurfaceStyleRefraction::is(Type::Enum v) { return v == Type::IfcSurfaceStyleRefraction; } Type::Enum IfcSurfaceStyleRefraction::type() { return Type::IfcSurfaceStyleRefraction; } Type::Enum IfcSurfaceStyleRefraction::Class() { return Type::IfcSurfaceStyleRefraction; } -IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleRefraction)) throw; entity = e; } +IfcSurfaceStyleRefraction::IfcSurfaceStyleRefraction(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleRefraction)) throw; entity = e; } // IfcSurfaceStyleRendering bool IfcSurfaceStyleRendering::hasTransparency() { return !entity->getArgument(1)->isNull(); } IfcNormalisedRatioMeasure IfcSurfaceStyleRendering::Transparency() { return *entity->getArgument(1); } @@ -8840,19 +8839,19 @@ IfcReflectanceMethodEnum::IfcReflectanceMethodEnum IfcSurfaceStyleRendering::Ref bool IfcSurfaceStyleRendering::is(Type::Enum v) { return v == Type::IfcSurfaceStyleRendering || IfcSurfaceStyleShading::is(v); } Type::Enum IfcSurfaceStyleRendering::type() { return Type::IfcSurfaceStyleRendering; } Type::Enum IfcSurfaceStyleRendering::Class() { return Type::IfcSurfaceStyleRendering; } -IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleRendering)) throw; entity = e; } +IfcSurfaceStyleRendering::IfcSurfaceStyleRendering(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleRendering)) throw; entity = e; } // IfcSurfaceStyleShading SHARED_PTR IfcSurfaceStyleShading::SurfaceColour() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcSurfaceStyleShading::is(Type::Enum v) { return v == Type::IfcSurfaceStyleShading; } Type::Enum IfcSurfaceStyleShading::type() { return Type::IfcSurfaceStyleShading; } Type::Enum IfcSurfaceStyleShading::Class() { return Type::IfcSurfaceStyleShading; } -IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleShading)) throw; entity = e; } +IfcSurfaceStyleShading::IfcSurfaceStyleShading(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleShading)) throw; entity = e; } // IfcSurfaceStyleWithTextures SHARED_PTR< IfcTemplatedEntityList > IfcSurfaceStyleWithTextures::Textures() { RETURN_AS_LIST(IfcSurfaceTexture,0) } bool IfcSurfaceStyleWithTextures::is(Type::Enum v) { return v == Type::IfcSurfaceStyleWithTextures; } Type::Enum IfcSurfaceStyleWithTextures::type() { return Type::IfcSurfaceStyleWithTextures; } Type::Enum IfcSurfaceStyleWithTextures::Class() { return Type::IfcSurfaceStyleWithTextures; } -IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleWithTextures)) throw; entity = e; } +IfcSurfaceStyleWithTextures::IfcSurfaceStyleWithTextures(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceStyleWithTextures)) throw; entity = e; } // IfcSurfaceTexture bool IfcSurfaceTexture::RepeatS() { return *entity->getArgument(0); } bool IfcSurfaceTexture::RepeatT() { return *entity->getArgument(1); } @@ -8862,14 +8861,14 @@ SHARED_PTR IfcSurfaceTexture::TextureTrans bool IfcSurfaceTexture::is(Type::Enum v) { return v == Type::IfcSurfaceTexture; } Type::Enum IfcSurfaceTexture::type() { return Type::IfcSurfaceTexture; } Type::Enum IfcSurfaceTexture::Class() { return Type::IfcSurfaceTexture; } -IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceTexture)) throw; entity = e; } +IfcSurfaceTexture::IfcSurfaceTexture(IfcAbstractEntityPtr e) { if (!is(Type::IfcSurfaceTexture)) throw; entity = e; } // IfcSweptAreaSolid SHARED_PTR IfcSweptAreaSolid::SweptArea() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcSweptAreaSolid::Position() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcSweptAreaSolid::is(Type::Enum v) { return v == Type::IfcSweptAreaSolid || IfcSolidModel::is(v); } Type::Enum IfcSweptAreaSolid::type() { return Type::IfcSweptAreaSolid; } Type::Enum IfcSweptAreaSolid::Class() { return Type::IfcSweptAreaSolid; } -IfcSweptAreaSolid::IfcSweptAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptAreaSolid)) throw; entity = e; } +IfcSweptAreaSolid::IfcSweptAreaSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptAreaSolid)) throw; entity = e; } // IfcSweptDiskSolid SHARED_PTR IfcSweptDiskSolid::Directrix() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcPositiveLengthMeasure IfcSweptDiskSolid::Radius() { return *entity->getArgument(1); } @@ -8880,37 +8879,37 @@ IfcParameterValue IfcSweptDiskSolid::EndParam() { return *entity->getArgument(4) bool IfcSweptDiskSolid::is(Type::Enum v) { return v == Type::IfcSweptDiskSolid || IfcSolidModel::is(v); } Type::Enum IfcSweptDiskSolid::type() { return Type::IfcSweptDiskSolid; } Type::Enum IfcSweptDiskSolid::Class() { return Type::IfcSweptDiskSolid; } -IfcSweptDiskSolid::IfcSweptDiskSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptDiskSolid)) throw; entity = e; } +IfcSweptDiskSolid::IfcSweptDiskSolid(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptDiskSolid)) throw; entity = e; } // IfcSweptSurface SHARED_PTR IfcSweptSurface::SweptCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR IfcSweptSurface::Position() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcSweptSurface::is(Type::Enum v) { return v == Type::IfcSweptSurface || IfcSurface::is(v); } Type::Enum IfcSweptSurface::type() { return Type::IfcSweptSurface; } Type::Enum IfcSweptSurface::Class() { return Type::IfcSweptSurface; } -IfcSweptSurface::IfcSweptSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptSurface)) throw; entity = e; } +IfcSweptSurface::IfcSweptSurface(IfcAbstractEntityPtr e) { if (!is(Type::IfcSweptSurface)) throw; entity = e; } // IfcSwitchingDeviceType IfcSwitchingDeviceTypeEnum::IfcSwitchingDeviceTypeEnum IfcSwitchingDeviceType::PredefinedType() { return IfcSwitchingDeviceTypeEnum::FromString(*entity->getArgument(9)); } bool IfcSwitchingDeviceType::is(Type::Enum v) { return v == Type::IfcSwitchingDeviceType || IfcFlowControllerType::is(v); } Type::Enum IfcSwitchingDeviceType::type() { return Type::IfcSwitchingDeviceType; } Type::Enum IfcSwitchingDeviceType::Class() { return Type::IfcSwitchingDeviceType; } -IfcSwitchingDeviceType::IfcSwitchingDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSwitchingDeviceType)) throw; entity = e; } +IfcSwitchingDeviceType::IfcSwitchingDeviceType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSwitchingDeviceType)) throw; entity = e; } // IfcSymbolStyle IfcSymbolStyleSelect IfcSymbolStyle::StyleOfSymbol() { return *entity->getArgument(1); } bool IfcSymbolStyle::is(Type::Enum v) { return v == Type::IfcSymbolStyle || IfcPresentationStyle::is(v); } Type::Enum IfcSymbolStyle::type() { return Type::IfcSymbolStyle; } Type::Enum IfcSymbolStyle::Class() { return Type::IfcSymbolStyle; } -IfcSymbolStyle::IfcSymbolStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcSymbolStyle)) throw; entity = e; } +IfcSymbolStyle::IfcSymbolStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcSymbolStyle)) throw; entity = e; } // IfcSystem IfcRelServicesBuildings::list IfcSystem::ServicesBuildings() { RETURN_INVERSE(IfcRelServicesBuildings) } bool IfcSystem::is(Type::Enum v) { return v == Type::IfcSystem || IfcGroup::is(v); } Type::Enum IfcSystem::type() { return Type::IfcSystem; } Type::Enum IfcSystem::Class() { return Type::IfcSystem; } -IfcSystem::IfcSystem(IfcAbstractEntityPtr e) { if (!is(Type::IfcSystem)) throw; entity = e; } +IfcSystem::IfcSystem(IfcAbstractEntityPtr e) { if (!is(Type::IfcSystem)) throw; entity = e; } // IfcSystemFurnitureElementType bool IfcSystemFurnitureElementType::is(Type::Enum v) { return v == Type::IfcSystemFurnitureElementType || IfcFurnishingElementType::is(v); } Type::Enum IfcSystemFurnitureElementType::type() { return Type::IfcSystemFurnitureElementType; } Type::Enum IfcSystemFurnitureElementType::Class() { return Type::IfcSystemFurnitureElementType; } -IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSystemFurnitureElementType)) throw; entity = e; } +IfcSystemFurnitureElementType::IfcSystemFurnitureElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcSystemFurnitureElementType)) throw; entity = e; } // IfcTShapeProfileDef IfcPositiveLengthMeasure IfcTShapeProfileDef::Depth() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcTShapeProfileDef::FlangeWidth() { return *entity->getArgument(4); } @@ -8931,14 +8930,14 @@ IfcPositiveLengthMeasure IfcTShapeProfileDef::CentreOfGravityInY() { return *ent bool IfcTShapeProfileDef::is(Type::Enum v) { return v == Type::IfcTShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcTShapeProfileDef::type() { return Type::IfcTShapeProfileDef; } Type::Enum IfcTShapeProfileDef::Class() { return Type::IfcTShapeProfileDef; } -IfcTShapeProfileDef::IfcTShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcTShapeProfileDef)) throw; entity = e; } +IfcTShapeProfileDef::IfcTShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcTShapeProfileDef)) throw; entity = e; } // IfcTable std::string IfcTable::Name() { return *entity->getArgument(0); } SHARED_PTR< IfcTemplatedEntityList > IfcTable::Rows() { RETURN_AS_LIST(IfcTableRow,1) } bool IfcTable::is(Type::Enum v) { return v == Type::IfcTable; } Type::Enum IfcTable::type() { return Type::IfcTable; } Type::Enum IfcTable::Class() { return Type::IfcTable; } -IfcTable::IfcTable(IfcAbstractEntityPtr e) { if (!is(Type::IfcTable)) throw; entity = e; } +IfcTable::IfcTable(IfcAbstractEntityPtr e) { if (!is(Type::IfcTable)) throw; entity = e; } // IfcTableRow SHARED_PTR< IfcTemplatedEntityList > IfcTableRow::RowCells() { RETURN_AS_LIST(IfcAbstractSelect,0) } bool IfcTableRow::IsHeading() { return *entity->getArgument(1); } @@ -8946,13 +8945,13 @@ IfcTable::list IfcTableRow::OfTable() { RETURN_INVERSE(IfcTable) } bool IfcTableRow::is(Type::Enum v) { return v == Type::IfcTableRow; } Type::Enum IfcTableRow::type() { return Type::IfcTableRow; } Type::Enum IfcTableRow::Class() { return Type::IfcTableRow; } -IfcTableRow::IfcTableRow(IfcAbstractEntityPtr e) { if (!is(Type::IfcTableRow)) throw; entity = e; } +IfcTableRow::IfcTableRow(IfcAbstractEntityPtr e) { if (!is(Type::IfcTableRow)) throw; entity = e; } // IfcTankType IfcTankTypeEnum::IfcTankTypeEnum IfcTankType::PredefinedType() { return IfcTankTypeEnum::FromString(*entity->getArgument(9)); } bool IfcTankType::is(Type::Enum v) { return v == Type::IfcTankType || IfcFlowStorageDeviceType::is(v); } Type::Enum IfcTankType::type() { return Type::IfcTankType; } Type::Enum IfcTankType::Class() { return Type::IfcTankType; } -IfcTankType::IfcTankType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTankType)) throw; entity = e; } +IfcTankType::IfcTankType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTankType)) throw; entity = e; } // IfcTask IfcIdentifier IfcTask::TaskId() { return *entity->getArgument(5); } bool IfcTask::hasStatus() { return !entity->getArgument(6)->isNull(); } @@ -8965,22 +8964,22 @@ int IfcTask::Priority() { return *entity->getArgument(9); } bool IfcTask::is(Type::Enum v) { return v == Type::IfcTask || IfcProcess::is(v); } Type::Enum IfcTask::type() { return Type::IfcTask; } Type::Enum IfcTask::Class() { return Type::IfcTask; } -IfcTask::IfcTask(IfcAbstractEntityPtr e) { if (!is(Type::IfcTask)) throw; entity = e; } +IfcTask::IfcTask(IfcAbstractEntityPtr e) { if (!is(Type::IfcTask)) throw; entity = e; } // IfcTelecomAddress bool IfcTelecomAddress::hasTelephoneNumbers() { return !entity->getArgument(3)->isNull(); } -std::vector IfcTelecomAddress::TelephoneNumbers() { return *entity->getArgument(3); } +std::vector /*[1:?]*/ IfcTelecomAddress::TelephoneNumbers() { return *entity->getArgument(3); } bool IfcTelecomAddress::hasFacsimileNumbers() { return !entity->getArgument(4)->isNull(); } -std::vector IfcTelecomAddress::FacsimileNumbers() { return *entity->getArgument(4); } +std::vector /*[1:?]*/ IfcTelecomAddress::FacsimileNumbers() { return *entity->getArgument(4); } bool IfcTelecomAddress::hasPagerNumber() { return !entity->getArgument(5)->isNull(); } IfcLabel IfcTelecomAddress::PagerNumber() { return *entity->getArgument(5); } bool IfcTelecomAddress::hasElectronicMailAddresses() { return !entity->getArgument(6)->isNull(); } -std::vector IfcTelecomAddress::ElectronicMailAddresses() { return *entity->getArgument(6); } +std::vector /*[1:?]*/ IfcTelecomAddress::ElectronicMailAddresses() { return *entity->getArgument(6); } bool IfcTelecomAddress::hasWWWHomePageURL() { return !entity->getArgument(7)->isNull(); } IfcLabel IfcTelecomAddress::WWWHomePageURL() { return *entity->getArgument(7); } bool IfcTelecomAddress::is(Type::Enum v) { return v == Type::IfcTelecomAddress || IfcAddress::is(v); } Type::Enum IfcTelecomAddress::type() { return Type::IfcTelecomAddress; } Type::Enum IfcTelecomAddress::Class() { return Type::IfcTelecomAddress; } -IfcTelecomAddress::IfcTelecomAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcTelecomAddress)) throw; entity = e; } +IfcTelecomAddress::IfcTelecomAddress(IfcAbstractEntityPtr e) { if (!is(Type::IfcTelecomAddress)) throw; entity = e; } // IfcTendon IfcTendonTypeEnum::IfcTendonTypeEnum IfcTendon::PredefinedType() { return IfcTendonTypeEnum::FromString(*entity->getArgument(9)); } IfcPositiveLengthMeasure IfcTendon::NominalDiameter() { return *entity->getArgument(10); } @@ -8998,18 +8997,18 @@ IfcPositiveLengthMeasure IfcTendon::MinCurvatureRadius() { return *entity->getAr bool IfcTendon::is(Type::Enum v) { return v == Type::IfcTendon || IfcReinforcingElement::is(v); } Type::Enum IfcTendon::type() { return Type::IfcTendon; } Type::Enum IfcTendon::Class() { return Type::IfcTendon; } -IfcTendon::IfcTendon(IfcAbstractEntityPtr e) { if (!is(Type::IfcTendon)) throw; entity = e; } +IfcTendon::IfcTendon(IfcAbstractEntityPtr e) { if (!is(Type::IfcTendon)) throw; entity = e; } // IfcTendonAnchor bool IfcTendonAnchor::is(Type::Enum v) { return v == Type::IfcTendonAnchor || IfcReinforcingElement::is(v); } Type::Enum IfcTendonAnchor::type() { return Type::IfcTendonAnchor; } Type::Enum IfcTendonAnchor::Class() { return Type::IfcTendonAnchor; } -IfcTendonAnchor::IfcTendonAnchor(IfcAbstractEntityPtr e) { if (!is(Type::IfcTendonAnchor)) throw; entity = e; } +IfcTendonAnchor::IfcTendonAnchor(IfcAbstractEntityPtr e) { if (!is(Type::IfcTendonAnchor)) throw; entity = e; } // IfcTerminatorSymbol SHARED_PTR IfcTerminatorSymbol::AnnotatedCurve() { return reinterpret_pointer_cast(*entity->getArgument(3)); } bool IfcTerminatorSymbol::is(Type::Enum v) { return v == Type::IfcTerminatorSymbol || IfcAnnotationSymbolOccurrence::is(v); } Type::Enum IfcTerminatorSymbol::type() { return Type::IfcTerminatorSymbol; } Type::Enum IfcTerminatorSymbol::Class() { return Type::IfcTerminatorSymbol; } -IfcTerminatorSymbol::IfcTerminatorSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcTerminatorSymbol)) throw; entity = e; } +IfcTerminatorSymbol::IfcTerminatorSymbol(IfcAbstractEntityPtr e) { if (!is(Type::IfcTerminatorSymbol)) throw; entity = e; } // IfcTextLiteral IfcPresentableText IfcTextLiteral::Literal() { return *entity->getArgument(0); } IfcAxis2Placement IfcTextLiteral::Placement() { return *entity->getArgument(1); } @@ -9017,14 +9016,14 @@ IfcTextPath::IfcTextPath IfcTextLiteral::Path() { return IfcTextPath::FromString bool IfcTextLiteral::is(Type::Enum v) { return v == Type::IfcTextLiteral || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcTextLiteral::type() { return Type::IfcTextLiteral; } Type::Enum IfcTextLiteral::Class() { return Type::IfcTextLiteral; } -IfcTextLiteral::IfcTextLiteral(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextLiteral)) throw; entity = e; } +IfcTextLiteral::IfcTextLiteral(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextLiteral)) throw; entity = e; } // IfcTextLiteralWithExtent SHARED_PTR IfcTextLiteralWithExtent::Extent() { return reinterpret_pointer_cast(*entity->getArgument(3)); } IfcBoxAlignment IfcTextLiteralWithExtent::BoxAlignment() { return *entity->getArgument(4); } bool IfcTextLiteralWithExtent::is(Type::Enum v) { return v == Type::IfcTextLiteralWithExtent || IfcTextLiteral::is(v); } Type::Enum IfcTextLiteralWithExtent::type() { return Type::IfcTextLiteralWithExtent; } Type::Enum IfcTextLiteralWithExtent::Class() { return Type::IfcTextLiteralWithExtent; } -IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextLiteralWithExtent)) throw; entity = e; } +IfcTextLiteralWithExtent::IfcTextLiteralWithExtent(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextLiteralWithExtent)) throw; entity = e; } // IfcTextStyle bool IfcTextStyle::hasTextCharacterAppearance() { return !entity->getArgument(1)->isNull(); } IfcCharacterStyleSelect IfcTextStyle::TextCharacterAppearance() { return *entity->getArgument(1); } @@ -9034,10 +9033,10 @@ IfcTextFontSelect IfcTextStyle::TextFontStyle() { return *entity->getArgument(3) bool IfcTextStyle::is(Type::Enum v) { return v == Type::IfcTextStyle || IfcPresentationStyle::is(v); } Type::Enum IfcTextStyle::type() { return Type::IfcTextStyle; } Type::Enum IfcTextStyle::Class() { return Type::IfcTextStyle; } -IfcTextStyle::IfcTextStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyle)) throw; entity = e; } +IfcTextStyle::IfcTextStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyle)) throw; entity = e; } // IfcTextStyleFontModel bool IfcTextStyleFontModel::hasFontFamily() { return !entity->getArgument(1)->isNull(); } -std::vector IfcTextStyleFontModel::FontFamily() { return *entity->getArgument(1); } +std::vector /*[1:?]*/ IfcTextStyleFontModel::FontFamily() { return *entity->getArgument(1); } bool IfcTextStyleFontModel::hasFontStyle() { return !entity->getArgument(2)->isNull(); } IfcFontStyle IfcTextStyleFontModel::FontStyle() { return *entity->getArgument(2); } bool IfcTextStyleFontModel::hasFontVariant() { return !entity->getArgument(3)->isNull(); } @@ -9048,7 +9047,7 @@ IfcSizeSelect IfcTextStyleFontModel::FontSize() { return *entity->getArgument(5) bool IfcTextStyleFontModel::is(Type::Enum v) { return v == Type::IfcTextStyleFontModel || IfcPreDefinedTextFont::is(v); } Type::Enum IfcTextStyleFontModel::type() { return Type::IfcTextStyleFontModel; } Type::Enum IfcTextStyleFontModel::Class() { return Type::IfcTextStyleFontModel; } -IfcTextStyleFontModel::IfcTextStyleFontModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleFontModel)) throw; entity = e; } +IfcTextStyleFontModel::IfcTextStyleFontModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleFontModel)) throw; entity = e; } // IfcTextStyleForDefinedFont IfcColour IfcTextStyleForDefinedFont::Colour() { return *entity->getArgument(0); } bool IfcTextStyleForDefinedFont::hasBackgroundColour() { return !entity->getArgument(1)->isNull(); } @@ -9056,7 +9055,7 @@ IfcColour IfcTextStyleForDefinedFont::BackgroundColour() { return *entity->getAr bool IfcTextStyleForDefinedFont::is(Type::Enum v) { return v == Type::IfcTextStyleForDefinedFont; } Type::Enum IfcTextStyleForDefinedFont::type() { return Type::IfcTextStyleForDefinedFont; } Type::Enum IfcTextStyleForDefinedFont::Class() { return Type::IfcTextStyleForDefinedFont; } -IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleForDefinedFont)) throw; entity = e; } +IfcTextStyleForDefinedFont::IfcTextStyleForDefinedFont(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleForDefinedFont)) throw; entity = e; } // IfcTextStyleTextModel bool IfcTextStyleTextModel::hasTextIndent() { return !entity->getArgument(0)->isNull(); } IfcSizeSelect IfcTextStyleTextModel::TextIndent() { return *entity->getArgument(0); } @@ -9075,7 +9074,7 @@ IfcSizeSelect IfcTextStyleTextModel::LineHeight() { return *entity->getArgument( bool IfcTextStyleTextModel::is(Type::Enum v) { return v == Type::IfcTextStyleTextModel; } Type::Enum IfcTextStyleTextModel::type() { return Type::IfcTextStyleTextModel; } Type::Enum IfcTextStyleTextModel::Class() { return Type::IfcTextStyleTextModel; } -IfcTextStyleTextModel::IfcTextStyleTextModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleTextModel)) throw; entity = e; } +IfcTextStyleTextModel::IfcTextStyleTextModel(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleTextModel)) throw; entity = e; } // IfcTextStyleWithBoxCharacteristics bool IfcTextStyleWithBoxCharacteristics::hasBoxHeight() { return !entity->getArgument(0)->isNull(); } IfcPositiveLengthMeasure IfcTextStyleWithBoxCharacteristics::BoxHeight() { return *entity->getArgument(0); } @@ -9090,32 +9089,32 @@ IfcSizeSelect IfcTextStyleWithBoxCharacteristics::CharacterSpacing() { return *e bool IfcTextStyleWithBoxCharacteristics::is(Type::Enum v) { return v == Type::IfcTextStyleWithBoxCharacteristics; } Type::Enum IfcTextStyleWithBoxCharacteristics::type() { return Type::IfcTextStyleWithBoxCharacteristics; } Type::Enum IfcTextStyleWithBoxCharacteristics::Class() { return Type::IfcTextStyleWithBoxCharacteristics; } -IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleWithBoxCharacteristics)) throw; entity = e; } +IfcTextStyleWithBoxCharacteristics::IfcTextStyleWithBoxCharacteristics(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextStyleWithBoxCharacteristics)) throw; entity = e; } // IfcTextureCoordinate IfcAnnotationSurface::list IfcTextureCoordinate::AnnotatedSurface() { RETURN_INVERSE(IfcAnnotationSurface) } bool IfcTextureCoordinate::is(Type::Enum v) { return v == Type::IfcTextureCoordinate; } Type::Enum IfcTextureCoordinate::type() { return Type::IfcTextureCoordinate; } Type::Enum IfcTextureCoordinate::Class() { return Type::IfcTextureCoordinate; } -IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureCoordinate)) throw; entity = e; } +IfcTextureCoordinate::IfcTextureCoordinate(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureCoordinate)) throw; entity = e; } // IfcTextureCoordinateGenerator IfcLabel IfcTextureCoordinateGenerator::Mode() { return *entity->getArgument(0); } SHARED_PTR< IfcTemplatedEntityList > IfcTextureCoordinateGenerator::Parameter() { RETURN_AS_LIST(IfcAbstractSelect,1) } bool IfcTextureCoordinateGenerator::is(Type::Enum v) { return v == Type::IfcTextureCoordinateGenerator || IfcTextureCoordinate::is(v); } Type::Enum IfcTextureCoordinateGenerator::type() { return Type::IfcTextureCoordinateGenerator; } Type::Enum IfcTextureCoordinateGenerator::Class() { return Type::IfcTextureCoordinateGenerator; } -IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureCoordinateGenerator)) throw; entity = e; } +IfcTextureCoordinateGenerator::IfcTextureCoordinateGenerator(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureCoordinateGenerator)) throw; entity = e; } // IfcTextureMap SHARED_PTR< IfcTemplatedEntityList > IfcTextureMap::TextureMaps() { RETURN_AS_LIST(IfcVertexBasedTextureMap,0) } bool IfcTextureMap::is(Type::Enum v) { return v == Type::IfcTextureMap || IfcTextureCoordinate::is(v); } Type::Enum IfcTextureMap::type() { return Type::IfcTextureMap; } Type::Enum IfcTextureMap::Class() { return Type::IfcTextureMap; } -IfcTextureMap::IfcTextureMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureMap)) throw; entity = e; } +IfcTextureMap::IfcTextureMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureMap)) throw; entity = e; } // IfcTextureVertex -std::vector IfcTextureVertex::Coordinates() { return *entity->getArgument(0); } +std::vector /*[2:2]*/ IfcTextureVertex::Coordinates() { return *entity->getArgument(0); } bool IfcTextureVertex::is(Type::Enum v) { return v == Type::IfcTextureVertex; } Type::Enum IfcTextureVertex::type() { return Type::IfcTextureVertex; } Type::Enum IfcTextureVertex::Class() { return Type::IfcTextureVertex; } -IfcTextureVertex::IfcTextureVertex(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureVertex)) throw; entity = e; } +IfcTextureVertex::IfcTextureVertex(IfcAbstractEntityPtr e) { if (!is(Type::IfcTextureVertex)) throw; entity = e; } // IfcThermalMaterialProperties bool IfcThermalMaterialProperties::hasSpecificHeatCapacity() { return !entity->getArgument(1)->isNull(); } IfcSpecificHeatCapacityMeasure IfcThermalMaterialProperties::SpecificHeatCapacity() { return *entity->getArgument(1); } @@ -9128,7 +9127,7 @@ IfcThermalConductivityMeasure IfcThermalMaterialProperties::ThermalConductivity( bool IfcThermalMaterialProperties::is(Type::Enum v) { return v == Type::IfcThermalMaterialProperties || IfcMaterialProperties::is(v); } Type::Enum IfcThermalMaterialProperties::type() { return Type::IfcThermalMaterialProperties; } Type::Enum IfcThermalMaterialProperties::Class() { return Type::IfcThermalMaterialProperties; } -IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcThermalMaterialProperties)) throw; entity = e; } +IfcThermalMaterialProperties::IfcThermalMaterialProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcThermalMaterialProperties)) throw; entity = e; } // IfcTimeSeries IfcLabel IfcTimeSeries::Name() { return *entity->getArgument(0); } bool IfcTimeSeries::hasDescription() { return !entity->getArgument(1)->isNull(); } @@ -9145,14 +9144,14 @@ IfcTimeSeriesReferenceRelationship::list IfcTimeSeries::DocumentedBy() { RETURN_ bool IfcTimeSeries::is(Type::Enum v) { return v == Type::IfcTimeSeries; } Type::Enum IfcTimeSeries::type() { return Type::IfcTimeSeries; } Type::Enum IfcTimeSeries::Class() { return Type::IfcTimeSeries; } -IfcTimeSeries::IfcTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeries)) throw; entity = e; } +IfcTimeSeries::IfcTimeSeries(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeries)) throw; entity = e; } // IfcTimeSeriesReferenceRelationship SHARED_PTR IfcTimeSeriesReferenceRelationship::ReferencedTimeSeries() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcTimeSeriesReferenceRelationship::TimeSeriesReferences() { RETURN_AS_LIST(IfcAbstractSelect,1) } bool IfcTimeSeriesReferenceRelationship::is(Type::Enum v) { return v == Type::IfcTimeSeriesReferenceRelationship; } Type::Enum IfcTimeSeriesReferenceRelationship::type() { return Type::IfcTimeSeriesReferenceRelationship; } Type::Enum IfcTimeSeriesReferenceRelationship::Class() { return Type::IfcTimeSeriesReferenceRelationship; } -IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesReferenceRelationship)) throw; entity = e; } +IfcTimeSeriesReferenceRelationship::IfcTimeSeriesReferenceRelationship(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesReferenceRelationship)) throw; entity = e; } // IfcTimeSeriesSchedule bool IfcTimeSeriesSchedule::hasApplicableDates() { return !entity->getArgument(5)->isNull(); } SHARED_PTR< IfcTemplatedEntityList > IfcTimeSeriesSchedule::ApplicableDates() { RETURN_AS_LIST(IfcAbstractSelect,5) } @@ -9161,29 +9160,29 @@ SHARED_PTR IfcTimeSeriesSchedule::TimeSeries() { return reinterpr bool IfcTimeSeriesSchedule::is(Type::Enum v) { return v == Type::IfcTimeSeriesSchedule || IfcControl::is(v); } Type::Enum IfcTimeSeriesSchedule::type() { return Type::IfcTimeSeriesSchedule; } Type::Enum IfcTimeSeriesSchedule::Class() { return Type::IfcTimeSeriesSchedule; } -IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesSchedule)) throw; entity = e; } +IfcTimeSeriesSchedule::IfcTimeSeriesSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesSchedule)) throw; entity = e; } // IfcTimeSeriesValue SHARED_PTR< IfcTemplatedEntityList > IfcTimeSeriesValue::ListValues() { RETURN_AS_LIST(IfcAbstractSelect,0) } bool IfcTimeSeriesValue::is(Type::Enum v) { return v == Type::IfcTimeSeriesValue; } Type::Enum IfcTimeSeriesValue::type() { return Type::IfcTimeSeriesValue; } Type::Enum IfcTimeSeriesValue::Class() { return Type::IfcTimeSeriesValue; } -IfcTimeSeriesValue::IfcTimeSeriesValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesValue)) throw; entity = e; } +IfcTimeSeriesValue::IfcTimeSeriesValue(IfcAbstractEntityPtr e) { if (!is(Type::IfcTimeSeriesValue)) throw; entity = e; } // IfcTopologicalRepresentationItem bool IfcTopologicalRepresentationItem::is(Type::Enum v) { return v == Type::IfcTopologicalRepresentationItem || IfcRepresentationItem::is(v); } Type::Enum IfcTopologicalRepresentationItem::type() { return Type::IfcTopologicalRepresentationItem; } Type::Enum IfcTopologicalRepresentationItem::Class() { return Type::IfcTopologicalRepresentationItem; } -IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcTopologicalRepresentationItem)) throw; entity = e; } +IfcTopologicalRepresentationItem::IfcTopologicalRepresentationItem(IfcAbstractEntityPtr e) { if (!is(Type::IfcTopologicalRepresentationItem)) throw; entity = e; } // IfcTopologyRepresentation bool IfcTopologyRepresentation::is(Type::Enum v) { return v == Type::IfcTopologyRepresentation || IfcShapeModel::is(v); } Type::Enum IfcTopologyRepresentation::type() { return Type::IfcTopologyRepresentation; } Type::Enum IfcTopologyRepresentation::Class() { return Type::IfcTopologyRepresentation; } -IfcTopologyRepresentation::IfcTopologyRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcTopologyRepresentation)) throw; entity = e; } +IfcTopologyRepresentation::IfcTopologyRepresentation(IfcAbstractEntityPtr e) { if (!is(Type::IfcTopologyRepresentation)) throw; entity = e; } // IfcTransformerType IfcTransformerTypeEnum::IfcTransformerTypeEnum IfcTransformerType::PredefinedType() { return IfcTransformerTypeEnum::FromString(*entity->getArgument(9)); } bool IfcTransformerType::is(Type::Enum v) { return v == Type::IfcTransformerType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcTransformerType::type() { return Type::IfcTransformerType; } Type::Enum IfcTransformerType::Class() { return Type::IfcTransformerType; } -IfcTransformerType::IfcTransformerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransformerType)) throw; entity = e; } +IfcTransformerType::IfcTransformerType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransformerType)) throw; entity = e; } // IfcTransportElement bool IfcTransportElement::hasOperationType() { return !entity->getArgument(8)->isNull(); } IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElement::OperationType() { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(8)); } @@ -9194,13 +9193,13 @@ IfcCountMeasure IfcTransportElement::CapacityByNumber() { return *entity->getArg bool IfcTransportElement::is(Type::Enum v) { return v == Type::IfcTransportElement || IfcElement::is(v); } Type::Enum IfcTransportElement::type() { return Type::IfcTransportElement; } Type::Enum IfcTransportElement::Class() { return Type::IfcTransportElement; } -IfcTransportElement::IfcTransportElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransportElement)) throw; entity = e; } +IfcTransportElement::IfcTransportElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransportElement)) throw; entity = e; } // IfcTransportElementType IfcTransportElementTypeEnum::IfcTransportElementTypeEnum IfcTransportElementType::PredefinedType() { return IfcTransportElementTypeEnum::FromString(*entity->getArgument(9)); } bool IfcTransportElementType::is(Type::Enum v) { return v == Type::IfcTransportElementType || IfcElementType::is(v); } Type::Enum IfcTransportElementType::type() { return Type::IfcTransportElementType; } Type::Enum IfcTransportElementType::Class() { return Type::IfcTransportElementType; } -IfcTransportElementType::IfcTransportElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransportElementType)) throw; entity = e; } +IfcTransportElementType::IfcTransportElementType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTransportElementType)) throw; entity = e; } // IfcTrapeziumProfileDef IfcPositiveLengthMeasure IfcTrapeziumProfileDef::BottomXDim() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcTrapeziumProfileDef::TopXDim() { return *entity->getArgument(4); } @@ -9209,7 +9208,7 @@ IfcLengthMeasure IfcTrapeziumProfileDef::TopXOffset() { return *entity->getArgum bool IfcTrapeziumProfileDef::is(Type::Enum v) { return v == Type::IfcTrapeziumProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcTrapeziumProfileDef::type() { return Type::IfcTrapeziumProfileDef; } Type::Enum IfcTrapeziumProfileDef::Class() { return Type::IfcTrapeziumProfileDef; } -IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcTrapeziumProfileDef)) throw; entity = e; } +IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcTrapeziumProfileDef)) throw; entity = e; } // IfcTrimmedCurve SHARED_PTR IfcTrimmedCurve::BasisCurve() { return reinterpret_pointer_cast(*entity->getArgument(0)); } SHARED_PTR< IfcTemplatedEntityList > IfcTrimmedCurve::Trim1() { RETURN_AS_LIST(IfcAbstractSelect,1) } @@ -9219,19 +9218,19 @@ IfcTrimmingPreference::IfcTrimmingPreference IfcTrimmedCurve::MasterRepresentati bool IfcTrimmedCurve::is(Type::Enum v) { return v == Type::IfcTrimmedCurve || IfcBoundedCurve::is(v); } Type::Enum IfcTrimmedCurve::type() { return Type::IfcTrimmedCurve; } Type::Enum IfcTrimmedCurve::Class() { return Type::IfcTrimmedCurve; } -IfcTrimmedCurve::IfcTrimmedCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcTrimmedCurve)) throw; entity = e; } +IfcTrimmedCurve::IfcTrimmedCurve(IfcAbstractEntityPtr e) { if (!is(Type::IfcTrimmedCurve)) throw; entity = e; } // IfcTubeBundleType IfcTubeBundleTypeEnum::IfcTubeBundleTypeEnum IfcTubeBundleType::PredefinedType() { return IfcTubeBundleTypeEnum::FromString(*entity->getArgument(9)); } bool IfcTubeBundleType::is(Type::Enum v) { return v == Type::IfcTubeBundleType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcTubeBundleType::type() { return Type::IfcTubeBundleType; } Type::Enum IfcTubeBundleType::Class() { return Type::IfcTubeBundleType; } -IfcTubeBundleType::IfcTubeBundleType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTubeBundleType)) throw; entity = e; } +IfcTubeBundleType::IfcTubeBundleType(IfcAbstractEntityPtr e) { if (!is(Type::IfcTubeBundleType)) throw; entity = e; } // IfcTwoDirectionRepeatFactor SHARED_PTR IfcTwoDirectionRepeatFactor::SecondRepeatFactor() { return reinterpret_pointer_cast(*entity->getArgument(1)); } bool IfcTwoDirectionRepeatFactor::is(Type::Enum v) { return v == Type::IfcTwoDirectionRepeatFactor || IfcOneDirectionRepeatFactor::is(v); } Type::Enum IfcTwoDirectionRepeatFactor::type() { return Type::IfcTwoDirectionRepeatFactor; } Type::Enum IfcTwoDirectionRepeatFactor::Class() { return Type::IfcTwoDirectionRepeatFactor; } -IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcTwoDirectionRepeatFactor)) throw; entity = e; } +IfcTwoDirectionRepeatFactor::IfcTwoDirectionRepeatFactor(IfcAbstractEntityPtr e) { if (!is(Type::IfcTwoDirectionRepeatFactor)) throw; entity = e; } // IfcTypeObject bool IfcTypeObject::hasApplicableOccurrence() { return !entity->getArgument(4)->isNull(); } IfcLabel IfcTypeObject::ApplicableOccurrence() { return *entity->getArgument(4); } @@ -9241,7 +9240,7 @@ IfcRelDefinesByType::list IfcTypeObject::ObjectTypeOf() { RETURN_INVERSE(IfcRelD bool IfcTypeObject::is(Type::Enum v) { return v == Type::IfcTypeObject || IfcObjectDefinition::is(v); } Type::Enum IfcTypeObject::type() { return Type::IfcTypeObject; } Type::Enum IfcTypeObject::Class() { return Type::IfcTypeObject; } -IfcTypeObject::IfcTypeObject(IfcAbstractEntityPtr e) { if (!is(Type::IfcTypeObject)) throw; entity = e; } +IfcTypeObject::IfcTypeObject(IfcAbstractEntityPtr e) { if (!is(Type::IfcTypeObject)) throw; entity = e; } // IfcTypeProduct bool IfcTypeProduct::hasRepresentationMaps() { return !entity->getArgument(6)->isNull(); } SHARED_PTR< IfcTemplatedEntityList > IfcTypeProduct::RepresentationMaps() { RETURN_AS_LIST(IfcRepresentationMap,6) } @@ -9250,7 +9249,7 @@ IfcLabel IfcTypeProduct::Tag() { return *entity->getArgument(7); } bool IfcTypeProduct::is(Type::Enum v) { return v == Type::IfcTypeProduct || IfcTypeObject::is(v); } Type::Enum IfcTypeProduct::type() { return Type::IfcTypeProduct; } Type::Enum IfcTypeProduct::Class() { return Type::IfcTypeProduct; } -IfcTypeProduct::IfcTypeProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcTypeProduct)) throw; entity = e; } +IfcTypeProduct::IfcTypeProduct(IfcAbstractEntityPtr e) { if (!is(Type::IfcTypeProduct)) throw; entity = e; } // IfcUShapeProfileDef IfcPositiveLengthMeasure IfcUShapeProfileDef::Depth() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcUShapeProfileDef::FlangeWidth() { return *entity->getArgument(4); } @@ -9267,96 +9266,96 @@ IfcPositiveLengthMeasure IfcUShapeProfileDef::CentreOfGravityInX() { return *ent bool IfcUShapeProfileDef::is(Type::Enum v) { return v == Type::IfcUShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcUShapeProfileDef::type() { return Type::IfcUShapeProfileDef; } Type::Enum IfcUShapeProfileDef::Class() { return Type::IfcUShapeProfileDef; } -IfcUShapeProfileDef::IfcUShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcUShapeProfileDef)) throw; entity = e; } +IfcUShapeProfileDef::IfcUShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcUShapeProfileDef)) throw; entity = e; } // IfcUnitAssignment SHARED_PTR< IfcTemplatedEntityList > IfcUnitAssignment::Units() { RETURN_AS_LIST(IfcAbstractSelect,0) } bool IfcUnitAssignment::is(Type::Enum v) { return v == Type::IfcUnitAssignment; } Type::Enum IfcUnitAssignment::type() { return Type::IfcUnitAssignment; } Type::Enum IfcUnitAssignment::Class() { return Type::IfcUnitAssignment; } -IfcUnitAssignment::IfcUnitAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcUnitAssignment)) throw; entity = e; } +IfcUnitAssignment::IfcUnitAssignment(IfcAbstractEntityPtr e) { if (!is(Type::IfcUnitAssignment)) throw; entity = e; } // IfcUnitaryEquipmentType IfcUnitaryEquipmentTypeEnum::IfcUnitaryEquipmentTypeEnum IfcUnitaryEquipmentType::PredefinedType() { return IfcUnitaryEquipmentTypeEnum::FromString(*entity->getArgument(9)); } bool IfcUnitaryEquipmentType::is(Type::Enum v) { return v == Type::IfcUnitaryEquipmentType || IfcEnergyConversionDeviceType::is(v); } Type::Enum IfcUnitaryEquipmentType::type() { return Type::IfcUnitaryEquipmentType; } Type::Enum IfcUnitaryEquipmentType::Class() { return Type::IfcUnitaryEquipmentType; } -IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcUnitaryEquipmentType)) throw; entity = e; } +IfcUnitaryEquipmentType::IfcUnitaryEquipmentType(IfcAbstractEntityPtr e) { if (!is(Type::IfcUnitaryEquipmentType)) throw; entity = e; } // IfcValveType IfcValveTypeEnum::IfcValveTypeEnum IfcValveType::PredefinedType() { return IfcValveTypeEnum::FromString(*entity->getArgument(9)); } bool IfcValveType::is(Type::Enum v) { return v == Type::IfcValveType || IfcFlowControllerType::is(v); } Type::Enum IfcValveType::type() { return Type::IfcValveType; } Type::Enum IfcValveType::Class() { return Type::IfcValveType; } -IfcValveType::IfcValveType(IfcAbstractEntityPtr e) { if (!is(Type::IfcValveType)) throw; entity = e; } +IfcValveType::IfcValveType(IfcAbstractEntityPtr e) { if (!is(Type::IfcValveType)) throw; entity = e; } // IfcVector SHARED_PTR IfcVector::Orientation() { return reinterpret_pointer_cast(*entity->getArgument(0)); } IfcLengthMeasure IfcVector::Magnitude() { return *entity->getArgument(1); } bool IfcVector::is(Type::Enum v) { return v == Type::IfcVector || IfcGeometricRepresentationItem::is(v); } Type::Enum IfcVector::type() { return Type::IfcVector; } Type::Enum IfcVector::Class() { return Type::IfcVector; } -IfcVector::IfcVector(IfcAbstractEntityPtr e) { if (!is(Type::IfcVector)) throw; entity = e; } +IfcVector::IfcVector(IfcAbstractEntityPtr e) { if (!is(Type::IfcVector)) throw; entity = e; } // IfcVertex bool IfcVertex::is(Type::Enum v) { return v == Type::IfcVertex || IfcTopologicalRepresentationItem::is(v); } Type::Enum IfcVertex::type() { return Type::IfcVertex; } Type::Enum IfcVertex::Class() { return Type::IfcVertex; } -IfcVertex::IfcVertex(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertex)) throw; entity = e; } +IfcVertex::IfcVertex(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertex)) throw; entity = e; } // IfcVertexBasedTextureMap SHARED_PTR< IfcTemplatedEntityList > IfcVertexBasedTextureMap::TextureVertices() { RETURN_AS_LIST(IfcTextureVertex,0) } SHARED_PTR< IfcTemplatedEntityList > IfcVertexBasedTextureMap::TexturePoints() { RETURN_AS_LIST(IfcCartesianPoint,1) } bool IfcVertexBasedTextureMap::is(Type::Enum v) { return v == Type::IfcVertexBasedTextureMap; } Type::Enum IfcVertexBasedTextureMap::type() { return Type::IfcVertexBasedTextureMap; } Type::Enum IfcVertexBasedTextureMap::Class() { return Type::IfcVertexBasedTextureMap; } -IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexBasedTextureMap)) throw; entity = e; } +IfcVertexBasedTextureMap::IfcVertexBasedTextureMap(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexBasedTextureMap)) throw; entity = e; } // IfcVertexLoop SHARED_PTR IfcVertexLoop::LoopVertex() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcVertexLoop::is(Type::Enum v) { return v == Type::IfcVertexLoop || IfcLoop::is(v); } Type::Enum IfcVertexLoop::type() { return Type::IfcVertexLoop; } Type::Enum IfcVertexLoop::Class() { return Type::IfcVertexLoop; } -IfcVertexLoop::IfcVertexLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexLoop)) throw; entity = e; } +IfcVertexLoop::IfcVertexLoop(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexLoop)) throw; entity = e; } // IfcVertexPoint SHARED_PTR IfcVertexPoint::VertexGeometry() { return reinterpret_pointer_cast(*entity->getArgument(0)); } bool IfcVertexPoint::is(Type::Enum v) { return v == Type::IfcVertexPoint || IfcVertex::is(v); } Type::Enum IfcVertexPoint::type() { return Type::IfcVertexPoint; } Type::Enum IfcVertexPoint::Class() { return Type::IfcVertexPoint; } -IfcVertexPoint::IfcVertexPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexPoint)) throw; entity = e; } +IfcVertexPoint::IfcVertexPoint(IfcAbstractEntityPtr e) { if (!is(Type::IfcVertexPoint)) throw; entity = e; } // IfcVibrationIsolatorType IfcVibrationIsolatorTypeEnum::IfcVibrationIsolatorTypeEnum IfcVibrationIsolatorType::PredefinedType() { return IfcVibrationIsolatorTypeEnum::FromString(*entity->getArgument(9)); } bool IfcVibrationIsolatorType::is(Type::Enum v) { return v == Type::IfcVibrationIsolatorType || IfcDiscreteAccessoryType::is(v); } Type::Enum IfcVibrationIsolatorType::type() { return Type::IfcVibrationIsolatorType; } Type::Enum IfcVibrationIsolatorType::Class() { return Type::IfcVibrationIsolatorType; } -IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcVibrationIsolatorType)) throw; entity = e; } +IfcVibrationIsolatorType::IfcVibrationIsolatorType(IfcAbstractEntityPtr e) { if (!is(Type::IfcVibrationIsolatorType)) throw; entity = e; } // IfcVirtualElement bool IfcVirtualElement::is(Type::Enum v) { return v == Type::IfcVirtualElement || IfcElement::is(v); } Type::Enum IfcVirtualElement::type() { return Type::IfcVirtualElement; } Type::Enum IfcVirtualElement::Class() { return Type::IfcVirtualElement; } -IfcVirtualElement::IfcVirtualElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcVirtualElement)) throw; entity = e; } +IfcVirtualElement::IfcVirtualElement(IfcAbstractEntityPtr e) { if (!is(Type::IfcVirtualElement)) throw; entity = e; } // IfcVirtualGridIntersection SHARED_PTR< IfcTemplatedEntityList > IfcVirtualGridIntersection::IntersectingAxes() { RETURN_AS_LIST(IfcGridAxis,0) } -std::vector IfcVirtualGridIntersection::OffsetDistances() { return *entity->getArgument(1); } +std::vector /*[2:3]*/ IfcVirtualGridIntersection::OffsetDistances() { return *entity->getArgument(1); } bool IfcVirtualGridIntersection::is(Type::Enum v) { return v == Type::IfcVirtualGridIntersection; } Type::Enum IfcVirtualGridIntersection::type() { return Type::IfcVirtualGridIntersection; } Type::Enum IfcVirtualGridIntersection::Class() { return Type::IfcVirtualGridIntersection; } -IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcAbstractEntityPtr e) { if (!is(Type::IfcVirtualGridIntersection)) throw; entity = e; } +IfcVirtualGridIntersection::IfcVirtualGridIntersection(IfcAbstractEntityPtr e) { if (!is(Type::IfcVirtualGridIntersection)) throw; entity = e; } // IfcWall bool IfcWall::is(Type::Enum v) { return v == Type::IfcWall || IfcBuildingElement::is(v); } Type::Enum IfcWall::type() { return Type::IfcWall; } Type::Enum IfcWall::Class() { return Type::IfcWall; } -IfcWall::IfcWall(IfcAbstractEntityPtr e) { if (!is(Type::IfcWall)) throw; entity = e; } +IfcWall::IfcWall(IfcAbstractEntityPtr e) { if (!is(Type::IfcWall)) throw; entity = e; } // IfcWallStandardCase bool IfcWallStandardCase::is(Type::Enum v) { return v == Type::IfcWallStandardCase || IfcWall::is(v); } Type::Enum IfcWallStandardCase::type() { return Type::IfcWallStandardCase; } Type::Enum IfcWallStandardCase::Class() { return Type::IfcWallStandardCase; } -IfcWallStandardCase::IfcWallStandardCase(IfcAbstractEntityPtr e) { if (!is(Type::IfcWallStandardCase)) throw; entity = e; } +IfcWallStandardCase::IfcWallStandardCase(IfcAbstractEntityPtr e) { if (!is(Type::IfcWallStandardCase)) throw; entity = e; } // IfcWallType IfcWallTypeEnum::IfcWallTypeEnum IfcWallType::PredefinedType() { return IfcWallTypeEnum::FromString(*entity->getArgument(9)); } bool IfcWallType::is(Type::Enum v) { return v == Type::IfcWallType || IfcBuildingElementType::is(v); } Type::Enum IfcWallType::type() { return Type::IfcWallType; } Type::Enum IfcWallType::Class() { return Type::IfcWallType; } -IfcWallType::IfcWallType(IfcAbstractEntityPtr e) { if (!is(Type::IfcWallType)) throw; entity = e; } +IfcWallType::IfcWallType(IfcAbstractEntityPtr e) { if (!is(Type::IfcWallType)) throw; entity = e; } // IfcWasteTerminalType IfcWasteTerminalTypeEnum::IfcWasteTerminalTypeEnum IfcWasteTerminalType::PredefinedType() { return IfcWasteTerminalTypeEnum::FromString(*entity->getArgument(9)); } bool IfcWasteTerminalType::is(Type::Enum v) { return v == Type::IfcWasteTerminalType || IfcFlowTerminalType::is(v); } Type::Enum IfcWasteTerminalType::type() { return Type::IfcWasteTerminalType; } Type::Enum IfcWasteTerminalType::Class() { return Type::IfcWasteTerminalType; } -IfcWasteTerminalType::IfcWasteTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcWasteTerminalType)) throw; entity = e; } +IfcWasteTerminalType::IfcWasteTerminalType(IfcAbstractEntityPtr e) { if (!is(Type::IfcWasteTerminalType)) throw; entity = e; } // IfcWaterProperties bool IfcWaterProperties::hasIsPotable() { return !entity->getArgument(1)->isNull(); } bool IfcWaterProperties::IsPotable() { return *entity->getArgument(1); } @@ -9375,7 +9374,7 @@ IfcNormalisedRatioMeasure IfcWaterProperties::DissolvedSolidsContent() { return bool IfcWaterProperties::is(Type::Enum v) { return v == Type::IfcWaterProperties || IfcMaterialProperties::is(v); } Type::Enum IfcWaterProperties::type() { return Type::IfcWaterProperties; } Type::Enum IfcWaterProperties::Class() { return Type::IfcWaterProperties; } -IfcWaterProperties::IfcWaterProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWaterProperties)) throw; entity = e; } +IfcWaterProperties::IfcWaterProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWaterProperties)) throw; entity = e; } // IfcWindow bool IfcWindow::hasOverallHeight() { return !entity->getArgument(8)->isNull(); } IfcPositiveLengthMeasure IfcWindow::OverallHeight() { return *entity->getArgument(8); } @@ -9384,7 +9383,7 @@ IfcPositiveLengthMeasure IfcWindow::OverallWidth() { return *entity->getArgument bool IfcWindow::is(Type::Enum v) { return v == Type::IfcWindow || IfcBuildingElement::is(v); } Type::Enum IfcWindow::type() { return Type::IfcWindow; } Type::Enum IfcWindow::Class() { return Type::IfcWindow; } -IfcWindow::IfcWindow(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindow)) throw; entity = e; } +IfcWindow::IfcWindow(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindow)) throw; entity = e; } // IfcWindowLiningProperties bool IfcWindowLiningProperties::hasLiningDepth() { return !entity->getArgument(4)->isNull(); } IfcPositiveLengthMeasure IfcWindowLiningProperties::LiningDepth() { return *entity->getArgument(4); } @@ -9407,7 +9406,7 @@ SHARED_PTR IfcWindowLiningProperties::ShapeAspectStyle() { retur bool IfcWindowLiningProperties::is(Type::Enum v) { return v == Type::IfcWindowLiningProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcWindowLiningProperties::type() { return Type::IfcWindowLiningProperties; } Type::Enum IfcWindowLiningProperties::Class() { return Type::IfcWindowLiningProperties; } -IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowLiningProperties)) throw; entity = e; } +IfcWindowLiningProperties::IfcWindowLiningProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowLiningProperties)) throw; entity = e; } // IfcWindowPanelProperties IfcWindowPanelOperationEnum::IfcWindowPanelOperationEnum IfcWindowPanelProperties::OperationType() { return IfcWindowPanelOperationEnum::FromString(*entity->getArgument(4)); } IfcWindowPanelPositionEnum::IfcWindowPanelPositionEnum IfcWindowPanelProperties::PanelPosition() { return IfcWindowPanelPositionEnum::FromString(*entity->getArgument(5)); } @@ -9420,7 +9419,7 @@ SHARED_PTR IfcWindowPanelProperties::ShapeAspectStyle() { return bool IfcWindowPanelProperties::is(Type::Enum v) { return v == Type::IfcWindowPanelProperties || IfcPropertySetDefinition::is(v); } Type::Enum IfcWindowPanelProperties::type() { return Type::IfcWindowPanelProperties; } Type::Enum IfcWindowPanelProperties::Class() { return Type::IfcWindowPanelProperties; } -IfcWindowPanelProperties::IfcWindowPanelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowPanelProperties)) throw; entity = e; } +IfcWindowPanelProperties::IfcWindowPanelProperties(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowPanelProperties)) throw; entity = e; } // IfcWindowStyle IfcWindowStyleConstructionEnum::IfcWindowStyleConstructionEnum IfcWindowStyle::ConstructionType() { return IfcWindowStyleConstructionEnum::FromString(*entity->getArgument(8)); } IfcWindowStyleOperationEnum::IfcWindowStyleOperationEnum IfcWindowStyle::OperationType() { return IfcWindowStyleOperationEnum::FromString(*entity->getArgument(9)); } @@ -9429,7 +9428,7 @@ bool IfcWindowStyle::Sizeable() { return *entity->getArgument(11); } bool IfcWindowStyle::is(Type::Enum v) { return v == Type::IfcWindowStyle || IfcTypeProduct::is(v); } Type::Enum IfcWindowStyle::type() { return Type::IfcWindowStyle; } Type::Enum IfcWindowStyle::Class() { return Type::IfcWindowStyle; } -IfcWindowStyle::IfcWindowStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowStyle)) throw; entity = e; } +IfcWindowStyle::IfcWindowStyle(IfcAbstractEntityPtr e) { if (!is(Type::IfcWindowStyle)) throw; entity = e; } // IfcWorkControl IfcIdentifier IfcWorkControl::Identifier() { return *entity->getArgument(5); } IfcDateTimeSelect IfcWorkControl::CreationDate() { return *entity->getArgument(6); } @@ -9451,17 +9450,17 @@ IfcLabel IfcWorkControl::UserDefinedControlType() { return *entity->getArgument( bool IfcWorkControl::is(Type::Enum v) { return v == Type::IfcWorkControl || IfcControl::is(v); } Type::Enum IfcWorkControl::type() { return Type::IfcWorkControl; } Type::Enum IfcWorkControl::Class() { return Type::IfcWorkControl; } -IfcWorkControl::IfcWorkControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkControl)) throw; entity = e; } +IfcWorkControl::IfcWorkControl(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkControl)) throw; entity = e; } // IfcWorkPlan bool IfcWorkPlan::is(Type::Enum v) { return v == Type::IfcWorkPlan || IfcWorkControl::is(v); } Type::Enum IfcWorkPlan::type() { return Type::IfcWorkPlan; } Type::Enum IfcWorkPlan::Class() { return Type::IfcWorkPlan; } -IfcWorkPlan::IfcWorkPlan(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkPlan)) throw; entity = e; } +IfcWorkPlan::IfcWorkPlan(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkPlan)) throw; entity = e; } // IfcWorkSchedule bool IfcWorkSchedule::is(Type::Enum v) { return v == Type::IfcWorkSchedule || IfcWorkControl::is(v); } Type::Enum IfcWorkSchedule::type() { return Type::IfcWorkSchedule; } Type::Enum IfcWorkSchedule::Class() { return Type::IfcWorkSchedule; } -IfcWorkSchedule::IfcWorkSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkSchedule)) throw; entity = e; } +IfcWorkSchedule::IfcWorkSchedule(IfcAbstractEntityPtr e) { if (!is(Type::IfcWorkSchedule)) throw; entity = e; } // IfcZShapeProfileDef IfcPositiveLengthMeasure IfcZShapeProfileDef::Depth() { return *entity->getArgument(3); } IfcPositiveLengthMeasure IfcZShapeProfileDef::FlangeWidth() { return *entity->getArgument(4); } @@ -9474,9 +9473,9 @@ IfcPositiveLengthMeasure IfcZShapeProfileDef::EdgeRadius() { return *entity->get bool IfcZShapeProfileDef::is(Type::Enum v) { return v == Type::IfcZShapeProfileDef || IfcParameterizedProfileDef::is(v); } Type::Enum IfcZShapeProfileDef::type() { return Type::IfcZShapeProfileDef; } Type::Enum IfcZShapeProfileDef::Class() { return Type::IfcZShapeProfileDef; } -IfcZShapeProfileDef::IfcZShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcZShapeProfileDef)) throw; entity = e; } +IfcZShapeProfileDef::IfcZShapeProfileDef(IfcAbstractEntityPtr e) { if (!is(Type::IfcZShapeProfileDef)) throw; entity = e; } // IfcZone bool IfcZone::is(Type::Enum v) { return v == Type::IfcZone || IfcGroup::is(v); } Type::Enum IfcZone::type() { return Type::IfcZone; } Type::Enum IfcZone::Class() { return Type::IfcZone; } -IfcZone::IfcZone(IfcAbstractEntityPtr e) { if (!is(Type::IfcZone)) throw; entity = e; } +IfcZone::IfcZone(IfcAbstractEntityPtr e) { if (!is(Type::IfcZone)) throw; entity = e; } \ No newline at end of file diff --git a/src/ifcparse/Ifc2x3.h b/src/ifcparse/Ifc2x3.h index fed67cdeb7..bfda184882 100644 --- a/src/ifcparse/Ifc2x3.h +++ b/src/ifcparse/Ifc2x3.h @@ -23,12 +23,10 @@ * but instead modify the python script that has been used to generate this. * * * ********************************************************************************/ - + #ifndef IFC2X3_H #define IFC2X3_H -#pragma once - #include #include @@ -41,7 +39,7 @@ using namespace IfcUtil; IfcEntities e = entity->getInverse(T::Class()); \ SHARED_PTR< IfcTemplatedEntityList > l ( new IfcTemplatedEntityList() ); \ for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \ - l->push(reinterpret_pointer_cast(*it));\ + l->push(reinterpret_pointer_cast(*it)); \ } \ return l; @@ -491,7 +489,7 @@ IfcMemberTypeEnum FromString(const std::string& s);} namespace IfcMotorConnectionTypeEnum {typedef enum {BELTDRIVE, COUPLING, DIRECTDRIVE, USERDEFINED, NOTDEFINED} IfcMotorConnectionTypeEnum; std::string ToString(IfcMotorConnectionTypeEnum v); IfcMotorConnectionTypeEnum FromString(const std::string& s);} -namespace IfcNullStyle {typedef enum {IFC_NULL, } IfcNullStyle; +namespace IfcNullStyle {typedef enum {IFC_NULL} IfcNullStyle; std::string ToString(IfcNullStyle v); IfcNullStyle FromString(const std::string& s);} namespace IfcObjectTypeEnum {typedef enum {PRODUCT, PROCESS, CONTROL, RESOURCE, ACTOR, GROUP, PROJECT, NOTDEFINED} IfcObjectTypeEnum; @@ -713,7 +711,6 @@ IfcWindowStyleOperationEnum FromString(const std::string& s);} namespace IfcWorkControlTypeEnum {typedef enum {ACTUAL, BASELINE, PLANNED, USERDEFINED, NOTDEFINED} IfcWorkControlTypeEnum; std::string ToString(IfcWorkControlTypeEnum v); IfcWorkControlTypeEnum FromString(const std::string& s);} - // Forward definitions class Ifc2DCompositeCurve; class IfcActionRequest; class IfcActor; class IfcActorRole; class IfcActuatorType; class IfcAddress; class IfcAirTerminalBoxType; class IfcAirTerminalType; class IfcAirToAirHeatRecoveryType; class IfcAlarmType; class IfcAngularDimension; class IfcAnnotation; class IfcAnnotationCurveOccurrence; class IfcAnnotationFillArea; class IfcAnnotationFillAreaOccurrence; class IfcAnnotationOccurrence; class IfcAnnotationSurface; class IfcAnnotationSurfaceOccurrence; class IfcAnnotationSymbolOccurrence; class IfcAnnotationTextOccurrence; class IfcApplication; class IfcAppliedValue; class IfcAppliedValueRelationship; class IfcApproval; class IfcApprovalActorRelationship; class IfcApprovalPropertyRelationship; class IfcApprovalRelationship; class IfcArbitraryClosedProfileDef; class IfcArbitraryOpenProfileDef; class IfcArbitraryProfileDefWithVoids; class IfcAsset; class IfcAsymmetricIShapeProfileDef; class IfcAxis1Placement; class IfcAxis2Placement2D; class IfcAxis2Placement3D; class IfcBSplineCurve; class IfcBeam; class IfcBeamType; class IfcBezierCurve; class IfcBlobTexture; class IfcBlock; class IfcBoilerType; class IfcBooleanClippingResult; class IfcBooleanResult; class IfcBoundaryCondition; class IfcBoundaryEdgeCondition; class IfcBoundaryFaceCondition; class IfcBoundaryNodeCondition; class IfcBoundaryNodeConditionWarping; class IfcBoundedCurve; class IfcBoundedSurface; class IfcBoundingBox; class IfcBoxedHalfSpace; class IfcBuilding; class IfcBuildingElement; class IfcBuildingElementComponent; class IfcBuildingElementPart; class IfcBuildingElementProxy; class IfcBuildingElementProxyType; class IfcBuildingElementType; class IfcBuildingStorey; class IfcCShapeProfileDef; class IfcCableCarrierFittingType; class IfcCableCarrierSegmentType; class IfcCableSegmentType; class IfcCalendarDate; class IfcCartesianPoint; class IfcCartesianTransformationOperator; class IfcCartesianTransformationOperator2D; class IfcCartesianTransformationOperator2DnonUniform; class IfcCartesianTransformationOperator3D; class IfcCartesianTransformationOperator3DnonUniform; class IfcCenterLineProfileDef; class IfcChamferEdgeFeature; class IfcChillerType; class IfcCircle; class IfcCircleHollowProfileDef; class IfcCircleProfileDef; class IfcClassification; class IfcClassificationItem; class IfcClassificationItemRelationship; class IfcClassificationNotation; class IfcClassificationNotationFacet; class IfcClassificationReference; class IfcClosedShell; class IfcCoilType; class IfcColourRgb; class IfcColourSpecification; class IfcColumn; class IfcColumnType; class IfcComplexProperty; class IfcCompositeCurve; class IfcCompositeCurveSegment; class IfcCompositeProfileDef; class IfcCompressorType; class IfcCondenserType; class IfcCondition; class IfcConditionCriterion; class IfcConic; class IfcConnectedFaceSet; class IfcConnectionCurveGeometry; class IfcConnectionGeometry; class IfcConnectionPointEccentricity; class IfcConnectionPointGeometry; class IfcConnectionPortGeometry; class IfcConnectionSurfaceGeometry; class IfcConstraint; class IfcConstraintAggregationRelationship; class IfcConstraintClassificationRelationship; class IfcConstraintRelationship; class IfcConstructionEquipmentResource; class IfcConstructionMaterialResource; class IfcConstructionProductResource; class IfcConstructionResource; class IfcContextDependentUnit; class IfcControl; class IfcControllerType; class IfcConversionBasedUnit; class IfcCooledBeamType; class IfcCoolingTowerType; class IfcCoordinatedUniversalTimeOffset; class IfcCostItem; class IfcCostSchedule; class IfcCostValue; class IfcCovering; class IfcCoveringType; class IfcCraneRailAShapeProfileDef; class IfcCraneRailFShapeProfileDef; class IfcCrewResource; class IfcCsgPrimitive3D; class IfcCsgSolid; class IfcCurrencyRelationship; class IfcCurtainWall; class IfcCurtainWallType; class IfcCurve; class IfcCurveBoundedPlane; class IfcCurveStyle; class IfcCurveStyleFont; class IfcCurveStyleFontAndScaling; class IfcCurveStyleFontPattern; class IfcDamperType; class IfcDateAndTime; class IfcDefinedSymbol; class IfcDerivedProfileDef; class IfcDerivedUnit; class IfcDerivedUnitElement; class IfcDiameterDimension; class IfcDimensionCalloutRelationship; class IfcDimensionCurve; class IfcDimensionCurveDirectedCallout; class IfcDimensionCurveTerminator; class IfcDimensionPair; class IfcDimensionalExponents; class IfcDirection; class IfcDiscreteAccessory; class IfcDiscreteAccessoryType; class IfcDistributionChamberElement; class IfcDistributionChamberElementType; class IfcDistributionControlElement; class IfcDistributionControlElementType; class IfcDistributionElement; class IfcDistributionElementType; class IfcDistributionFlowElement; class IfcDistributionFlowElementType; class IfcDistributionPort; class IfcDocumentElectronicFormat; class IfcDocumentInformation; class IfcDocumentInformationRelationship; class IfcDocumentReference; class IfcDoor; class IfcDoorLiningProperties; class IfcDoorPanelProperties; class IfcDoorStyle; class IfcDraughtingCallout; class IfcDraughtingCalloutRelationship; class IfcDraughtingPreDefinedColour; class IfcDraughtingPreDefinedCurveFont; class IfcDraughtingPreDefinedTextFont; class IfcDuctFittingType; class IfcDuctSegmentType; class IfcDuctSilencerType; class IfcEdge; class IfcEdgeCurve; class IfcEdgeFeature; class IfcEdgeLoop; class IfcElectricApplianceType; class IfcElectricDistributionPoint; class IfcElectricFlowStorageDeviceType; class IfcElectricGeneratorType; class IfcElectricHeaterType; class IfcElectricMotorType; class IfcElectricTimeControlType; class IfcElectricalBaseProperties; class IfcElectricalCircuit; class IfcElectricalElement; class IfcElement; class IfcElementAssembly; class IfcElementComponent; class IfcElementComponentType; class IfcElementQuantity; class IfcElementType; class IfcElementarySurface; class IfcEllipse; class IfcEllipseProfileDef; class IfcEnergyConversionDevice; class IfcEnergyConversionDeviceType; class IfcEnergyProperties; class IfcEnvironmentalImpactValue; class IfcEquipmentElement; class IfcEquipmentStandard; class IfcEvaporativeCoolerType; class IfcEvaporatorType; class IfcExtendedMaterialProperties; class IfcExternalReference; class IfcExternallyDefinedHatchStyle; class IfcExternallyDefinedSurfaceStyle; class IfcExternallyDefinedSymbol; class IfcExternallyDefinedTextFont; class IfcExtrudedAreaSolid; class IfcFace; class IfcFaceBasedSurfaceModel; class IfcFaceBound; class IfcFaceOuterBound; class IfcFaceSurface; class IfcFacetedBrep; class IfcFacetedBrepWithVoids; class IfcFailureConnectionCondition; class IfcFanType; class IfcFastener; class IfcFastenerType; class IfcFeatureElement; class IfcFeatureElementAddition; class IfcFeatureElementSubtraction; class IfcFillAreaStyle; class IfcFillAreaStyleHatching; class IfcFillAreaStyleTileSymbolWithStyle; class IfcFillAreaStyleTiles; class IfcFilterType; class IfcFireSuppressionTerminalType; class IfcFlowController; class IfcFlowControllerType; class IfcFlowFitting; class IfcFlowFittingType; class IfcFlowInstrumentType; class IfcFlowMeterType; class IfcFlowMovingDevice; class IfcFlowMovingDeviceType; class IfcFlowSegment; class IfcFlowSegmentType; class IfcFlowStorageDevice; class IfcFlowStorageDeviceType; class IfcFlowTerminal; class IfcFlowTerminalType; class IfcFlowTreatmentDevice; class IfcFlowTreatmentDeviceType; class IfcFluidFlowProperties; class IfcFooting; class IfcFuelProperties; class IfcFurnishingElement; class IfcFurnishingElementType; class IfcFurnitureStandard; class IfcFurnitureType; class IfcGasTerminalType; class IfcGeneralMaterialProperties; class IfcGeneralProfileProperties; class IfcGeometricCurveSet; class IfcGeometricRepresentationContext; class IfcGeometricRepresentationItem; class IfcGeometricRepresentationSubContext; class IfcGeometricSet; class IfcGrid; class IfcGridAxis; class IfcGridPlacement; class IfcGroup; class IfcHalfSpaceSolid; class IfcHeatExchangerType; class IfcHumidifierType; class IfcHygroscopicMaterialProperties; class IfcIShapeProfileDef; class IfcImageTexture; class IfcInventory; class IfcIrregularTimeSeries; class IfcIrregularTimeSeriesValue; class IfcJunctionBoxType; class IfcLShapeProfileDef; class IfcLaborResource; class IfcLampType; class IfcLibraryInformation; class IfcLibraryReference; class IfcLightDistributionData; class IfcLightFixtureType; class IfcLightIntensityDistribution; class IfcLightSource; class IfcLightSourceAmbient; class IfcLightSourceDirectional; class IfcLightSourceGoniometric; class IfcLightSourcePositional; class IfcLightSourceSpot; class IfcLine; class IfcLinearDimension; class IfcLocalPlacement; class IfcLocalTime; class IfcLoop; class IfcManifoldSolidBrep; class IfcMappedItem; class IfcMaterial; class IfcMaterialClassificationRelationship; class IfcMaterialDefinitionRepresentation; class IfcMaterialLayer; class IfcMaterialLayerSet; class IfcMaterialLayerSetUsage; class IfcMaterialList; class IfcMaterialProperties; class IfcMeasureWithUnit; class IfcMechanicalConcreteMaterialProperties; class IfcMechanicalFastener; class IfcMechanicalFastenerType; class IfcMechanicalMaterialProperties; class IfcMechanicalSteelMaterialProperties; class IfcMember; class IfcMemberType; class IfcMetric; class IfcMonetaryUnit; class IfcMotorConnectionType; class IfcMove; class IfcNamedUnit; class IfcObject; class IfcObjectDefinition; class IfcObjectPlacement; class IfcObjective; class IfcOccupant; class IfcOffsetCurve2D; class IfcOffsetCurve3D; class IfcOneDirectionRepeatFactor; class IfcOpenShell; class IfcOpeningElement; class IfcOpticalMaterialProperties; class IfcOrderAction; class IfcOrganization; class IfcOrganizationRelationship; class IfcOrientedEdge; class IfcOutletType; class IfcOwnerHistory; class IfcParameterizedProfileDef; class IfcPath; class IfcPerformanceHistory; class IfcPermeableCoveringProperties; class IfcPermit; class IfcPerson; class IfcPersonAndOrganization; class IfcPhysicalComplexQuantity; class IfcPhysicalQuantity; class IfcPhysicalSimpleQuantity; class IfcPile; class IfcPipeFittingType; class IfcPipeSegmentType; class IfcPixelTexture; class IfcPlacement; class IfcPlanarBox; class IfcPlanarExtent; class IfcPlane; class IfcPlate; class IfcPlateType; class IfcPoint; class IfcPointOnCurve; class IfcPointOnSurface; class IfcPolyLoop; class IfcPolygonalBoundedHalfSpace; class IfcPolyline; class IfcPort; class IfcPostalAddress; class IfcPreDefinedColour; class IfcPreDefinedCurveFont; class IfcPreDefinedDimensionSymbol; class IfcPreDefinedItem; class IfcPreDefinedPointMarkerSymbol; class IfcPreDefinedSymbol; class IfcPreDefinedTerminatorSymbol; class IfcPreDefinedTextFont; class IfcPresentationLayerAssignment; class IfcPresentationLayerWithStyle; class IfcPresentationStyle; class IfcPresentationStyleAssignment; class IfcProcedure; class IfcProcess; class IfcProduct; class IfcProductDefinitionShape; class IfcProductRepresentation; class IfcProductsOfCombustionProperties; class IfcProfileDef; class IfcProfileProperties; class IfcProject; class IfcProjectOrder; class IfcProjectOrderRecord; class IfcProjectionCurve; class IfcProjectionElement; class IfcProperty; class IfcPropertyBoundedValue; class IfcPropertyConstraintRelationship; class IfcPropertyDefinition; class IfcPropertyDependencyRelationship; class IfcPropertyEnumeratedValue; class IfcPropertyEnumeration; class IfcPropertyListValue; class IfcPropertyReferenceValue; class IfcPropertySet; class IfcPropertySetDefinition; class IfcPropertySingleValue; class IfcPropertyTableValue; class IfcProtectiveDeviceType; class IfcProxy; class IfcPumpType; class IfcQuantityArea; class IfcQuantityCount; class IfcQuantityLength; class IfcQuantityTime; class IfcQuantityVolume; class IfcQuantityWeight; class IfcRadiusDimension; class IfcRailing; class IfcRailingType; class IfcRamp; class IfcRampFlight; class IfcRampFlightType; class IfcRationalBezierCurve; class IfcRectangleHollowProfileDef; class IfcRectangleProfileDef; class IfcRectangularPyramid; class IfcRectangularTrimmedSurface; class IfcReferencesValueDocument; class IfcRegularTimeSeries; class IfcReinforcementBarProperties; class IfcReinforcementDefinitionProperties; class IfcReinforcingBar; class IfcReinforcingElement; class IfcReinforcingMesh; class IfcRelAggregates; class IfcRelAssigns; class IfcRelAssignsTasks; class IfcRelAssignsToActor; class IfcRelAssignsToControl; class IfcRelAssignsToGroup; class IfcRelAssignsToProcess; class IfcRelAssignsToProduct; class IfcRelAssignsToProjectOrder; class IfcRelAssignsToResource; class IfcRelAssociates; class IfcRelAssociatesAppliedValue; class IfcRelAssociatesApproval; class IfcRelAssociatesClassification; class IfcRelAssociatesConstraint; class IfcRelAssociatesDocument; class IfcRelAssociatesLibrary; class IfcRelAssociatesMaterial; class IfcRelAssociatesProfileProperties; class IfcRelConnects; class IfcRelConnectsElements; class IfcRelConnectsPathElements; class IfcRelConnectsPortToElement; class IfcRelConnectsPorts; class IfcRelConnectsStructuralActivity; class IfcRelConnectsStructuralElement; class IfcRelConnectsStructuralMember; class IfcRelConnectsWithEccentricity; class IfcRelConnectsWithRealizingElements; class IfcRelContainedInSpatialStructure; class IfcRelCoversBldgElements; class IfcRelCoversSpaces; class IfcRelDecomposes; class IfcRelDefines; class IfcRelDefinesByProperties; class IfcRelDefinesByType; class IfcRelFillsElement; class IfcRelFlowControlElements; class IfcRelInteractionRequirements; class IfcRelNests; class IfcRelOccupiesSpaces; class IfcRelOverridesProperties; class IfcRelProjectsElement; class IfcRelReferencedInSpatialStructure; class IfcRelSchedulesCostItems; class IfcRelSequence; class IfcRelServicesBuildings; class IfcRelSpaceBoundary; class IfcRelVoidsElement; class IfcRelationship; class IfcRelaxation; class IfcRepresentation; class IfcRepresentationContext; class IfcRepresentationItem; class IfcRepresentationMap; class IfcResource; class IfcRevolvedAreaSolid; class IfcRibPlateProfileProperties; class IfcRightCircularCone; class IfcRightCircularCylinder; class IfcRoof; class IfcRoot; class IfcRoundedEdgeFeature; class IfcRoundedRectangleProfileDef; class IfcSIUnit; class IfcSanitaryTerminalType; class IfcScheduleTimeControl; class IfcSectionProperties; class IfcSectionReinforcementProperties; class IfcSectionedSpine; class IfcSensorType; class IfcServiceLife; class IfcServiceLifeFactor; class IfcShapeAspect; class IfcShapeModel; class IfcShapeRepresentation; class IfcShellBasedSurfaceModel; class IfcSimpleProperty; class IfcSite; class IfcSlab; class IfcSlabType; class IfcSlippageConnectionCondition; class IfcSolidModel; class IfcSoundProperties; class IfcSoundValue; class IfcSpace; class IfcSpaceHeaterType; class IfcSpaceProgram; class IfcSpaceThermalLoadProperties; class IfcSpaceType; class IfcSpatialStructureElement; class IfcSpatialStructureElementType; class IfcSphere; class IfcStackTerminalType; class IfcStair; class IfcStairFlight; class IfcStairFlightType; class IfcStructuralAction; class IfcStructuralActivity; class IfcStructuralAnalysisModel; class IfcStructuralConnection; class IfcStructuralConnectionCondition; class IfcStructuralCurveConnection; class IfcStructuralCurveMember; class IfcStructuralCurveMemberVarying; class IfcStructuralItem; class IfcStructuralLinearAction; class IfcStructuralLinearActionVarying; class IfcStructuralLoad; class IfcStructuralLoadGroup; class IfcStructuralLoadLinearForce; class IfcStructuralLoadPlanarForce; class IfcStructuralLoadSingleDisplacement; class IfcStructuralLoadSingleDisplacementDistortion; class IfcStructuralLoadSingleForce; class IfcStructuralLoadSingleForceWarping; class IfcStructuralLoadStatic; class IfcStructuralLoadTemperature; class IfcStructuralMember; class IfcStructuralPlanarAction; class IfcStructuralPlanarActionVarying; class IfcStructuralPointAction; class IfcStructuralPointConnection; class IfcStructuralPointReaction; class IfcStructuralProfileProperties; class IfcStructuralReaction; class IfcStructuralResultGroup; class IfcStructuralSteelProfileProperties; class IfcStructuralSurfaceConnection; class IfcStructuralSurfaceMember; class IfcStructuralSurfaceMemberVarying; class IfcStructuredDimensionCallout; class IfcStyleModel; class IfcStyledItem; class IfcStyledRepresentation; class IfcSubContractResource; class IfcSubedge; class IfcSurface; class IfcSurfaceCurveSweptAreaSolid; class IfcSurfaceOfLinearExtrusion; class IfcSurfaceOfRevolution; class IfcSurfaceStyle; class IfcSurfaceStyleLighting; class IfcSurfaceStyleRefraction; class IfcSurfaceStyleRendering; class IfcSurfaceStyleShading; class IfcSurfaceStyleWithTextures; class IfcSurfaceTexture; class IfcSweptAreaSolid; class IfcSweptDiskSolid; class IfcSweptSurface; class IfcSwitchingDeviceType; class IfcSymbolStyle; class IfcSystem; class IfcSystemFurnitureElementType; class IfcTShapeProfileDef; class IfcTable; class IfcTableRow; class IfcTankType; class IfcTask; class IfcTelecomAddress; class IfcTendon; class IfcTendonAnchor; class IfcTerminatorSymbol; class IfcTextLiteral; class IfcTextLiteralWithExtent; class IfcTextStyle; class IfcTextStyleFontModel; class IfcTextStyleForDefinedFont; class IfcTextStyleTextModel; class IfcTextStyleWithBoxCharacteristics; class IfcTextureCoordinate; class IfcTextureCoordinateGenerator; class IfcTextureMap; class IfcTextureVertex; class IfcThermalMaterialProperties; class IfcTimeSeries; class IfcTimeSeriesReferenceRelationship; class IfcTimeSeriesSchedule; class IfcTimeSeriesValue; class IfcTopologicalRepresentationItem; class IfcTopologyRepresentation; class IfcTransformerType; class IfcTransportElement; class IfcTransportElementType; class IfcTrapeziumProfileDef; class IfcTrimmedCurve; class IfcTubeBundleType; class IfcTwoDirectionRepeatFactor; class IfcTypeObject; class IfcTypeProduct; class IfcUShapeProfileDef; class IfcUnitAssignment; class IfcUnitaryEquipmentType; class IfcValveType; class IfcVector; class IfcVertex; class IfcVertexBasedTextureMap; class IfcVertexLoop; class IfcVertexPoint; class IfcVibrationIsolatorType; class IfcVirtualElement; class IfcVirtualGridIntersection; class IfcWall; class IfcWallStandardCase; class IfcWallType; class IfcWasteTerminalType; class IfcWaterProperties; class IfcWindow; class IfcWindowLiningProperties; class IfcWindowPanelProperties; class IfcWindowStyle; class IfcWorkControl; class IfcWorkPlan; class IfcWorkSchedule; class IfcZShapeProfileDef; class IfcZone; @@ -1528,8 +1525,8 @@ public: class IfcLightDistributionData : public IfcBaseClass { public: IfcPlaneAngleMeasure MainPlaneAngle(); - std::vector SecondaryPlaneAngle(); - std::vector LuminousIntensity(); + std::vector /*[1:?]*/ SecondaryPlaneAngle(); + std::vector /*[1:?]*/ LuminousIntensity(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -1877,11 +1874,11 @@ public: bool hasGivenName(); IfcLabel GivenName(); bool hasMiddleNames(); - std::vector MiddleNames(); + std::vector /*[1:?]*/ MiddleNames(); bool hasPrefixTitles(); - std::vector PrefixTitles(); + std::vector /*[1:?]*/ PrefixTitles(); bool hasSuffixTitles(); - std::vector SuffixTitles(); + std::vector /*[1:?]*/ SuffixTitles(); bool hasRoles(); SHARED_PTR< IfcTemplatedEntityList > Roles(); bool hasAddresses(); @@ -1940,7 +1937,7 @@ public: bool hasInternalLocation(); IfcLabel InternalLocation(); bool hasAddressLines(); - std::vector AddressLines(); + std::vector /*[1:?]*/ AddressLines(); bool hasPostalBox(); IfcLabel PostalBox(); bool hasTown(); @@ -2678,13 +2675,13 @@ public: class IfcTelecomAddress : public IfcAddress { public: bool hasTelephoneNumbers(); - std::vector TelephoneNumbers(); + std::vector /*[1:?]*/ TelephoneNumbers(); bool hasFacsimileNumbers(); - std::vector FacsimileNumbers(); + std::vector /*[1:?]*/ FacsimileNumbers(); bool hasPagerNumber(); IfcLabel PagerNumber(); bool hasElectronicMailAddresses(); - std::vector ElectronicMailAddresses(); + std::vector /*[1:?]*/ ElectronicMailAddresses(); bool hasWWWHomePageURL(); IfcLabel WWWHomePageURL(); bool is(Type::Enum v); @@ -2713,7 +2710,7 @@ public: class IfcTextStyleFontModel : public IfcPreDefinedTextFont { public: bool hasFontFamily(); - std::vector FontFamily(); + std::vector /*[1:?]*/ FontFamily(); bool hasFontStyle(); IfcFontStyle FontStyle(); bool hasFontVariant(); @@ -2822,7 +2819,7 @@ public: }; class IfcTextureVertex : public IfcBaseClass { public: - std::vector Coordinates(); + std::vector /*[2:2]*/ Coordinates(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -2961,7 +2958,7 @@ public: class IfcVirtualGridIntersection : public IfcBaseClass { public: SHARED_PTR< IfcTemplatedEntityList > IntersectingAxes(); - std::vector OffsetDistances(); + std::vector /*[2:3]*/ OffsetDistances(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -3808,7 +3805,7 @@ public: IfcInteger Width(); IfcInteger Height(); IfcInteger ColourComponents(); - std::vector Pixel(); + std::vector /*[1:?]*/ Pixel(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -4886,7 +4883,7 @@ public: }; class IfcCartesianPoint : public IfcPoint { public: - std::vector Coordinates(); + std::vector /*[1:3]*/ Coordinates(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -5121,7 +5118,7 @@ public: }; class IfcDirection : public IfcGeometricRepresentationItem { public: - std::vector DirectionRatios(); + std::vector /*[2:3]*/ DirectionRatios(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -5921,8 +5918,8 @@ public: }; class IfcRelConnectsPathElements : public IfcRelConnectsElements { public: - std::vector RelatingPriorities(); - std::vector RelatedPriorities(); + std::vector /*[0:?]*/ RelatingPriorities(); + std::vector /*[0:?]*/ RelatedPriorities(); IfcConnectionTypeEnum::IfcConnectionTypeEnum RelatedConnectionType(); IfcConnectionTypeEnum::IfcConnectionTypeEnum RelatingConnectionType(); bool is(Type::Enum v); @@ -6416,7 +6413,7 @@ public: }; class IfcStructuralSurfaceMemberVarying : public IfcStructuralSurfaceMember { public: - std::vector SubsequentThickness(); + std::vector /*[2:?]*/ SubsequentThickness(); SHARED_PTR VaryingThicknessLocation(); bool is(Type::Enum v); Type::Enum type(); @@ -7294,7 +7291,7 @@ public: SHARED_PTR MoveFrom(); SHARED_PTR MoveTo(); bool hasPunchList(); - std::vector PunchList(); + std::vector /*[1:?]*/ PunchList(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -8960,7 +8957,7 @@ public: }; class IfcRationalBezierCurve : public IfcBezierCurve { public: - std::vector WeightsData(); + std::vector /*[2:?]*/ WeightsData(); bool is(Type::Enum v); Type::Enum type(); static Type::Enum Class(); @@ -9281,9 +9278,7 @@ public: typedef SHARED_PTR< IfcTemplatedEntityList > list; typedef IfcTemplatedEntityList::it it; }; - IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = IfcAbstractEntityPtr()); - } -#endif \ No newline at end of file +#endif diff --git a/src/ifcparse/Ifc2x3enum.h b/src/ifcparse/Ifc2x3enum.h index 09433a8691..4e503d6668 100644 --- a/src/ifcparse/Ifc2x3enum.h +++ b/src/ifcparse/Ifc2x3enum.h @@ -23,7 +23,7 @@ * but instead modify the python script that has been used to generate this. * * * ********************************************************************************/ - + #ifndef IFC2X3ENUM_H #define IFC2X3ENUM_H @@ -31,12 +31,13 @@ namespace Ifc2x3 { namespace Type { typedef enum { - IfcSoundPowerMeasure, IfcRotationalFrequencyMeasure, IfcSpecificHeatCapacityMeasure, IfcElectricConductanceMeasure, IfcElectricChargeMeasure, IfcPositiveLengthMeasure, IfcAngularVelocityMeasure, IfcNullStyle, IfcIonConcentrationMeasure, IfcModulusOfLinearSubgradeReactionMeasure, IfcHeatFluxDensityMeasure, IfcHeatingValueMeasure, IfcForceMeasure, IfcPositiveRatioMeasure, IfcMolecularWeightMeasure, IfcLuminousFluxMeasure, IfcNormalisedRatioMeasure, IfcLabel, IfcTimeStamp, IfcNumericMeasure, IfcRotationalMassMeasure, IfcLinearForceMeasure, IfcKinematicViscosityMeasure, IfcMassDensityMeasure, IfcIntegerCountRateMeasure, IfcRadioActivityMeasure, IfcReal, IfcLinearMomentMeasure, IfcElectricCurrentMeasure, IfcThermalTransmittanceMeasure, IfcModulusOfElasticityMeasure, IfcInductanceMeasure, IfcWarpingMomentMeasure, IfcDynamicViscosityMeasure, IfcAreaMeasure, IfcLogical, IfcAmountOfSubstanceMeasure, IfcContextDependentMeasure, IfcThermalConductivityMeasure, IfcEnergyMeasure, IfcRotationalStiffnessMeasure, IfcDerivedMeasureValue, IfcPowerMeasure, IfcThermalExpansionCoefficientMeasure, IfcTorqueMeasure, IfcMassPerLengthMeasure, IfcCountMeasure, IfcCurveStyleFontSelect, IfcVolumetricFlowRateMeasure, IfcModulusOfSubgradeReactionMeasure, IfcMassFlowRateMeasure, IfcMonetaryMeasure, IfcTemperatureGradientMeasure, IfcColour, IfcVolumeMeasure, IfcSectionalAreaIntegralMeasure, IfcVaporPermeabilityMeasure, IfcLinearVelocityMeasure, IfcLengthMeasure, IfcModulusOfRotationalSubgradeReactionMeasure, IfcPlanarForceMeasure, IfcInteger, IfcSimpleValue, IfcMeasureValue, IfcPlaneAngleMeasure, IfcWarpingConstantMeasure, IfcElectricCapacitanceMeasure, IfcSoundPressureMeasure, IfcSpecularRoughness, IfcIlluminanceMeasure, IfcText, IfcTimeMeasure, IfcAccelerationMeasure, IfcLuminousIntensityMeasure, IfcPressureMeasure, IfcElectricVoltageMeasure, IfcThermodynamicTemperatureMeasure, IfcMagneticFluxMeasure, IfcSolidAngleMeasure, IfcFrequencyMeasure, IfcPHMeasure, IfcThermalAdmittanceMeasure, IfcSpecularExponent, IfcDateTimeSelect, IfcLinearStiffnessMeasure, IfcCompoundPlaneAngleMeasure, IfcCurvatureMeasure, IfcAbsorbedDoseMeasure, IfcParameterValue, IfcDescriptiveMeasure, IfcMomentOfInertiaMeasure, IfcDoseEquivalentMeasure, IfcComplexNumber, IfcRatioMeasure, IfcLuminousIntensityDistributionMeasure, IfcIsothermalMoistureCapacityMeasure, IfcElectricResistanceMeasure, IfcThermalResistanceMeasure, IfcShearModulusMeasure, IfcIdentifier, IfcBoolean, IfcSectionModulusMeasure, IfcMassMeasure, IfcMoistureDiffusivityMeasure, IfcPositivePlaneAngleMeasure, IfcMagneticFluxDensityMeasure, Ifc2DCompositeCurve, IfcActionRequest, IfcActor, IfcActorRole, IfcActuatorType, IfcAddress, IfcAirTerminalBoxType, IfcAirTerminalType, IfcAirToAirHeatRecoveryType, IfcAlarmType, IfcAngularDimension, IfcAnnotation, IfcAnnotationCurveOccurrence, IfcAnnotationFillArea, IfcAnnotationFillAreaOccurrence, IfcAnnotationOccurrence, IfcAnnotationSurface, IfcAnnotationSurfaceOccurrence, IfcAnnotationSymbolOccurrence, IfcAnnotationTextOccurrence, IfcApplication, IfcAppliedValue, IfcAppliedValueRelationship, IfcApproval, IfcApprovalActorRelationship, IfcApprovalPropertyRelationship, IfcApprovalRelationship, IfcArbitraryClosedProfileDef, IfcArbitraryOpenProfileDef, IfcArbitraryProfileDefWithVoids, IfcAsset, IfcAsymmetricIShapeProfileDef, IfcAxis1Placement, IfcAxis2Placement2D, IfcAxis2Placement3D, IfcBSplineCurve, IfcBeam, IfcBeamType, IfcBezierCurve, IfcBlobTexture, IfcBlock, IfcBoilerType, IfcBooleanClippingResult, IfcBooleanResult, IfcBoundaryCondition, IfcBoundaryEdgeCondition, IfcBoundaryFaceCondition, IfcBoundaryNodeCondition, IfcBoundaryNodeConditionWarping, IfcBoundedCurve, IfcBoundedSurface, IfcBoundingBox, IfcBoxedHalfSpace, IfcBuilding, IfcBuildingElement, IfcBuildingElementComponent, IfcBuildingElementPart, IfcBuildingElementProxy, IfcBuildingElementProxyType, IfcBuildingElementType, IfcBuildingStorey, IfcCShapeProfileDef, IfcCableCarrierFittingType, IfcCableCarrierSegmentType, IfcCableSegmentType, IfcCalendarDate, IfcCartesianPoint, IfcCartesianTransformationOperator, IfcCartesianTransformationOperator2D, IfcCartesianTransformationOperator2DnonUniform, IfcCartesianTransformationOperator3D, IfcCartesianTransformationOperator3DnonUniform, IfcCenterLineProfileDef, IfcChamferEdgeFeature, IfcChillerType, IfcCircle, IfcCircleHollowProfileDef, IfcCircleProfileDef, IfcClassification, IfcClassificationItem, IfcClassificationItemRelationship, IfcClassificationNotation, IfcClassificationNotationFacet, IfcClassificationReference, IfcClosedShell, IfcCoilType, IfcColourRgb, IfcColourSpecification, IfcColumn, IfcColumnType, IfcComplexProperty, IfcCompositeCurve, IfcCompositeCurveSegment, IfcCompositeProfileDef, IfcCompressorType, IfcCondenserType, IfcCondition, IfcConditionCriterion, IfcConic, IfcConnectedFaceSet, IfcConnectionCurveGeometry, IfcConnectionGeometry, IfcConnectionPointEccentricity, IfcConnectionPointGeometry, IfcConnectionPortGeometry, IfcConnectionSurfaceGeometry, IfcConstraint, IfcConstraintAggregationRelationship, IfcConstraintClassificationRelationship, IfcConstraintRelationship, IfcConstructionEquipmentResource, IfcConstructionMaterialResource, IfcConstructionProductResource, IfcConstructionResource, IfcContextDependentUnit, IfcControl, IfcControllerType, IfcConversionBasedUnit, IfcCooledBeamType, IfcCoolingTowerType, IfcCoordinatedUniversalTimeOffset, IfcCostItem, IfcCostSchedule, IfcCostValue, IfcCovering, IfcCoveringType, IfcCraneRailAShapeProfileDef, IfcCraneRailFShapeProfileDef, IfcCrewResource, IfcCsgPrimitive3D, IfcCsgSolid, IfcCurrencyRelationship, IfcCurtainWall, IfcCurtainWallType, IfcCurve, IfcCurveBoundedPlane, IfcCurveStyle, IfcCurveStyleFont, IfcCurveStyleFontAndScaling, IfcCurveStyleFontPattern, IfcDamperType, IfcDateAndTime, IfcDefinedSymbol, IfcDerivedProfileDef, IfcDerivedUnit, IfcDerivedUnitElement, IfcDiameterDimension, IfcDimensionCalloutRelationship, IfcDimensionCurve, IfcDimensionCurveDirectedCallout, IfcDimensionCurveTerminator, IfcDimensionPair, IfcDimensionalExponents, IfcDirection, IfcDiscreteAccessory, IfcDiscreteAccessoryType, IfcDistributionChamberElement, IfcDistributionChamberElementType, IfcDistributionControlElement, IfcDistributionControlElementType, IfcDistributionElement, IfcDistributionElementType, IfcDistributionFlowElement, IfcDistributionFlowElementType, IfcDistributionPort, IfcDocumentElectronicFormat, IfcDocumentInformation, IfcDocumentInformationRelationship, IfcDocumentReference, IfcDoor, IfcDoorLiningProperties, IfcDoorPanelProperties, IfcDoorStyle, IfcDraughtingCallout, IfcDraughtingCalloutRelationship, IfcDraughtingPreDefinedColour, IfcDraughtingPreDefinedCurveFont, IfcDraughtingPreDefinedTextFont, IfcDuctFittingType, IfcDuctSegmentType, IfcDuctSilencerType, IfcEdge, IfcEdgeCurve, IfcEdgeFeature, IfcEdgeLoop, IfcElectricApplianceType, IfcElectricDistributionPoint, IfcElectricFlowStorageDeviceType, IfcElectricGeneratorType, IfcElectricHeaterType, IfcElectricMotorType, IfcElectricTimeControlType, IfcElectricalBaseProperties, IfcElectricalCircuit, IfcElectricalElement, IfcElement, IfcElementAssembly, IfcElementComponent, IfcElementComponentType, IfcElementQuantity, IfcElementType, IfcElementarySurface, IfcEllipse, IfcEllipseProfileDef, IfcEnergyConversionDevice, IfcEnergyConversionDeviceType, IfcEnergyProperties, IfcEnvironmentalImpactValue, IfcEquipmentElement, IfcEquipmentStandard, IfcEvaporativeCoolerType, IfcEvaporatorType, IfcExtendedMaterialProperties, IfcExternalReference, IfcExternallyDefinedHatchStyle, IfcExternallyDefinedSurfaceStyle, IfcExternallyDefinedSymbol, IfcExternallyDefinedTextFont, IfcExtrudedAreaSolid, IfcFace, IfcFaceBasedSurfaceModel, IfcFaceBound, IfcFaceOuterBound, IfcFaceSurface, IfcFacetedBrep, IfcFacetedBrepWithVoids, IfcFailureConnectionCondition, IfcFanType, IfcFastener, IfcFastenerType, IfcFeatureElement, IfcFeatureElementAddition, IfcFeatureElementSubtraction, IfcFillAreaStyle, IfcFillAreaStyleHatching, IfcFillAreaStyleTileSymbolWithStyle, IfcFillAreaStyleTiles, IfcFilterType, IfcFireSuppressionTerminalType, IfcFlowController, IfcFlowControllerType, IfcFlowFitting, IfcFlowFittingType, IfcFlowInstrumentType, IfcFlowMeterType, IfcFlowMovingDevice, IfcFlowMovingDeviceType, IfcFlowSegment, IfcFlowSegmentType, IfcFlowStorageDevice, IfcFlowStorageDeviceType, IfcFlowTerminal, IfcFlowTerminalType, IfcFlowTreatmentDevice, IfcFlowTreatmentDeviceType, IfcFluidFlowProperties, IfcFooting, IfcFuelProperties, IfcFurnishingElement, IfcFurnishingElementType, IfcFurnitureStandard, IfcFurnitureType, IfcGasTerminalType, IfcGeneralMaterialProperties, IfcGeneralProfileProperties, IfcGeometricCurveSet, IfcGeometricRepresentationContext, IfcGeometricRepresentationItem, IfcGeometricRepresentationSubContext, IfcGeometricSet, IfcGrid, IfcGridAxis, IfcGridPlacement, IfcGroup, IfcHalfSpaceSolid, IfcHeatExchangerType, IfcHumidifierType, IfcHygroscopicMaterialProperties, IfcIShapeProfileDef, IfcImageTexture, IfcInventory, IfcIrregularTimeSeries, IfcIrregularTimeSeriesValue, IfcJunctionBoxType, IfcLShapeProfileDef, IfcLaborResource, IfcLampType, IfcLibraryInformation, IfcLibraryReference, IfcLightDistributionData, IfcLightFixtureType, IfcLightIntensityDistribution, IfcLightSource, IfcLightSourceAmbient, IfcLightSourceDirectional, IfcLightSourceGoniometric, IfcLightSourcePositional, IfcLightSourceSpot, IfcLine, IfcLinearDimension, IfcLocalPlacement, IfcLocalTime, IfcLoop, IfcManifoldSolidBrep, IfcMappedItem, IfcMaterial, IfcMaterialClassificationRelationship, IfcMaterialDefinitionRepresentation, IfcMaterialLayer, IfcMaterialLayerSet, IfcMaterialLayerSetUsage, IfcMaterialList, IfcMaterialProperties, IfcMeasureWithUnit, IfcMechanicalConcreteMaterialProperties, IfcMechanicalFastener, IfcMechanicalFastenerType, IfcMechanicalMaterialProperties, IfcMechanicalSteelMaterialProperties, IfcMember, IfcMemberType, IfcMetric, IfcMonetaryUnit, IfcMotorConnectionType, IfcMove, IfcNamedUnit, IfcObject, IfcObjectDefinition, IfcObjectPlacement, IfcObjective, IfcOccupant, IfcOffsetCurve2D, IfcOffsetCurve3D, IfcOneDirectionRepeatFactor, IfcOpenShell, IfcOpeningElement, IfcOpticalMaterialProperties, IfcOrderAction, IfcOrganization, IfcOrganizationRelationship, IfcOrientedEdge, IfcOutletType, IfcOwnerHistory, IfcParameterizedProfileDef, IfcPath, IfcPerformanceHistory, IfcPermeableCoveringProperties, IfcPermit, IfcPerson, IfcPersonAndOrganization, IfcPhysicalComplexQuantity, IfcPhysicalQuantity, IfcPhysicalSimpleQuantity, IfcPile, IfcPipeFittingType, IfcPipeSegmentType, IfcPixelTexture, IfcPlacement, IfcPlanarBox, IfcPlanarExtent, IfcPlane, IfcPlate, IfcPlateType, IfcPoint, IfcPointOnCurve, IfcPointOnSurface, IfcPolyLoop, IfcPolygonalBoundedHalfSpace, IfcPolyline, IfcPort, IfcPostalAddress, IfcPreDefinedColour, IfcPreDefinedCurveFont, IfcPreDefinedDimensionSymbol, IfcPreDefinedItem, IfcPreDefinedPointMarkerSymbol, IfcPreDefinedSymbol, IfcPreDefinedTerminatorSymbol, IfcPreDefinedTextFont, IfcPresentationLayerAssignment, IfcPresentationLayerWithStyle, IfcPresentationStyle, IfcPresentationStyleAssignment, IfcProcedure, IfcProcess, IfcProduct, IfcProductDefinitionShape, IfcProductRepresentation, IfcProductsOfCombustionProperties, IfcProfileDef, IfcProfileProperties, IfcProject, IfcProjectOrder, IfcProjectOrderRecord, IfcProjectionCurve, IfcProjectionElement, IfcProperty, IfcPropertyBoundedValue, IfcPropertyConstraintRelationship, IfcPropertyDefinition, IfcPropertyDependencyRelationship, IfcPropertyEnumeratedValue, IfcPropertyEnumeration, IfcPropertyListValue, IfcPropertyReferenceValue, IfcPropertySet, IfcPropertySetDefinition, IfcPropertySingleValue, IfcPropertyTableValue, IfcProtectiveDeviceType, IfcProxy, IfcPumpType, IfcQuantityArea, IfcQuantityCount, IfcQuantityLength, IfcQuantityTime, IfcQuantityVolume, IfcQuantityWeight, IfcRadiusDimension, IfcRailing, IfcRailingType, IfcRamp, IfcRampFlight, IfcRampFlightType, IfcRationalBezierCurve, IfcRectangleHollowProfileDef, IfcRectangleProfileDef, IfcRectangularPyramid, IfcRectangularTrimmedSurface, IfcReferencesValueDocument, IfcRegularTimeSeries, IfcReinforcementBarProperties, IfcReinforcementDefinitionProperties, IfcReinforcingBar, IfcReinforcingElement, IfcReinforcingMesh, IfcRelAggregates, IfcRelAssigns, IfcRelAssignsTasks, IfcRelAssignsToActor, IfcRelAssignsToControl, IfcRelAssignsToGroup, IfcRelAssignsToProcess, IfcRelAssignsToProduct, IfcRelAssignsToProjectOrder, IfcRelAssignsToResource, IfcRelAssociates, IfcRelAssociatesAppliedValue, IfcRelAssociatesApproval, IfcRelAssociatesClassification, IfcRelAssociatesConstraint, IfcRelAssociatesDocument, IfcRelAssociatesLibrary, IfcRelAssociatesMaterial, IfcRelAssociatesProfileProperties, IfcRelConnects, IfcRelConnectsElements, IfcRelConnectsPathElements, IfcRelConnectsPortToElement, IfcRelConnectsPorts, IfcRelConnectsStructuralActivity, IfcRelConnectsStructuralElement, IfcRelConnectsStructuralMember, IfcRelConnectsWithEccentricity, IfcRelConnectsWithRealizingElements, IfcRelContainedInSpatialStructure, IfcRelCoversBldgElements, IfcRelCoversSpaces, IfcRelDecomposes, IfcRelDefines, IfcRelDefinesByProperties, IfcRelDefinesByType, IfcRelFillsElement, IfcRelFlowControlElements, IfcRelInteractionRequirements, IfcRelNests, IfcRelOccupiesSpaces, IfcRelOverridesProperties, IfcRelProjectsElement, IfcRelReferencedInSpatialStructure, IfcRelSchedulesCostItems, IfcRelSequence, IfcRelServicesBuildings, IfcRelSpaceBoundary, IfcRelVoidsElement, IfcRelationship, IfcRelaxation, IfcRepresentation, IfcRepresentationContext, IfcRepresentationItem, IfcRepresentationMap, IfcResource, IfcRevolvedAreaSolid, IfcRibPlateProfileProperties, IfcRightCircularCone, IfcRightCircularCylinder, IfcRoof, IfcRoot, IfcRoundedEdgeFeature, IfcRoundedRectangleProfileDef, IfcSIUnit, IfcSanitaryTerminalType, IfcScheduleTimeControl, IfcSectionProperties, IfcSectionReinforcementProperties, IfcSectionedSpine, IfcSensorType, IfcServiceLife, IfcServiceLifeFactor, IfcShapeAspect, IfcShapeModel, IfcShapeRepresentation, IfcShellBasedSurfaceModel, IfcSimpleProperty, IfcSite, IfcSlab, IfcSlabType, IfcSlippageConnectionCondition, IfcSolidModel, IfcSoundProperties, IfcSoundValue, IfcSpace, IfcSpaceHeaterType, IfcSpaceProgram, IfcSpaceThermalLoadProperties, IfcSpaceType, IfcSpatialStructureElement, IfcSpatialStructureElementType, IfcSphere, IfcStackTerminalType, IfcStair, IfcStairFlight, IfcStairFlightType, IfcStructuralAction, IfcStructuralActivity, IfcStructuralAnalysisModel, IfcStructuralConnection, IfcStructuralConnectionCondition, IfcStructuralCurveConnection, IfcStructuralCurveMember, IfcStructuralCurveMemberVarying, IfcStructuralItem, IfcStructuralLinearAction, IfcStructuralLinearActionVarying, IfcStructuralLoad, IfcStructuralLoadGroup, IfcStructuralLoadLinearForce, IfcStructuralLoadPlanarForce, IfcStructuralLoadSingleDisplacement, IfcStructuralLoadSingleDisplacementDistortion, IfcStructuralLoadSingleForce, IfcStructuralLoadSingleForceWarping, IfcStructuralLoadStatic, IfcStructuralLoadTemperature, IfcStructuralMember, IfcStructuralPlanarAction, IfcStructuralPlanarActionVarying, IfcStructuralPointAction, IfcStructuralPointConnection, IfcStructuralPointReaction, IfcStructuralProfileProperties, IfcStructuralReaction, IfcStructuralResultGroup, IfcStructuralSteelProfileProperties, IfcStructuralSurfaceConnection, IfcStructuralSurfaceMember, IfcStructuralSurfaceMemberVarying, IfcStructuredDimensionCallout, IfcStyleModel, IfcStyledItem, IfcStyledRepresentation, IfcSubContractResource, IfcSubedge, IfcSurface, IfcSurfaceCurveSweptAreaSolid, IfcSurfaceOfLinearExtrusion, IfcSurfaceOfRevolution, IfcSurfaceStyle, IfcSurfaceStyleLighting, IfcSurfaceStyleRefraction, IfcSurfaceStyleRendering, IfcSurfaceStyleShading, IfcSurfaceStyleWithTextures, IfcSurfaceTexture, IfcSweptAreaSolid, IfcSweptDiskSolid, IfcSweptSurface, IfcSwitchingDeviceType, IfcSymbolStyle, IfcSystem, IfcSystemFurnitureElementType, IfcTShapeProfileDef, IfcTable, IfcTableRow, IfcTankType, IfcTask, IfcTelecomAddress, IfcTendon, IfcTendonAnchor, IfcTerminatorSymbol, IfcTextLiteral, IfcTextLiteralWithExtent, IfcTextStyle, IfcTextStyleFontModel, IfcTextStyleForDefinedFont, IfcTextStyleTextModel, IfcTextStyleWithBoxCharacteristics, IfcTextureCoordinate, IfcTextureCoordinateGenerator, IfcTextureMap, IfcTextureVertex, IfcThermalMaterialProperties, IfcTimeSeries, IfcTimeSeriesReferenceRelationship, IfcTimeSeriesSchedule, IfcTimeSeriesValue, IfcTopologicalRepresentationItem, IfcTopologyRepresentation, IfcTransformerType, IfcTransportElement, IfcTransportElementType, IfcTrapeziumProfileDef, IfcTrimmedCurve, IfcTubeBundleType, IfcTwoDirectionRepeatFactor, IfcTypeObject, IfcTypeProduct, IfcUShapeProfileDef, IfcUnitAssignment, IfcUnitaryEquipmentType, IfcValveType, IfcVector, IfcVertex, IfcVertexBasedTextureMap, IfcVertexLoop, IfcVertexPoint, IfcVibrationIsolatorType, IfcVirtualElement, IfcVirtualGridIntersection, IfcWall, IfcWallStandardCase, IfcWallType, IfcWasteTerminalType, IfcWaterProperties, IfcWindow, IfcWindowLiningProperties, IfcWindowPanelProperties, IfcWindowStyle, IfcWorkControl, IfcWorkPlan, IfcWorkSchedule, IfcZShapeProfileDef, IfcZone, ALL - } Enum; + IfcAbsorbedDoseMeasure, IfcAccelerationMeasure, IfcAmountOfSubstanceMeasure, IfcAngularVelocityMeasure, IfcAreaMeasure, IfcBoolean, IfcColour, IfcComplexNumber, IfcCompoundPlaneAngleMeasure, IfcContextDependentMeasure, IfcCountMeasure, IfcCurvatureMeasure, IfcDateTimeSelect, IfcDerivedMeasureValue, IfcDescriptiveMeasure, IfcDoseEquivalentMeasure, IfcDynamicViscosityMeasure, IfcElectricCapacitanceMeasure, IfcElectricChargeMeasure, IfcElectricConductanceMeasure, IfcElectricCurrentMeasure, IfcElectricResistanceMeasure, IfcElectricVoltageMeasure, IfcEnergyMeasure, IfcForceMeasure, IfcFrequencyMeasure, IfcHeatFluxDensityMeasure, IfcHeatingValueMeasure, IfcIdentifier, IfcIlluminanceMeasure, IfcInductanceMeasure, IfcInteger, IfcIntegerCountRateMeasure, IfcIonConcentrationMeasure, IfcIsothermalMoistureCapacityMeasure, IfcKinematicViscosityMeasure, IfcLabel, IfcLengthMeasure, IfcLinearForceMeasure, IfcLinearMomentMeasure, IfcLinearStiffnessMeasure, IfcLinearVelocityMeasure, IfcLogical, IfcLuminousFluxMeasure, IfcLuminousIntensityDistributionMeasure, IfcLuminousIntensityMeasure, IfcMagneticFluxDensityMeasure, IfcMagneticFluxMeasure, IfcMassDensityMeasure, IfcMassFlowRateMeasure, IfcMassMeasure, IfcMassPerLengthMeasure, IfcMeasureValue, IfcModulusOfElasticityMeasure, IfcModulusOfLinearSubgradeReactionMeasure, IfcModulusOfRotationalSubgradeReactionMeasure, IfcModulusOfSubgradeReactionMeasure, IfcMoistureDiffusivityMeasure, IfcMolecularWeightMeasure, IfcMomentOfInertiaMeasure, IfcMonetaryMeasure, IfcNormalisedRatioMeasure, IfcNullStyle, IfcNumericMeasure, IfcPHMeasure, IfcParameterValue, IfcPlanarForceMeasure, IfcPlaneAngleMeasure, IfcPositiveLengthMeasure, IfcPositivePlaneAngleMeasure, IfcPositiveRatioMeasure, IfcPowerMeasure, IfcPressureMeasure, IfcRadioActivityMeasure, IfcRatioMeasure, IfcReal, IfcRotationalFrequencyMeasure, IfcRotationalMassMeasure, IfcRotationalStiffnessMeasure, IfcSectionModulusMeasure, IfcSectionalAreaIntegralMeasure, IfcShearModulusMeasure, IfcSimpleValue, IfcSolidAngleMeasure, IfcSoundPowerMeasure, IfcSoundPressureMeasure, IfcSpecificHeatCapacityMeasure, IfcSpecularExponent, IfcSpecularRoughness, IfcTemperatureGradientMeasure, IfcText, IfcThermalAdmittanceMeasure, IfcThermalConductivityMeasure, IfcThermalExpansionCoefficientMeasure, IfcThermalResistanceMeasure, IfcThermalTransmittanceMeasure, IfcThermodynamicTemperatureMeasure, IfcTimeMeasure, IfcTimeStamp, IfcTorqueMeasure, IfcVaporPermeabilityMeasure, IfcVolumeMeasure, IfcVolumetricFlowRateMeasure, IfcWarpingConstantMeasure, IfcWarpingMomentMeasure, Ifc2DCompositeCurve, IfcActionRequest, IfcActor, IfcActorRole, IfcActuatorType, IfcAddress, IfcAirTerminalBoxType, IfcAirTerminalType, IfcAirToAirHeatRecoveryType, IfcAlarmType, IfcAngularDimension, IfcAnnotation, IfcAnnotationCurveOccurrence, IfcAnnotationFillArea, IfcAnnotationFillAreaOccurrence, IfcAnnotationOccurrence, IfcAnnotationSurface, IfcAnnotationSurfaceOccurrence, IfcAnnotationSymbolOccurrence, IfcAnnotationTextOccurrence, IfcApplication, IfcAppliedValue, IfcAppliedValueRelationship, IfcApproval, IfcApprovalActorRelationship, IfcApprovalPropertyRelationship, IfcApprovalRelationship, IfcArbitraryClosedProfileDef, IfcArbitraryOpenProfileDef, IfcArbitraryProfileDefWithVoids, IfcAsset, IfcAsymmetricIShapeProfileDef, IfcAxis1Placement, IfcAxis2Placement2D, IfcAxis2Placement3D, IfcBSplineCurve, IfcBeam, IfcBeamType, IfcBezierCurve, IfcBlobTexture, IfcBlock, IfcBoilerType, IfcBooleanClippingResult, IfcBooleanResult, IfcBoundaryCondition, IfcBoundaryEdgeCondition, IfcBoundaryFaceCondition, IfcBoundaryNodeCondition, IfcBoundaryNodeConditionWarping, IfcBoundedCurve, IfcBoundedSurface, IfcBoundingBox, IfcBoxedHalfSpace, IfcBuilding, IfcBuildingElement, IfcBuildingElementComponent, IfcBuildingElementPart, IfcBuildingElementProxy, IfcBuildingElementProxyType, IfcBuildingElementType, IfcBuildingStorey, IfcCShapeProfileDef, IfcCableCarrierFittingType, IfcCableCarrierSegmentType, IfcCableSegmentType, IfcCalendarDate, IfcCartesianPoint, IfcCartesianTransformationOperator, IfcCartesianTransformationOperator2D, IfcCartesianTransformationOperator2DnonUniform, IfcCartesianTransformationOperator3D, IfcCartesianTransformationOperator3DnonUniform, IfcCenterLineProfileDef, IfcChamferEdgeFeature, IfcChillerType, IfcCircle, IfcCircleHollowProfileDef, IfcCircleProfileDef, IfcClassification, IfcClassificationItem, IfcClassificationItemRelationship, IfcClassificationNotation, IfcClassificationNotationFacet, IfcClassificationReference, IfcClosedShell, IfcCoilType, IfcColourRgb, IfcColourSpecification, IfcColumn, IfcColumnType, IfcComplexProperty, IfcCompositeCurve, IfcCompositeCurveSegment, IfcCompositeProfileDef, IfcCompressorType, IfcCondenserType, IfcCondition, IfcConditionCriterion, IfcConic, IfcConnectedFaceSet, IfcConnectionCurveGeometry, IfcConnectionGeometry, IfcConnectionPointEccentricity, IfcConnectionPointGeometry, IfcConnectionPortGeometry, IfcConnectionSurfaceGeometry, IfcConstraint, IfcConstraintAggregationRelationship, IfcConstraintClassificationRelationship, IfcConstraintRelationship, IfcConstructionEquipmentResource, IfcConstructionMaterialResource, IfcConstructionProductResource, IfcConstructionResource, IfcContextDependentUnit, IfcControl, IfcControllerType, IfcConversionBasedUnit, IfcCooledBeamType, IfcCoolingTowerType, IfcCoordinatedUniversalTimeOffset, IfcCostItem, IfcCostSchedule, IfcCostValue, IfcCovering, IfcCoveringType, IfcCraneRailAShapeProfileDef, IfcCraneRailFShapeProfileDef, IfcCrewResource, IfcCsgPrimitive3D, IfcCsgSolid, IfcCurrencyRelationship, IfcCurtainWall, IfcCurtainWallType, IfcCurve, IfcCurveBoundedPlane, IfcCurveStyle, IfcCurveStyleFont, IfcCurveStyleFontAndScaling, IfcCurveStyleFontPattern, IfcDamperType, IfcDateAndTime, IfcDefinedSymbol, IfcDerivedProfileDef, IfcDerivedUnit, IfcDerivedUnitElement, IfcDiameterDimension, IfcDimensionCalloutRelationship, IfcDimensionCurve, IfcDimensionCurveDirectedCallout, IfcDimensionCurveTerminator, IfcDimensionPair, IfcDimensionalExponents, IfcDirection, IfcDiscreteAccessory, IfcDiscreteAccessoryType, IfcDistributionChamberElement, IfcDistributionChamberElementType, IfcDistributionControlElement, IfcDistributionControlElementType, IfcDistributionElement, IfcDistributionElementType, IfcDistributionFlowElement, IfcDistributionFlowElementType, IfcDistributionPort, IfcDocumentElectronicFormat, IfcDocumentInformation, IfcDocumentInformationRelationship, IfcDocumentReference, IfcDoor, IfcDoorLiningProperties, IfcDoorPanelProperties, IfcDoorStyle, IfcDraughtingCallout, IfcDraughtingCalloutRelationship, IfcDraughtingPreDefinedColour, IfcDraughtingPreDefinedCurveFont, IfcDraughtingPreDefinedTextFont, IfcDuctFittingType, IfcDuctSegmentType, IfcDuctSilencerType, IfcEdge, IfcEdgeCurve, IfcEdgeFeature, IfcEdgeLoop, IfcElectricApplianceType, IfcElectricDistributionPoint, IfcElectricFlowStorageDeviceType, IfcElectricGeneratorType, IfcElectricHeaterType, IfcElectricMotorType, IfcElectricTimeControlType, IfcElectricalBaseProperties, IfcElectricalCircuit, IfcElectricalElement, IfcElement, IfcElementAssembly, IfcElementComponent, IfcElementComponentType, IfcElementQuantity, IfcElementType, IfcElementarySurface, IfcEllipse, IfcEllipseProfileDef, IfcEnergyConversionDevice, IfcEnergyConversionDeviceType, IfcEnergyProperties, IfcEnvironmentalImpactValue, IfcEquipmentElement, IfcEquipmentStandard, IfcEvaporativeCoolerType, IfcEvaporatorType, IfcExtendedMaterialProperties, IfcExternalReference, IfcExternallyDefinedHatchStyle, IfcExternallyDefinedSurfaceStyle, IfcExternallyDefinedSymbol, IfcExternallyDefinedTextFont, IfcExtrudedAreaSolid, IfcFace, IfcFaceBasedSurfaceModel, IfcFaceBound, IfcFaceOuterBound, IfcFaceSurface, IfcFacetedBrep, IfcFacetedBrepWithVoids, IfcFailureConnectionCondition, IfcFanType, IfcFastener, IfcFastenerType, IfcFeatureElement, IfcFeatureElementAddition, IfcFeatureElementSubtraction, IfcFillAreaStyle, IfcFillAreaStyleHatching, IfcFillAreaStyleTileSymbolWithStyle, IfcFillAreaStyleTiles, IfcFilterType, IfcFireSuppressionTerminalType, IfcFlowController, IfcFlowControllerType, IfcFlowFitting, IfcFlowFittingType, IfcFlowInstrumentType, IfcFlowMeterType, IfcFlowMovingDevice, IfcFlowMovingDeviceType, IfcFlowSegment, IfcFlowSegmentType, IfcFlowStorageDevice, IfcFlowStorageDeviceType, IfcFlowTerminal, IfcFlowTerminalType, IfcFlowTreatmentDevice, IfcFlowTreatmentDeviceType, IfcFluidFlowProperties, IfcFooting, IfcFuelProperties, IfcFurnishingElement, IfcFurnishingElementType, IfcFurnitureStandard, IfcFurnitureType, IfcGasTerminalType, IfcGeneralMaterialProperties, IfcGeneralProfileProperties, IfcGeometricCurveSet, IfcGeometricRepresentationContext, IfcGeometricRepresentationItem, IfcGeometricRepresentationSubContext, IfcGeometricSet, IfcGrid, IfcGridAxis, IfcGridPlacement, IfcGroup, IfcHalfSpaceSolid, IfcHeatExchangerType, IfcHumidifierType, IfcHygroscopicMaterialProperties, IfcIShapeProfileDef, IfcImageTexture, IfcInventory, IfcIrregularTimeSeries, IfcIrregularTimeSeriesValue, IfcJunctionBoxType, IfcLShapeProfileDef, IfcLaborResource, IfcLampType, IfcLibraryInformation, IfcLibraryReference, IfcLightDistributionData, IfcLightFixtureType, IfcLightIntensityDistribution, IfcLightSource, IfcLightSourceAmbient, IfcLightSourceDirectional, IfcLightSourceGoniometric, IfcLightSourcePositional, IfcLightSourceSpot, IfcLine, IfcLinearDimension, IfcLocalPlacement, IfcLocalTime, IfcLoop, IfcManifoldSolidBrep, IfcMappedItem, IfcMaterial, IfcMaterialClassificationRelationship, IfcMaterialDefinitionRepresentation, IfcMaterialLayer, IfcMaterialLayerSet, IfcMaterialLayerSetUsage, IfcMaterialList, IfcMaterialProperties, IfcMeasureWithUnit, IfcMechanicalConcreteMaterialProperties, IfcMechanicalFastener, IfcMechanicalFastenerType, IfcMechanicalMaterialProperties, IfcMechanicalSteelMaterialProperties, IfcMember, IfcMemberType, IfcMetric, IfcMonetaryUnit, IfcMotorConnectionType, IfcMove, IfcNamedUnit, IfcObject, IfcObjectDefinition, IfcObjectPlacement, IfcObjective, IfcOccupant, IfcOffsetCurve2D, IfcOffsetCurve3D, IfcOneDirectionRepeatFactor, IfcOpenShell, IfcOpeningElement, IfcOpticalMaterialProperties, IfcOrderAction, IfcOrganization, IfcOrganizationRelationship, IfcOrientedEdge, IfcOutletType, IfcOwnerHistory, IfcParameterizedProfileDef, IfcPath, IfcPerformanceHistory, IfcPermeableCoveringProperties, IfcPermit, IfcPerson, IfcPersonAndOrganization, IfcPhysicalComplexQuantity, IfcPhysicalQuantity, IfcPhysicalSimpleQuantity, IfcPile, IfcPipeFittingType, IfcPipeSegmentType, IfcPixelTexture, IfcPlacement, IfcPlanarBox, IfcPlanarExtent, IfcPlane, IfcPlate, IfcPlateType, IfcPoint, IfcPointOnCurve, IfcPointOnSurface, IfcPolyLoop, IfcPolygonalBoundedHalfSpace, IfcPolyline, IfcPort, IfcPostalAddress, IfcPreDefinedColour, IfcPreDefinedCurveFont, IfcPreDefinedDimensionSymbol, IfcPreDefinedItem, IfcPreDefinedPointMarkerSymbol, IfcPreDefinedSymbol, IfcPreDefinedTerminatorSymbol, IfcPreDefinedTextFont, IfcPresentationLayerAssignment, IfcPresentationLayerWithStyle, IfcPresentationStyle, IfcPresentationStyleAssignment, IfcProcedure, IfcProcess, IfcProduct, IfcProductDefinitionShape, IfcProductRepresentation, IfcProductsOfCombustionProperties, IfcProfileDef, IfcProfileProperties, IfcProject, IfcProjectOrder, IfcProjectOrderRecord, IfcProjectionCurve, IfcProjectionElement, IfcProperty, IfcPropertyBoundedValue, IfcPropertyConstraintRelationship, IfcPropertyDefinition, IfcPropertyDependencyRelationship, IfcPropertyEnumeratedValue, IfcPropertyEnumeration, IfcPropertyListValue, IfcPropertyReferenceValue, IfcPropertySet, IfcPropertySetDefinition, IfcPropertySingleValue, IfcPropertyTableValue, IfcProtectiveDeviceType, IfcProxy, IfcPumpType, IfcQuantityArea, IfcQuantityCount, IfcQuantityLength, IfcQuantityTime, IfcQuantityVolume, IfcQuantityWeight, IfcRadiusDimension, IfcRailing, IfcRailingType, IfcRamp, IfcRampFlight, IfcRampFlightType, IfcRationalBezierCurve, IfcRectangleHollowProfileDef, IfcRectangleProfileDef, IfcRectangularPyramid, IfcRectangularTrimmedSurface, IfcReferencesValueDocument, IfcRegularTimeSeries, IfcReinforcementBarProperties, IfcReinforcementDefinitionProperties, IfcReinforcingBar, IfcReinforcingElement, IfcReinforcingMesh, IfcRelAggregates, IfcRelAssigns, IfcRelAssignsTasks, IfcRelAssignsToActor, IfcRelAssignsToControl, IfcRelAssignsToGroup, IfcRelAssignsToProcess, IfcRelAssignsToProduct, IfcRelAssignsToProjectOrder, IfcRelAssignsToResource, IfcRelAssociates, IfcRelAssociatesAppliedValue, IfcRelAssociatesApproval, IfcRelAssociatesClassification, IfcRelAssociatesConstraint, IfcRelAssociatesDocument, IfcRelAssociatesLibrary, IfcRelAssociatesMaterial, IfcRelAssociatesProfileProperties, IfcRelConnects, IfcRelConnectsElements, IfcRelConnectsPathElements, IfcRelConnectsPortToElement, IfcRelConnectsPorts, IfcRelConnectsStructuralActivity, IfcRelConnectsStructuralElement, IfcRelConnectsStructuralMember, IfcRelConnectsWithEccentricity, IfcRelConnectsWithRealizingElements, IfcRelContainedInSpatialStructure, IfcRelCoversBldgElements, IfcRelCoversSpaces, IfcRelDecomposes, IfcRelDefines, IfcRelDefinesByProperties, IfcRelDefinesByType, IfcRelFillsElement, IfcRelFlowControlElements, IfcRelInteractionRequirements, IfcRelNests, IfcRelOccupiesSpaces, IfcRelOverridesProperties, IfcRelProjectsElement, IfcRelReferencedInSpatialStructure, IfcRelSchedulesCostItems, IfcRelSequence, IfcRelServicesBuildings, IfcRelSpaceBoundary, IfcRelVoidsElement, IfcRelationship, IfcRelaxation, IfcRepresentation, IfcRepresentationContext, IfcRepresentationItem, IfcRepresentationMap, IfcResource, IfcRevolvedAreaSolid, IfcRibPlateProfileProperties, IfcRightCircularCone, IfcRightCircularCylinder, IfcRoof, IfcRoot, IfcRoundedEdgeFeature, IfcRoundedRectangleProfileDef, IfcSIUnit, IfcSanitaryTerminalType, IfcScheduleTimeControl, IfcSectionProperties, IfcSectionReinforcementProperties, IfcSectionedSpine, IfcSensorType, IfcServiceLife, IfcServiceLifeFactor, IfcShapeAspect, IfcShapeModel, IfcShapeRepresentation, IfcShellBasedSurfaceModel, IfcSimpleProperty, IfcSite, IfcSlab, IfcSlabType, IfcSlippageConnectionCondition, IfcSolidModel, IfcSoundProperties, IfcSoundValue, IfcSpace, IfcSpaceHeaterType, IfcSpaceProgram, IfcSpaceThermalLoadProperties, IfcSpaceType, IfcSpatialStructureElement, IfcSpatialStructureElementType, IfcSphere, IfcStackTerminalType, IfcStair, IfcStairFlight, IfcStairFlightType, IfcStructuralAction, IfcStructuralActivity, IfcStructuralAnalysisModel, IfcStructuralConnection, IfcStructuralConnectionCondition, IfcStructuralCurveConnection, IfcStructuralCurveMember, IfcStructuralCurveMemberVarying, IfcStructuralItem, IfcStructuralLinearAction, IfcStructuralLinearActionVarying, IfcStructuralLoad, IfcStructuralLoadGroup, IfcStructuralLoadLinearForce, IfcStructuralLoadPlanarForce, IfcStructuralLoadSingleDisplacement, IfcStructuralLoadSingleDisplacementDistortion, IfcStructuralLoadSingleForce, IfcStructuralLoadSingleForceWarping, IfcStructuralLoadStatic, IfcStructuralLoadTemperature, IfcStructuralMember, IfcStructuralPlanarAction, IfcStructuralPlanarActionVarying, IfcStructuralPointAction, IfcStructuralPointConnection, IfcStructuralPointReaction, IfcStructuralProfileProperties, IfcStructuralReaction, IfcStructuralResultGroup, IfcStructuralSteelProfileProperties, IfcStructuralSurfaceConnection, IfcStructuralSurfaceMember, IfcStructuralSurfaceMemberVarying, IfcStructuredDimensionCallout, IfcStyleModel, IfcStyledItem, IfcStyledRepresentation, IfcSubContractResource, IfcSubedge, IfcSurface, IfcSurfaceCurveSweptAreaSolid, IfcSurfaceOfLinearExtrusion, IfcSurfaceOfRevolution, IfcSurfaceStyle, IfcSurfaceStyleLighting, IfcSurfaceStyleRefraction, IfcSurfaceStyleRendering, IfcSurfaceStyleShading, IfcSurfaceStyleWithTextures, IfcSurfaceTexture, IfcSweptAreaSolid, IfcSweptDiskSolid, IfcSweptSurface, IfcSwitchingDeviceType, IfcSymbolStyle, IfcSystem, IfcSystemFurnitureElementType, IfcTShapeProfileDef, IfcTable, IfcTableRow, IfcTankType, IfcTask, IfcTelecomAddress, IfcTendon, IfcTendonAnchor, IfcTerminatorSymbol, IfcTextLiteral, IfcTextLiteralWithExtent, IfcTextStyle, IfcTextStyleFontModel, IfcTextStyleForDefinedFont, IfcTextStyleTextModel, IfcTextStyleWithBoxCharacteristics, IfcTextureCoordinate, IfcTextureCoordinateGenerator, IfcTextureMap, IfcTextureVertex, IfcThermalMaterialProperties, IfcTimeSeries, IfcTimeSeriesReferenceRelationship, IfcTimeSeriesSchedule, IfcTimeSeriesValue, IfcTopologicalRepresentationItem, IfcTopologyRepresentation, IfcTransformerType, IfcTransportElement, IfcTransportElementType, IfcTrapeziumProfileDef, IfcTrimmedCurve, IfcTubeBundleType, IfcTwoDirectionRepeatFactor, IfcTypeObject, IfcTypeProduct, IfcUShapeProfileDef, IfcUnitAssignment, IfcUnitaryEquipmentType, IfcValveType, IfcVector, IfcVertex, IfcVertexBasedTextureMap, IfcVertexLoop, IfcVertexPoint, IfcVibrationIsolatorType, IfcVirtualElement, IfcVirtualGridIntersection, IfcWall, IfcWallStandardCase, IfcWallType, IfcWasteTerminalType, IfcWaterProperties, IfcWindow, IfcWindowLiningProperties, IfcWindowPanelProperties, IfcWindowStyle, IfcWorkControl, IfcWorkPlan, IfcWorkSchedule, IfcZShapeProfileDef, IfcZone, ALL + } Enum; Enum FromString(const std::string& s); std::string ToString(Enum v); } } -#endif \ No newline at end of file +#endif +