Merge branch 'master' into tridify_ifcgeom_dll

# Conflicts:
#	cmake/CMakeLists.txt

src/ifcconvert/ColladaSerializer.h

@@ -159,8 +159,8 @@ private:
 		{
         }
         ColladaMaterials materials;
-        ColladaSerializer *serializer;
         ColladaGeometries geometries;
+        ColladaSerializer *serializer;
 		std::vector<DeferredObject> deferreds;
 		virtual ~ColladaExporter() {}
 		void startDocument(const std::string& unit_name, float unit_magnitude);

src/ifcconvert/IfcConvert.cpp

@@ -40,7 +40,6 @@
 
 #include <boost/program_options.hpp>
 #include <boost/algorithm/string.hpp>
-#include <boost/optional/optional_io.hpp>
 
 #include <fstream>
 #include <sstream>
@@ -279,10 +278,10 @@ int main(int argc, char** argv) {
     const bool generate_uvs = vmap.count("generate-uvs") != 0 ;
     const bool deflection_tolerance_specified = vmap.count("deflection-tolerance") != 0 ;
 
-	boost::optional<int> bounding_width, bounding_height;
+	int bounding_width = -1, bounding_height = -1;
 	if (vmap.count("bounds") == 1) {
 		int w, h;
-		if (sscanf(bounds.c_str(), "%ux%u", &w, &h) == 2) {
+		if (sscanf(bounds.c_str(), "%ux%u", &w, &h) == 2 && w > 0 && h > 0) {
 			bounding_width = w;
 			bounding_height = h;
 		} else {
@@ -404,7 +403,7 @@ int main(int argc, char** argv) {
 		settings.set(IfcGeom::IteratorSettings::DISABLE_TRIANGULATION, true);
 		serializer = new SvgSerializer(output_temp_filename, settings);
 		if (bounding_width && bounding_height) {
-            static_cast<SvgSerializer*>(serializer)->setBoundingRectangle(*bounding_width, *bounding_height);
+            static_cast<SvgSerializer*>(serializer)->setBoundingRectangle(bounding_width, bounding_height);
 		}
 	} else {
 		Logger::Message(Logger::LOG_ERROR, "Unknown output filename extension '" + output_extension + "'");

src/ifcconvert/XmlSerializer.cpp

@@ -83,6 +83,8 @@ boost::optional<std::string> format_attribute(const Argument* argument, IfcUtil:
 				value = unit_name;
 			}
 			break; }
+        default:
+            break;
 	}
 	return value;
 }

src/ifcconvert/util.h

@@ -31,6 +31,7 @@ namespace util {
 		class item {
 		public:
 			virtual std::string str() const = 0;
+			virtual ~item() {};
 		};
 		class string_item : public item {
 			std::string s;
@@ -40,6 +41,7 @@ namespace util {
 			const std::string& value() const { return s; }
 			std::string& value() { return s; }
 			std::string str() const { return s; }
+			virtual ~string_item() {};
 		};
 		class float_item : public item {
 			double d;
@@ -49,6 +51,7 @@ namespace util {
 			const double& value() const { return d; }
 			double& value() { return d; }
 			std::string str() const { std::stringstream ss; ss << d; return ss.str(); }
+			virtual ~float_item() {};
 		};
 	private:
 		std::vector< boost::shared_ptr<item> > items;

src/ifcexpressparser/header.py

@@ -103,17 +103,17 @@ class Header(codegen.Base):
                     argument_start = argument_count - len(type.attributes)
 
                     argument_name_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return "%s"; '%(i+argument_start, attr.name) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
-                    argument_name_function_body_tail = (" return %s::getArgumentName(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
+                    argument_name_function_body_tail = (" return %s::getArgumentName(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
 
                     argument_name_function_body = argument_name_function_body_switch_stmt + argument_name_function_body_tail
 
                     argument_type_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_type(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
-                    argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
+                    argument_type_function_body_tail = (" return %s::getArgumentType(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
 
                     argument_type_function_body = argument_type_function_body_switch_stmt + argument_type_function_body_tail
                     
                     argument_entity_function_body_switch_stmt = " switch (i) {%s}"%("".join(['case %d: return %s; '%(i+argument_start, mapping.make_argument_entity(attr)) for i, attr in enumerate(type.attributes)])) if len(type.attributes) else ""
-                    argument_entity_function_body_tail = (" return %s::getArgumentEntity(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
+                    argument_entity_function_body_tail = (" return %s::getArgumentEntity(i); "%type.supertypes[0]) if len(type.supertypes) == 1 else ' (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); '
 
                     argument_entity_function_body = argument_entity_function_body_switch_stmt + argument_entity_function_body_tail
 

src/ifcexpressparser/templates.py

@@ -32,11 +32,6 @@ header = """
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/%(schema_name)senum.h"
 
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-
 #define IfcSchema %(schema_name)s
 
 namespace %(schema_name)s {
@@ -53,10 +48,6 @@ void InitStringMap();
 IfcUtil::IfcBaseClass* SchemaEntity(IfcAbstractEntity* e = 0);
 }
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 #endif
 """
 
@@ -209,7 +200,6 @@ void InitDescriptorMap() {
     IfcEntityDescriptor* current;
 %(entity_descriptors)s
     // Enumerations
-    IfcEnumerationDescriptor* current_enum;
     std::vector<std::string> values;
 %(enumeration_descriptors)s
 }
@@ -349,7 +339,7 @@ entity_descriptor_attribute_with_entity = '    current->add("%(name)s",%(optiona
 
 enumeration_descriptor = """    values.clear(); values.reserve(128);
 %(enumeration_descriptor_values)s
-    current_enum = enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
+    enumeration_descriptor_map[Type::%(type)s] = new IfcEnumerationDescriptor(Type::%(type)s, values);"""
 
 enumeration_descriptor_value = '    values.push_back("%(name)s");'
 

src/ifcgeom/IfcGeom.h

@@ -283,9 +283,9 @@ public:
 			return _get_surface_style<T>(representation_item->as<IfcSchema::IfcStyledItem>());
 		}
 		IfcSchema::IfcStyledItem::list::ptr styled_items = representation_item->StyledByItem();
-		for (IfcSchema::IfcStyledItem::list::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
+		if (styled_items->size()) {
 			// StyledByItem is a SET [0:1] OF IfcStyledItem, so we return after the first IfcStyledItem:
-			return _get_surface_style<T>(*jt);
+			return _get_surface_style<T>(*styled_items->begin());
 		}
 		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
 	}

src/ifcgeom/IfcGeomFunctions.cpp

@@ -1373,7 +1373,6 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 	const IfcSchema::IfcMaterialLayerSet* layerset = usage->ForLayerSet();
 	const bool positive = usage->DirectionSense() == IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE;
 	double offset = usage->OffsetFromReferenceLine() * getValue(GV_LENGTH_UNIT);
-	const int axis = usage->LayerSetDirection();
 
 	IfcSchema::IfcMaterialLayer::list::ptr material_layers = layerset->MaterialLayers();
 
@@ -1730,7 +1729,7 @@ bool IfcGeom::Kernel::fold_layers(const IfcSchema::IfcWall* wall, const IfcRepre
 
 			bool found_intersection = false;
 			boost::optional<gp_Pnt> point_outside_param_range;
-			double param;
+			//double param;
 				
 			const Handle_Geom_Surface& surface = *jt;
 
@@ -1741,7 +1740,7 @@ bool IfcGeom::Kernel::fold_layers(const IfcSchema::IfcWall* wall, const IfcRepre
 				intersections.Parameters(1, u, v, w);
 				if (w < axis_u1 || w > axis_u2) {
 					point_outside_param_range = p;
-					param = w;
+					//param = w;
 				} else {
 					// Found an intersection. Layer end point is covered by connecting wall
 					found_intersection = true;

src/ifcgeom/IfcGeomIterator.h

@@ -162,6 +162,11 @@ namespace IfcGeom {
 				initUnits();
 			} catch (...) {}
 
+			std::set<std::string> allowed_context_types;
+			allowed_context_types.insert("model");
+			allowed_context_types.insert("plan");
+			allowed_context_types.insert("notdefined");
+
 			std::set<std::string> context_types;
             if (!settings.get(IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES)) {
 				// Really this should only be 'Model', as per 
@@ -169,8 +174,9 @@ namespace IfcGeom {
 				// just for backwards compatibility:
 				context_types.insert("model");
 				context_types.insert("design");
-				// DDS likes to output 'model view'
+				// Some earlier (?) versions DDS-CAD output their own ContextTypes
 				context_types.insert("model view");
+				context_types.insert("detail view");
 			}
             if (settings.get(IteratorSettings::INCLUDE_CURVES)) {
 				context_types.insert("plan");
@@ -199,6 +205,10 @@ namespace IfcGeom {
 					if (context->hasContextType()) {
 						std::string context_type = context->ContextType();
 						boost::to_lower(context_type);
+
+						if (allowed_context_types.find(context_type) == allowed_context_types.end()) {
+							Logger::Message(Logger::LOG_ERROR, std::string("ContextType '") + context->ContextType() + "' not allowed:", context->entity);
+						}
 						if (context_types.find(context_type) != context_types.end()) {
 							filtered_contexts->push(context);
 						}
@@ -401,8 +411,6 @@ namespace IfcGeom {
 						}
 					}
 
-					const int repid = representation->entity->id();
-					
 					bool has_openings = false;
 					bool has_layers = false;
 
@@ -558,6 +566,8 @@ namespace IfcGeom {
 					element = kernel.create_brep_for_processed_representation(settings, representation, product, current_shape_model);
 				}
 
+				Logger::SetProduct(boost::none);
+
 				if ( !element ) {
 					_nextShape();
 					continue;

src/ifcgeom/IfcGeomSerialisation.cpp

@@ -43,6 +43,7 @@ int convert_to_ifc(const gp_Ax2& a, IfcSchema::IfcAxis2Placement3D*& ax, bool ad
 	IfcSchema::IfcCartesianPoint* p;
 	IfcSchema::IfcDirection *x, *z;
 	if (!(convert_to_ifc(a.Location(), p, advanced) && convert_to_ifc(a.Direction(), z, advanced) && convert_to_ifc(a.XDirection(), x, advanced))) {
+        ax = 0;
 		return 0;
 	}
 	ax = new IfcSchema::IfcAxis2Placement3D(p, z, x);

src/ifcgeom/IfcGeomShapes.cpp

@@ -1150,7 +1150,6 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS
 
 	if (faces.empty()) return false;
 	
-	const unsigned int num_faces = (unsigned)indices.size();
 	bool valid_shell = false;
 
 	if (faces.size() < getValue(GV_MAX_FACES_TO_SEW)) {

src/ifcgeomserver/IfcGeomServer.cpp

@@ -46,11 +46,17 @@
 
 using namespace boost;
 
+template <typename T>
+union data_field {
+    char buffer[sizeof(T)];
+    T value;
+};
+
 template <typename T>
 T sread(std::istream& s) {
-	char buf[sizeof(T)];
-	s.read(buf, sizeof(T));
-	return *((T*)buf);
+    data_field<T> data;
+    s.read(data.buffer, sizeof(T));
+    return data.value;
 }
 
 template <>

src/ifcopenshell-python/ifcopenshell/__init__.py

@@ -24,35 +24,35 @@ import sys
 import platform
 
 python_distribution = os.path.join(platform.system().lower(),
-	platform.architecture()[0],
-	'python%s.%s' % platform.python_version_tuple()[:2])
+    platform.architecture()[0],
+    'python%s.%s' % platform.python_version_tuple()[:2])
 sys.path.append(os.path.abspath(os.path.join(
-	os.path.dirname(__file__),
-	'lib', python_distribution)))
+    os.path.dirname(__file__),
+    'lib', python_distribution)))
 
 try:
-	from . import ifcopenshell_wrapper
+    from . import ifcopenshell_wrapper
 except Exception as e:
     if int(platform.python_version_tuple()[0]) == 2:
         import traceback
         traceback.print_exc()
         print('-' * 64)
-	raise ImportError("IfcOpenShell not built for '%s'" % python_distribution)
+    raise ImportError("IfcOpenShell not built for '%s'" % python_distribution)
     
 from . import guid
 from .file import file
 from .entity_instance import entity_instance
 
 def open(fn=None):
-	return file(ifcopenshell_wrapper.open(os.path.abspath(fn))) if fn else file()
+    return file(ifcopenshell_wrapper.open(os.path.abspath(fn))) if fn else file()
 
 
 def create_entity(type,*args,**kwargs):
-	e = entity_instance(ifcopenshell_wrapper.entity_instance(type))
-	attrs = list(enumerate(args)) + \
-		[(e.wrapped_data.get_argument_index(name), arg) for name, arg in kwargs.items()]
-	for idx, arg in attrs: e[idx] = arg
-	return e
+    e = entity_instance(ifcopenshell_wrapper.entity_instance(type))
+    attrs = list(enumerate(args)) + \
+        [(e.wrapped_data.get_argument_index(name), arg) for name, arg in kwargs.items()]
+    for idx, arg in attrs: e[idx] = arg
+    return e
 
 
 version = ifcopenshell_wrapper.version()

src/ifcopenshell-python/ifcopenshell/entity_instance.py

@@ -24,64 +24,64 @@ import itertools
 from . import ifcopenshell_wrapper
 
 class entity_instance(object):
-	def __init__(self, e):
-		super(entity_instance, self).__setattr__('wrapped_data', e)
-	def __getattr__(self, name):
-		INVALID, FORWARD, INVERSE = range(3)
-		attr_cat = self.wrapped_data.get_attribute_category(name)
-		if attr_cat == FORWARD:
-			return entity_instance.wrap_value(self.wrapped_data.get_argument(self.wrapped_data.get_argument_index(name)))
-		elif attr_cat == INVERSE:
-			return entity_instance.wrap_value(self.wrapped_data.get_inverse(name))
-		else: raise AttributeError("entity instance of type '%s' has no attribute '%s'"%(self.wrapped_data.is_a(), name))
-	@staticmethod
-	def walk(f, g, value):
-		if isinstance(value, (tuple, list)): return tuple(map(functools.partial(entity_instance.walk, f, g), value))
-		elif f(value): return g(value)
-		else: return value
-	@staticmethod
-	def wrap_value(v):
-		wrap = lambda e: entity_instance(e)
-		is_instance = lambda e: isinstance(e, ifcopenshell_wrapper.entity_instance)
-		return entity_instance.walk(is_instance, wrap, v)
-	@staticmethod
-	def unwrap_value(v):
-		unwrap = lambda e: e.wrapped_data
-		is_instance = lambda e: isinstance(e, entity_instance)
-		return entity_instance.walk(is_instance, unwrap, v)
-	def attribute_type(self, attr):
-		attr_idx = attr if isinstance(attr, numbers.Integral) else self.wrapped_data.get_argument_index(attr)
-		return self.wrapped_data.get_argument_type(attr_idx)
-	def attribute_name(self, attr_idx):
-		return self.wrapped_data.get_argument_name(attr_idx)
-	def __setattr__(self, key, value):
-		self[self.wrapped_data.get_argument_index(key)] = value
-	def __getitem__(self, key):
-		return entity_instance.wrap_value(self.wrapped_data.get_argument(key))
-	def __setitem__(self, idx, value):
-		if value is None:
-			self.wrapped_data.setArgumentAsNull(idx)
-		else:
-			attr_type = self.attribute_type(idx).title().replace(' ', '')
-			attr_type = attr_type.replace('Binary', 'String')
-			attr_type = attr_type.replace('Enumeration', 'String')
-			try:
-				if isinstance(value, unicode): value = value.encode("utf-8")
-			except: pass
-			getattr(self.wrapped_data, "setArgumentAs%s" % attr_type)(idx, entity_instance.unwrap_value(value))
-		return value
-	def __len__(self): return len(self.wrapped_data)
-	def __repr__(self): return repr(self.wrapped_data)
-	def is_a(self, *args): return self.wrapped_data.is_a(*args)
-	def id(self): return self.wrapped_data.id()
-	def __eq__(self, other):
-		if type(self) != type(other): return False
-		return self.wrapped_data == other.wrapped_data
-	def __hash__(self):
-		return hash((self.id(), self.wrapped_data.file_pointer()))
-	def __dir__(self):
-		return sorted(set(itertools.chain(
-			dir(type(self)),
-			self.wrapped_data.get_attribute_names(),
-			self.wrapped_data.get_inverse_attribute_names()
-		)))
+    def __init__(self, e):
+        super(entity_instance, self).__setattr__('wrapped_data', e)
+    def __getattr__(self, name):
+        INVALID, FORWARD, INVERSE = range(3)
+        attr_cat = self.wrapped_data.get_attribute_category(name)
+        if attr_cat == FORWARD:
+            return entity_instance.wrap_value(self.wrapped_data.get_argument(self.wrapped_data.get_argument_index(name)))
+        elif attr_cat == INVERSE:
+            return entity_instance.wrap_value(self.wrapped_data.get_inverse(name))
+        else: raise AttributeError("entity instance of type '%s' has no attribute '%s'"%(self.wrapped_data.is_a(), name))
+    @staticmethod
+    def walk(f, g, value):
+        if isinstance(value, (tuple, list)): return tuple(map(functools.partial(entity_instance.walk, f, g), value))
+        elif f(value): return g(value)
+        else: return value
+    @staticmethod
+    def wrap_value(v):
+        wrap = lambda e: entity_instance(e)
+        is_instance = lambda e: isinstance(e, ifcopenshell_wrapper.entity_instance)
+        return entity_instance.walk(is_instance, wrap, v)
+    @staticmethod
+    def unwrap_value(v):
+        unwrap = lambda e: e.wrapped_data
+        is_instance = lambda e: isinstance(e, entity_instance)
+        return entity_instance.walk(is_instance, unwrap, v)
+    def attribute_type(self, attr):
+        attr_idx = attr if isinstance(attr, numbers.Integral) else self.wrapped_data.get_argument_index(attr)
+        return self.wrapped_data.get_argument_type(attr_idx)
+    def attribute_name(self, attr_idx):
+        return self.wrapped_data.get_argument_name(attr_idx)
+    def __setattr__(self, key, value):
+        self[self.wrapped_data.get_argument_index(key)] = value
+    def __getitem__(self, key):
+        return entity_instance.wrap_value(self.wrapped_data.get_argument(key))
+    def __setitem__(self, idx, value):
+        if value is None:
+            self.wrapped_data.setArgumentAsNull(idx)
+        else:
+            attr_type = self.attribute_type(idx).title().replace(' ', '')
+            attr_type = attr_type.replace('Binary', 'String')
+            attr_type = attr_type.replace('Enumeration', 'String')
+            try:
+                if isinstance(value, unicode): value = value.encode("utf-8")
+            except: pass
+            getattr(self.wrapped_data, "setArgumentAs%s" % attr_type)(idx, entity_instance.unwrap_value(value))
+        return value
+    def __len__(self): return len(self.wrapped_data)
+    def __repr__(self): return repr(self.wrapped_data)
+    def is_a(self, *args): return self.wrapped_data.is_a(*args)
+    def id(self): return self.wrapped_data.id()
+    def __eq__(self, other):
+        if type(self) != type(other): return False
+        return self.wrapped_data == other.wrapped_data
+    def __hash__(self):
+        return hash((self.id(), self.wrapped_data.file_pointer()))
+    def __dir__(self):
+        return sorted(set(itertools.chain(
+            dir(type(self)),
+            self.wrapped_data.get_attribute_names(),
+            self.wrapped_data.get_inverse_attribute_names()
+        )))

src/ifcopenshell-python/ifcopenshell/file.py

@@ -24,34 +24,38 @@ from . import ifcopenshell_wrapper
 from .entity_instance import entity_instance
 
 class file(object):
-	def __init__(self, f=None):
-		self.wrapped_data = f or ifcopenshell_wrapper.file(True)
-	def create_entity(self,type,*args,**kwargs):
-		e = entity_instance(ifcopenshell_wrapper.entity_instance(type))
-		attrs = list(enumerate(args)) + \
-			[(e.wrapped_data.get_argument_index(name), arg) for name, arg in kwargs.items()]
-		for idx, arg in attrs: e[idx] = arg
-		self.wrapped_data.add(e.wrapped_data)
-		e.wrapped_data.this.disown()
-		return e
-	def __getattr__(self, attr):
-		if attr[0:6] == 'create': return functools.partial(self.create_entity,attr[6:])
-		else: return getattr(self.wrapped_data, attr)
-	def __getitem__(self, key):
-		if isinstance(key, numbers.Integral):
-			return entity_instance(self.wrapped_data.by_id(key))
-		elif isinstance(key, str):
-			return entity_instance(self.wrapped_data.by_guid(key))
-	def by_id(self, id): return self[id]
-	def by_guid(self, guid): return self[guid]
-	def add(self, inst):
-		inst.wrapped_data.this.disown()
-		return entity_instance(self.wrapped_data.add(inst.wrapped_data))
-	def by_type(self, type):
-		return [entity_instance(e) for e in self.wrapped_data.by_type(type)]
-	def traverse(self, inst):
-		return [entity_instance(e) for e in self.wrapped_data.traverse(inst.wrapped_data)]
-	def remove(self, inst):
-		return self.wrapped_data.remove(inst.wrapped_data)
-	def __iter__(self):
-		return iter(self[id] for id in self.wrapped_data.entity_names())
+    def __init__(self, f=None):
+        self.wrapped_data = f or ifcopenshell_wrapper.file(True)
+    def create_entity(self,type,*args,**kwargs):
+        e = entity_instance(ifcopenshell_wrapper.entity_instance(type))
+        attrs = list(enumerate(args)) + \
+            [(e.wrapped_data.get_argument_index(name), arg) for name, arg in kwargs.items()]
+        for idx, arg in attrs: e[idx] = arg
+        self.wrapped_data.add(e.wrapped_data)
+        e.wrapped_data.this.disown()
+        return e
+    def __getattr__(self, attr):
+        if attr[0:6] == 'create': return functools.partial(self.create_entity,attr[6:])
+        else: return getattr(self.wrapped_data, attr)
+    def __getitem__(self, key):
+        if isinstance(key, numbers.Integral):
+            return entity_instance(self.wrapped_data.by_id(key))
+        elif isinstance(key, str):
+            return entity_instance(self.wrapped_data.by_guid(key))
+    def by_id(self, id): return self[id]
+    def by_guid(self, guid): return self[guid]
+    def add(self, inst):
+        inst.wrapped_data.this.disown()
+        return entity_instance(self.wrapped_data.add(inst.wrapped_data))
+    def by_type(self, type):
+        return [entity_instance(e) for e in self.wrapped_data.by_type(type)]
+    def traverse(self, inst, max_levels=None):
+        if max_levels is None:
+            max_levels = -1
+        return [entity_instance(e) for e in self.wrapped_data.traverse(inst.wrapped_data, max_levels)]
+    def get_inverse(self, inst):
+        return [entity_instance(e) for e in self.wrapped_data.get_inverse(inst.wrapped_data)]
+    def remove(self, inst):
+        return self.wrapped_data.remove(inst.wrapped_data)
+    def __iter__(self):
+        return iter(self[id] for id in self.wrapped_data.entity_names())

src/ifcopenshell-python/ifcopenshell/geom/occ_utils.py

@@ -30,14 +30,14 @@ DEFAULT_STYLES = {
     "IfcWall"            : (.8 , .8, .8     ),
     "IfcSite"            : (.75, .8, .65    ),
     "IfcSlab"            : (.4 , .4, .4     ),
-	"IfcWallStandardCase": (.9 , .9, .9     ),
-	"IfcWall"            : (.9 , .9, .9     ),
-	"IfcWindow"          : (.75, .8, .75, .3),
-	"IfcDoor"            : (.55, .3, .15    ),
-	"IfcBeam"            : (.75, .7, .7     ),
-	"IfcRailing"         : (.65, .6, .6     ),
-	"IfcMember"          : (.65, .6, .6     ),
-	"IfcPlate"           : (.8 , .8, .8     )
+    "IfcWallStandardCase": (.9 , .9, .9     ),
+    "IfcWall"            : (.9 , .9, .9     ),
+    "IfcWindow"          : (.75, .8, .75, .3),
+    "IfcDoor"            : (.55, .3, .15    ),
+    "IfcBeam"            : (.75, .7, .7     ),
+    "IfcRailing"         : (.65, .6, .6     ),
+    "IfcMember"          : (.65, .6, .6     ),
+    "IfcPlate"           : (.8 , .8, .8     )
 }
 
 def initialize_display():

src/ifcparse/Ifc4.h

@@ -40,11 +40,6 @@
 #include "../ifcparse/IfcException.h"
 #include "../ifcparse/Ifc4enum.h"
 
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-
 #define IfcSchema Ifc4
 
 namespace Ifc4 {
@@ -8214,9 +8209,9 @@ public:
     std::string Description() const;
     void setDescription(std::string v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRoleEnum; case 1: return Type::IfcLabel; case 2: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Role"; case 1: return "UserDefinedRole"; case 2: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRoleEnum; case 1: return Type::IfcLabel; case 2: return Type::IfcText; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Role"; case 1: return "UserDefinedRole"; case 2: return "Description"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     bool is(Type::Enum v) const;
@@ -8252,9 +8247,9 @@ public:
     std::string UserDefinedPurpose() const;
     void setUserDefinedPurpose(std::string v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAddressTypeEnum; case 1: return Type::IfcText; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Purpose"; case 1: return "Description"; case 2: return "UserDefinedPurpose"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAddressTypeEnum; case 1: return Type::IfcText; case 2: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Purpose"; case 1: return "Description"; case 2: return "UserDefinedPurpose"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcPerson >::ptr OfPerson() const; // INVERSE IfcPerson::Addresses
     IfcTemplatedEntityList< IfcOrganization >::ptr OfOrganization() const; // INVERSE IfcOrganization::Addresses
@@ -8283,9 +8278,9 @@ public:
     std::string ApplicationIdentifier() const;
     void setApplicationIdentifier(std::string v);
     virtual unsigned int getArgumentCount() const { return 4; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrganization; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApplicationDeveloper"; case 1: return "Version"; case 2: return "ApplicationFullName"; case 3: return "ApplicationIdentifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcOrganization; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcIdentifier; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ApplicationDeveloper"; case 1: return "Version"; case 2: return "ApplicationFullName"; case 3: return "ApplicationIdentifier"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -8365,9 +8360,9 @@ public:
     IfcTemplatedEntityList< IfcAppliedValue >::ptr Components() const;
     void setComponents(IfcTemplatedEntityList< IfcAppliedValue >::ptr v);
     virtual unsigned int getArgumentCount() const { return 10; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDate; case 5: return Type::IfcDate; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::IfcArithmeticOperatorEnum; case 9: return Type::IfcAppliedValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AppliedValue"; case 3: return "UnitBasis"; case 4: return "ApplicableDate"; case 5: return "FixedUntilDate"; case 6: return "Category"; case 7: return "Condition"; case 8: return "ArithmeticOperator"; case 9: return "Components"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_STRING; case 8: return IfcUtil::Argument_ENUMERATION; case 9: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcAppliedValueSelect; case 3: return Type::IfcMeasureWithUnit; case 4: return Type::IfcDate; case 5: return Type::IfcDate; case 6: return Type::IfcLabel; case 7: return Type::IfcLabel; case 8: return Type::IfcArithmeticOperatorEnum; case 9: return Type::IfcAppliedValue; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AppliedValue"; case 3: return "UnitBasis"; case 4: return "ApplicableDate"; case 5: return "FixedUntilDate"; case 6: return "Category"; case 7: return "Condition"; case 8: return "ArithmeticOperator"; case 9: return "Components"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     bool is(Type::Enum v) const;
@@ -8436,9 +8431,9 @@ public:
     IfcActorSelect* GivingApproval() const;
     void setGivingApproval(IfcActorSelect* v);
     virtual unsigned int getArgumentCount() const { return 9; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDateTime; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcText; case 7: return Type::IfcActorSelect; case 8: return Type::IfcActorSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "TimeOfApproval"; case 4: return "Status"; case 5: return "Level"; case 6: return "Qualifier"; case 7: return "RequestingApproval"; case 8: return "GivingApproval"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_STRING; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; case 8: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcDateTime; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcText; case 7: return Type::IfcActorSelect; case 8: return Type::IfcActorSelect; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "TimeOfApproval"; case 4: return "Status"; case 5: return "Level"; case 6: return "Qualifier"; case 7: return "RequestingApproval"; case 8: return "GivingApproval"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     IfcTemplatedEntityList< IfcRelAssociatesApproval >::ptr ApprovedObjects() const; // INVERSE IfcRelAssociatesApproval::RelatingApproval
@@ -8475,9 +8470,9 @@ public:
     std::string Name() const;
     void setName(std::string v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -8678,9 +8673,9 @@ public:
 class IFC_PARSE_API IfcConnectionGeometry : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -8834,9 +8829,9 @@ public:
     std::string UserDefinedGrade() const;
     void setUserDefinedGrade(std::string v);
     virtual unsigned int getArgumentCount() const { return 7; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraintEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcActorSelect; case 5: return Type::IfcDateTime; case 6: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "ConstraintGrade"; case 3: return "ConstraintSource"; case 4: return "CreatingActor"; case 5: return "CreationTime"; case 6: return "UserDefinedGrade"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; case 5: return IfcUtil::Argument_STRING; case 6: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcConstraintEnum; case 3: return Type::IfcLabel; case 4: return Type::IfcActorSelect; case 5: return Type::IfcDateTime; case 6: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "ConstraintGrade"; case 3: return "ConstraintSource"; case 4: return "CreatingActor"; case 5: return "CreationTime"; case 6: return "UserDefinedGrade"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     IfcTemplatedEntityList< IfcResourceConstraintRelationship >::ptr PropertiesForConstraint() const; // INVERSE IfcResourceConstraintRelationship::RelatingConstraint
@@ -8902,9 +8897,9 @@ public:
     IfcCoordinateReferenceSystem* TargetCRS() const;
     void setTargetCRS(IfcCoordinateReferenceSystem* v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCoordinateReferenceSystemSelect; case 1: return Type::IfcCoordinateReferenceSystem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SourceCRS"; case 1: return "TargetCRS"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCoordinateReferenceSystemSelect; case 1: return Type::IfcCoordinateReferenceSystem; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "SourceCRS"; case 1: return "TargetCRS"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -8964,9 +8959,9 @@ public:
     std::string VerticalDatum() const;
     void setVerticalDatum(std::string v);
     virtual unsigned int getArgumentCount() const { return 4; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcIdentifier; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "GeodeticDatum"; case 3: return "VerticalDatum"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcIdentifier; case 3: return Type::IfcIdentifier; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "GeodeticDatum"; case 3: return "VerticalDatum"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcCoordinateOperation >::ptr HasCoordinateOperation() const; // INVERSE IfcCoordinateOperation::SourceCRS
     bool is(Type::Enum v) const;
@@ -9052,9 +9047,9 @@ public:
     std::string UserDefinedType() const;
     void setUserDefinedType(std::string v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDerivedUnitElement; case 1: return Type::IfcDerivedUnitEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Elements"; case 1: return "UnitType"; case 2: return "UserDefinedType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDerivedUnitElement; case 1: return Type::IfcDerivedUnitEnum; case 2: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Elements"; case 1: return "UnitType"; case 2: return "UserDefinedType"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9081,9 +9076,9 @@ public:
     int Exponent() const;
     void setExponent(int v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNamedUnit; case 1: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Unit"; case 1: return "Exponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_INT; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNamedUnit; case 1: return Type::UNDEFINED; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Unit"; case 1: return "Exponent"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9133,9 +9128,9 @@ public:
     int LuminousIntensityExponent() const;
     void setLuminousIntensityExponent(int v);
     virtual unsigned int getArgumentCount() const { return 7; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_INT; case 3: return IfcUtil::Argument_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::UNDEFINED; case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LengthExponent"; case 1: return "MassExponent"; case 2: return "TimeExponent"; case 3: return "ElectricCurrentExponent"; case 4: return "ThermodynamicTemperatureExponent"; case 5: return "AmountOfSubstanceExponent"; case 6: return "LuminousIntensityExponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_INT; case 1: return IfcUtil::Argument_INT; case 2: return IfcUtil::Argument_INT; case 3: return IfcUtil::Argument_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::UNDEFINED; case 1: return Type::UNDEFINED; case 2: return Type::UNDEFINED; case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; case 5: return Type::UNDEFINED; case 6: return Type::UNDEFINED; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LengthExponent"; case 1: return "MassExponent"; case 2: return "TimeExponent"; case 3: return "ElectricCurrentExponent"; case 4: return "ThermodynamicTemperatureExponent"; case 5: return "AmountOfSubstanceExponent"; case 6: return "LuminousIntensityExponent"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9153,9 +9148,9 @@ public:
 class IFC_PARSE_API IfcExternalInformation : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9201,9 +9196,9 @@ public:
     std::string Name() const;
     void setName(std::string v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcURIReference; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; case 1: return "Identification"; case 2: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcURIReference; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Location"; case 1: return "Identification"; case 2: return "Name"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr ExternalReferenceForResources() const; // INVERSE IfcExternalReferenceRelationship::RelatingReference
     bool is(Type::Enum v) const;
@@ -9314,9 +9309,9 @@ public:
     bool SameSense() const;
     void setSameSense(bool v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurve; case 2: return Type::IfcBoolean; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "AxisTag"; case 1: return "AxisCurve"; case 2: return "SameSense"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_BOOL; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcCurve; case 2: return Type::IfcBoolean; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "AxisTag"; case 1: return "AxisCurve"; case 2: return "SameSense"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcGrid >::ptr PartOfW() const; // INVERSE IfcGrid::WAxes
     IfcTemplatedEntityList< IfcGrid >::ptr PartOfV() const; // INVERSE IfcGrid::VAxes
@@ -9341,9 +9336,9 @@ public:
     IfcEntityList::ptr ListValues() const;
     void setListValues(IfcEntityList::ptr v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDateTime; case 1: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TimeStamp"; case 1: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDateTime; case 1: return Type::IfcValue; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TimeStamp"; case 1: return "ListValues"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9477,9 +9472,9 @@ public:
     std::vector< double > /*[1:?]*/ LuminousIntensity() const;
     void setLuminousIntensity(std::vector< double > /*[1:?]*/ v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPlaneAngleMeasure; case 1: return Type::IfcPlaneAngleMeasure; case 2: return Type::IfcLuminousIntensityDistributionMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MainPlaneAngle"; case 1: return "SecondaryPlaneAngle"; case 2: return "LuminousIntensity"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_DOUBLE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPlaneAngleMeasure; case 1: return Type::IfcPlaneAngleMeasure; case 2: return Type::IfcLuminousIntensityDistributionMeasure; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MainPlaneAngle"; case 1: return "SecondaryPlaneAngle"; case 2: return "LuminousIntensity"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9500,9 +9495,9 @@ public:
     IfcTemplatedEntityList< IfcLightDistributionData >::ptr DistributionData() const;
     void setDistributionData(IfcTemplatedEntityList< IfcLightDistributionData >::ptr v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLightDistributionCurveEnum; case 1: return Type::IfcLightDistributionData; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LightDistributionCurve"; case 1: return "DistributionData"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLightDistributionCurveEnum; case 1: return Type::IfcLightDistributionData; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "LightDistributionCurve"; case 1: return "DistributionData"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9581,9 +9576,9 @@ public:
     IfcMaterial* ClassifiedMaterial() const;
     void setClassifiedMaterial(IfcMaterial* v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationSelect; case 1: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialClassifications"; case 1: return "ClassifiedMaterial"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcClassificationSelect; case 1: return Type::IfcMaterial; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MaterialClassifications"; case 1: return "ClassifiedMaterial"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -9619,9 +9614,9 @@ public:
 class IFC_PARSE_API IfcMaterialDefinition : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
@@ -9860,9 +9855,9 @@ public:
     IfcTemplatedEntityList< IfcMaterial >::ptr Materials() const;
     void setMaterials(IfcTemplatedEntityList< IfcMaterial >::ptr v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Materials"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcMaterial; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Materials"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10015,9 +10010,9 @@ public:
 class IFC_PARSE_API IfcMaterialUsageDefinition : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcRelAssociatesMaterial >::ptr AssociatedTo() const; // INVERSE IfcRelAssociatesMaterial::RelatingMaterial
     bool is(Type::Enum v) const;
@@ -10046,9 +10041,9 @@ public:
     IfcUnit* UnitComponent() const;
     void setUnitComponent(IfcUnit* v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ValueComponent"; case 1: return "UnitComponent"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcUnit; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ValueComponent"; case 1: return "UnitComponent"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10151,9 +10146,9 @@ public:
     std::string Currency() const;
     void setCurrency(std::string v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Currency"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Currency"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10176,9 +10171,9 @@ public:
     IfcUnitEnum::IfcUnitEnum UnitType() const;
     void setUnitType(IfcUnitEnum::IfcUnitEnum v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDimensionalExponents; case 1: return Type::IfcUnitEnum; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Dimensions"; case 1: return "UnitType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENUMERATION; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcDimensionalExponents; case 1: return Type::IfcUnitEnum; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Dimensions"; case 1: return "UnitType"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10201,9 +10196,9 @@ public:
 class IFC_PARSE_API IfcObjectPlacement : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcProduct >::ptr PlacesObject() const; // INVERSE IfcProduct::ObjectPlacement
     IfcTemplatedEntityList< IfcLocalPlacement >::ptr ReferencedByPlacements() const; // INVERSE IfcLocalPlacement::PlacementRelTo
@@ -10289,9 +10284,9 @@ public:
     IfcTemplatedEntityList< IfcAddress >::ptr Addresses() const;
     void setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v);
     virtual unsigned int getArgumentCount() const { return 5; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcActorRole; case 4: return Type::IfcAddress; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "Name"; case 2: return "Description"; case 3: return "Roles"; case 4: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcActorRole; case 4: return Type::IfcAddress; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "Name"; case 2: return "Description"; case 3: return "Roles"; case 4: return "Addresses"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr IsRelatedBy() const; // INVERSE IfcOrganizationRelationship::RelatedOrganizations
     IfcTemplatedEntityList< IfcOrganizationRelationship >::ptr Relates() const; // INVERSE IfcOrganizationRelationship::RelatingOrganization
@@ -10350,9 +10345,9 @@ public:
     int CreationDate() const;
     void setCreationDate(int v);
     virtual unsigned int getArgumentCount() const { return 8; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_INT; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPersonAndOrganization; case 1: return Type::IfcApplication; case 2: return Type::IfcStateEnum; case 3: return Type::IfcChangeActionEnum; case 4: return Type::IfcTimeStamp; case 5: return Type::IfcPersonAndOrganization; case 6: return Type::IfcApplication; case 7: return Type::IfcTimeStamp; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "OwningUser"; case 1: return "OwningApplication"; case 2: return "State"; case 3: return "ChangeAction"; case 4: return "LastModifiedDate"; case 5: return "LastModifyingUser"; case 6: return "LastModifyingApplication"; case 7: return "CreationDate"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_ENUMERATION; case 3: return IfcUtil::Argument_ENUMERATION; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_ENTITY_INSTANCE; case 6: return IfcUtil::Argument_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_INT; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPersonAndOrganization; case 1: return Type::IfcApplication; case 2: return Type::IfcStateEnum; case 3: return Type::IfcChangeActionEnum; case 4: return Type::IfcTimeStamp; case 5: return Type::IfcPersonAndOrganization; case 6: return Type::IfcApplication; case 7: return Type::IfcTimeStamp; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "OwningUser"; case 1: return "OwningApplication"; case 2: return "State"; case 3: return "ChangeAction"; case 4: return "LastModifiedDate"; case 5: return "LastModifyingUser"; case 6: return "LastModifyingApplication"; case 7: return "CreationDate"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10419,9 +10414,9 @@ public:
     IfcTemplatedEntityList< IfcAddress >::ptr Addresses() const;
     void setAddresses(IfcTemplatedEntityList< IfcAddress >::ptr v);
     virtual unsigned int getArgumentCount() const { return 8; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcActorRole; case 7: return Type::IfcAddress; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "FamilyName"; case 2: return "GivenName"; case 3: return "MiddleNames"; case 4: return "PrefixTitles"; case 5: return "SuffixTitles"; case 6: return "Roles"; case 7: return "Addresses"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 4: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 5: return IfcUtil::Argument_AGGREGATE_OF_STRING; case 6: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcLabel; case 4: return Type::IfcLabel; case 5: return Type::IfcLabel; case 6: return Type::IfcActorRole; case 7: return Type::IfcAddress; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identification"; case 1: return "FamilyName"; case 2: return "GivenName"; case 3: return "MiddleNames"; case 4: return "PrefixTitles"; case 5: return "SuffixTitles"; case 6: return "Roles"; case 7: return "Addresses"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcPersonAndOrganization >::ptr EngagedIn() const; // INVERSE IfcPersonAndOrganization::ThePerson
     bool is(Type::Enum v) const;
@@ -10450,9 +10445,9 @@ public:
     IfcTemplatedEntityList< IfcActorRole >::ptr Roles() const;
     void setRoles(IfcTemplatedEntityList< IfcActorRole >::ptr v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPerson; case 1: return Type::IfcOrganization; case 2: return Type::IfcActorRole; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ThePerson"; case 1: return "TheOrganization"; case 2: return "Roles"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPerson; case 1: return Type::IfcOrganization; case 2: return Type::IfcActorRole; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ThePerson"; case 1: return "TheOrganization"; case 2: return "Roles"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10477,9 +10472,9 @@ public:
     std::string Description() const;
     void setDescription(std::string v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     IfcTemplatedEntityList< IfcPhysicalComplexQuantity >::ptr PartOfComplex() const; // INVERSE IfcPhysicalComplexQuantity::HasQuantities
@@ -10580,9 +10575,9 @@ public:
 class IFC_PARSE_API IfcPresentationItem : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10625,9 +10620,9 @@ public:
     std::string Identifier() const;
     void setIdentifier(std::string v);
     virtual unsigned int getArgumentCount() const { return 4; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcLayeredItem; case 3: return Type::IfcIdentifier; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AssignedItems"; case 3: return "Identifier"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 3: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcLayeredItem; case 3: return Type::IfcIdentifier; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "AssignedItems"; case 3: return "Identifier"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10692,9 +10687,9 @@ public:
     std::string Name() const;
     void setName(std::string v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10714,9 +10709,9 @@ public:
     IfcEntityList::ptr Styles() const;
     void setStyles(IfcEntityList::ptr v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPresentationStyleSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Styles"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcPresentationStyleSelect; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Styles"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10758,9 +10753,9 @@ public:
     IfcTemplatedEntityList< IfcRepresentation >::ptr Representations() const;
     void setRepresentations(IfcTemplatedEntityList< IfcRepresentation >::ptr v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcRepresentation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Representations"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcRepresentation; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "Representations"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -10950,9 +10945,9 @@ public:
     std::string ProfileName() const;
     void setProfileName(std::string v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileTypeEnum; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileType"; case 1: return "ProfileName"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcProfileTypeEnum; case 1: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ProfileType"; case 1: return "ProfileName"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     IfcTemplatedEntityList< IfcProfileProperties >::ptr HasProperties() const; // INVERSE IfcProfileProperties::ProfileDefinition
@@ -11026,9 +11021,9 @@ public:
 class IFC_PARSE_API IfcPropertyAbstraction : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReferences() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     bool is(Type::Enum v) const;
@@ -11343,9 +11338,9 @@ public:
     IfcTemplatedEntityList< IfcTimePeriod >::ptr TimePeriods() const;
     void setTimePeriods(IfcTemplatedEntityList< IfcTimePeriod >::ptr v);
     virtual unsigned int getArgumentCount() const { return 8; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_INT; case 2: return IfcUtil::Argument_AGGREGATE_OF_INT; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRecurrenceTypeEnum; case 1: return Type::IfcDayInMonthNumber; case 2: return Type::IfcDayInWeekNumber; case 3: return Type::IfcMonthInYearNumber; case 4: return Type::IfcInteger; case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::IfcTimePeriod; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RecurrenceType"; case 1: return "DayComponent"; case 2: return "WeekdayComponent"; case 3: return "MonthComponent"; case 4: return "Position"; case 5: return "Interval"; case 6: return "Occurrences"; case 7: return "TimePeriods"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENUMERATION; case 1: return IfcUtil::Argument_AGGREGATE_OF_INT; case 2: return IfcUtil::Argument_AGGREGATE_OF_INT; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_INT; case 5: return IfcUtil::Argument_INT; case 6: return IfcUtil::Argument_INT; case 7: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRecurrenceTypeEnum; case 1: return Type::IfcDayInMonthNumber; case 2: return Type::IfcDayInWeekNumber; case 3: return Type::IfcMonthInYearNumber; case 4: return Type::IfcInteger; case 5: return Type::IfcInteger; case 6: return Type::IfcInteger; case 7: return Type::IfcTimePeriod; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RecurrenceType"; case 1: return "DayComponent"; case 2: return "WeekdayComponent"; case 3: return "MonthComponent"; case 4: return "Position"; case 5: return "Interval"; case 6: return "Occurrences"; case 7: return "TimePeriods"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -11378,9 +11373,9 @@ public:
     IfcReference* InnerReference() const;
     void setInnerReference(IfcReference* v);
     virtual unsigned int getArgumentCount() const { return 5; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; case 3: return Type::IfcInteger; case 4: return Type::IfcReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TypeIdentifier"; case 1: return "AttributeIdentifier"; case 2: return "InstanceName"; case 3: return "ListPositions"; case 4: return "InnerReference"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcIdentifier; case 2: return Type::IfcLabel; case 3: return Type::IfcInteger; case 4: return Type::IfcReference; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TypeIdentifier"; case 1: return "AttributeIdentifier"; case 2: return "InstanceName"; case 3: return "ListPositions"; case 4: return "InnerReference"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -11455,9 +11450,9 @@ public:
     IfcTemplatedEntityList< IfcRepresentationItem >::ptr Items() const;
     void setItems(IfcTemplatedEntityList< IfcRepresentationItem >::ptr v);
     virtual unsigned int getArgumentCount() const { return 4; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationContext; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcRepresentationItem; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextOfItems"; case 1: return "RepresentationIdentifier"; case 2: return "RepresentationType"; case 3: return "Items"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcRepresentationContext; case 1: return Type::IfcLabel; case 2: return Type::IfcLabel; case 3: return Type::IfcRepresentationItem; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextOfItems"; case 1: return "RepresentationIdentifier"; case 2: return "RepresentationType"; case 3: return "Items"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcRepresentationMap >::ptr RepresentationMap() const; // INVERSE IfcRepresentationMap::MappedRepresentation
     IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignments() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems
@@ -11492,9 +11487,9 @@ public:
     std::string ContextType() const;
     void setContextType(std::string v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextIdentifier"; case 1: return "ContextType"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ContextIdentifier"; case 1: return "ContextType"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcRepresentation >::ptr RepresentationsInContext() const; // INVERSE IfcRepresentation::ContextOfItems
     bool is(Type::Enum v) const;
@@ -11539,9 +11534,9 @@ public:
 class IFC_PARSE_API IfcRepresentationItem : public IfcUtil::IfcBaseEntity {
 public:
     virtual unsigned int getArgumentCount() const { return 0; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcPresentationLayerAssignment >::ptr LayerAssignment() const; // INVERSE IfcPresentationLayerAssignment::AssignedItems
     IfcTemplatedEntityList< IfcStyledItem >::ptr StyledByItem() const; // INVERSE IfcStyledItem::Item
@@ -11573,9 +11568,9 @@ public:
     IfcRepresentation* MappedRepresentation() const;
     void setMappedRepresentation(IfcRepresentation* v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; case 1: return Type::IfcRepresentation; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappingOrigin"; case 1: return "MappedRepresentation"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcAxis2Placement; case 1: return Type::IfcRepresentation; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "MappingOrigin"; case 1: return "MappedRepresentation"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcShapeAspect >::ptr HasShapeAspects() const; // INVERSE IfcShapeAspect::PartOfProductDefinitionShape
     IfcTemplatedEntityList< IfcMappedItem >::ptr MapUsage() const; // INVERSE IfcMappedItem::MappingSource
@@ -11602,9 +11597,9 @@ public:
     std::string Description() const;
     void setDescription(std::string v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -11647,9 +11642,9 @@ public:
     std::string Description() const;
     void setDescription(std::string v);
     virtual unsigned int getArgumentCount() const { return 4; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGloballyUniqueId; case 1: return Type::IfcOwnerHistory; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "GlobalId"; case 1: return "OwnerHistory"; case 2: return "Name"; case 3: return "Description"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGloballyUniqueId; case 1: return Type::IfcOwnerHistory; case 2: return Type::IfcLabel; case 3: return Type::IfcText; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "GlobalId"; case 1: return "OwnerHistory"; case 2: return "Name"; case 3: return "Description"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -11711,9 +11706,9 @@ public:
     std::string UserDefinedDataOrigin() const;
     void setUserDefinedDataOrigin(std::string v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcDataOriginEnum; case 2: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "DataOrigin"; case 2: return "UserDefinedDataOrigin"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_ENUMERATION; case 2: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcDataOriginEnum; case 2: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "DataOrigin"; case 2: return "UserDefinedDataOrigin"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -11787,9 +11782,9 @@ public:
     IfcProductRepresentationSelect* PartOfProductDefinitionShape() const;
     void setPartOfProductDefinitionShape(IfcProductRepresentationSelect* v);
     virtual unsigned int getArgumentCount() const { return 5; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShapeModel; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcLogical; case 4: return Type::IfcProductRepresentationSelect; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ShapeRepresentations"; case 1: return "Name"; case 2: return "Description"; case 3: return "ProductDefinitional"; case 4: return "PartOfProductDefinitionShape"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_BOOL; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcShapeModel; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcLogical; case 4: return Type::IfcProductRepresentationSelect; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ShapeRepresentations"; case 1: return "Name"; case 2: return "Description"; case 3: return "ProductDefinitional"; case 4: return "PartOfProductDefinitionShape"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -11991,9 +11986,9 @@ public:
     std::string Name() const;
     void setName(std::string v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -12013,9 +12008,9 @@ public:
     std::string Name() const;
     void setName(std::string v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -12600,9 +12595,9 @@ public:
     IfcTemplatedEntityList< IfcTableColumn >::ptr Columns() const;
     void setColumns(IfcTemplatedEntityList< IfcTableColumn >::ptr v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcTableRow; case 2: return Type::IfcTableColumn; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Rows"; case 2: return "Columns"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcTableRow; case 2: return Type::IfcTableColumn; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Rows"; case 2: return "Columns"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -12643,9 +12638,9 @@ public:
     IfcReference* ReferencePath() const;
     void setReferencePath(IfcReference* v);
     virtual unsigned int getArgumentCount() const { return 5; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcUnit; case 4: return Type::IfcReference; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "Unit"; case 4: return "ReferencePath"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_ENTITY_INSTANCE; case 4: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcIdentifier; case 1: return Type::IfcLabel; case 2: return Type::IfcText; case 3: return Type::IfcUnit; case 4: return Type::IfcReference; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Identifier"; case 1: return "Name"; case 2: return "Description"; case 3: return "Unit"; case 4: return "ReferencePath"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -12680,9 +12675,9 @@ public:
     bool IsHeading() const;
     void setIsHeading(bool v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcBoolean; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RowCells"; case 1: return "IsHeading"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_BOOL; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; case 1: return Type::IfcBoolean; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "RowCells"; case 1: return "IsHeading"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -13318,9 +13313,9 @@ public:
     std::string EndTime() const;
     void setEndTime(std::string v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTime; case 1: return Type::IfcTime; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "StartTime"; case 1: return "EndTime"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcTime; case 1: return Type::IfcTime; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "StartTime"; case 1: return "EndTime"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -13367,9 +13362,9 @@ public:
     IfcUnit* Unit() const;
     void setUnit(IfcUnit* v);
     virtual unsigned int getArgumentCount() const { return 8; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDateTime; case 3: return Type::IfcDateTime; case 4: return Type::IfcTimeSeriesDataTypeEnum; case 5: return Type::IfcDataOriginEnum; case 6: return Type::IfcLabel; case 7: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "StartTime"; case 3: return "EndTime"; case 4: return "TimeSeriesDataType"; case 5: return "DataOrigin"; case 6: return "UserDefinedDataOrigin"; case 7: return "Unit"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_STRING; case 1: return IfcUtil::Argument_STRING; case 2: return IfcUtil::Argument_STRING; case 3: return IfcUtil::Argument_STRING; case 4: return IfcUtil::Argument_ENUMERATION; case 5: return IfcUtil::Argument_ENUMERATION; case 6: return IfcUtil::Argument_STRING; case 7: return IfcUtil::Argument_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLabel; case 1: return Type::IfcText; case 2: return Type::IfcDateTime; case 3: return Type::IfcDateTime; case 4: return Type::IfcTimeSeriesDataTypeEnum; case 5: return Type::IfcDataOriginEnum; case 6: return Type::IfcLabel; case 7: return Type::IfcUnit; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Name"; case 1: return "Description"; case 2: return "StartTime"; case 3: return "EndTime"; case 4: return "TimeSeriesDataType"; case 5: return "DataOrigin"; case 6: return "UserDefinedDataOrigin"; case 7: return "Unit"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     IfcTemplatedEntityList< IfcExternalReferenceRelationship >::ptr HasExternalReference() const; // INVERSE IfcExternalReferenceRelationship::RelatedResourceObjects
     bool is(Type::Enum v) const;
@@ -13394,9 +13389,9 @@ public:
     IfcEntityList::ptr ListValues() const;
     void setListValues(IfcEntityList::ptr v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ListValues"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcValue; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ListValues"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -13483,9 +13478,9 @@ public:
     IfcEntityList::ptr Units() const;
     void setUnits(IfcEntityList::ptr v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcUnit; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Units"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcUnit; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Units"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -13612,9 +13607,9 @@ public:
     std::vector< double > /*[2:3]*/ OffsetDistances() const;
     void setOffsetDistances(std::vector< double > /*[2:3]*/ v);
     virtual unsigned int getArgumentCount() const { return 2; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGridAxis; case 1: return Type::IfcLengthMeasure; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
-    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "IntersectingAxes"; case 1: return "OffsetDistances"; } throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_DOUBLE; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcGridAxis; case 1: return Type::IfcLengthMeasure; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
+    virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "IntersectingAxes"; case 1: return "OffsetDistances"; } (void)i; throw IfcParse::IfcAttributeOutOfRangeException("Argument index out of range"); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
     bool is(Type::Enum v) const;
     Type::Enum type() const;
@@ -55269,8 +55264,4 @@ void InitStringMap();
 IfcUtil::IfcBaseClass* SchemaEntity(IfcAbstractEntity* e = 0);
 }
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 #endif

src/ifcparse/IfcCharacterDecoder.cpp

@@ -137,10 +137,10 @@ IfcCharacterDecoder::operator std::string() {
 #ifdef HAVE_ICU
 			if ( previous_codepage != codepage ) {
 				if ( converter ) ucnv_close(converter);
-				char encoder[11] = {'i','s','o','-','8','8','5','9','-', (char)codepage + 0x30};
+				char encoder[11] = {'i','s','o','-','8','8','5','9','-', static_cast<char>(codepage + 0x30) };
 				converter = ucnv_open(encoder, &status);
 			}
-			const char characters[2] = { current_char + 0x80 };
+			const char characters[2] = { static_cast<char>(current_char + 0x80) };
 			const char* char_array = &characters[0];
 			UChar32 ch = ucnv_getNextUChar(converter,&char_array,char_array+1,&status);
 			addChar(s,ch);
@@ -218,7 +218,7 @@ IfcCharacterDecoder::operator std::string() {
 			(current_char == '\'' && parse_state == APOSTROPHE)
 			) ) {
 				if ( parse_state == APOSTROPHE && current_char != '\'' ) break;
-				throw IfcException("Invalid character encountered");
+				throw IfcInvalidTokenException(file->Tell(), current_char);
 		} else {
 			parse_state = hex = hex_count = 0;
 			// NOTE: this is in fact wrong, this ought to be the representation of the character.
@@ -286,7 +286,7 @@ void IfcCharacterDecoder::dryRun() {
 			(current_char == '\'' && parse_state == APOSTROPHE)
 			) ) {
 				if ( parse_state == APOSTROPHE && current_char != '\'' ) break;
-				throw IfcException("Invalid character encountered");
+				throw IfcInvalidTokenException(file->Tell(), current_char);
 		} else {
 			parse_state = hex_count = 0;
 		}

src/ifcparse/IfcException.h

@@ -54,7 +54,7 @@ namespace IfcParse {
 		~IfcAttributeOutOfRangeException () throw () {}
 	};
 
-	class IfcInvalidTokenException : public IfcException {
+	class IfcParse_EXPORT IfcInvalidTokenException : public IfcException {
 	public:
 		IfcInvalidTokenException(
 			int token_start,
@@ -67,8 +67,18 @@ namespace IfcParse {
 				" invalid " + expected_type
 			)
 		{}
+		IfcInvalidTokenException(
+			int token_start,
+			char c
+		)
+			: IfcException(
+				std::string("Unexpected '") + std::string(1, c) + "' at " +
+				boost::lexical_cast<std::string>(token_start)
+			)
+		{}
 		~IfcInvalidTokenException() throw () {}
 	};
+
 }
 
 #ifdef _MSC_VER

src/ifcparse/IfcParse.cpp

@@ -29,6 +29,7 @@
 #endif
 
 #include <boost/algorithm/string.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
 
 #include "../ifcparse/IfcCharacterDecoder.h"
 #include "../ifcparse/IfcParse.h"
@@ -916,7 +917,7 @@ void Entity::Load(std::vector<unsigned int>& ids, bool seek) const {
 		if ( ! TokenFunc::isKeyword(datatype)) throw IfcException("Unexpected token while parsing entity");
 		_type = IfcSchema::Type::FromString(TokenFunc::asStringRef(datatype));
 	}
-	Token open = file->tokens->Next();
+	/*Token open =*/ file->tokens->Next();
 	args = new ArgumentList();
 	args->read(file->tokens, ids);
 	unsigned int old_offset = file->tokens->stream->Tell();
@@ -1097,8 +1098,15 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* s) {
 			MaxId = (std::max)(MaxId,currentId);
 			currentId = 0;
 		} else {
-			try { token = tokens->Next(); }
-			catch (... ) { token = NoneTokenPtr(); }
+			try {
+				token = tokens->Next();
+			} catch (const IfcException& e) {
+				Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + ". Parsing terminated");
+				token = NoneTokenPtr();
+			} catch (...) {
+				Logger::Message(Logger::LOG_ERROR, "Parsing terminated");
+				token = NoneTokenPtr();
+			}
 		}
 
 		if ( ! (token.startPos || token.lexer) ) break;
@@ -1207,7 +1215,7 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) {
 		
 		// In case an entity is added that contains geometry, the unit
 		// information needs to be accounted for for IfcLengthMeasures.
-		boost::optional<double> conversion_factor;
+        double conversion_factor = std::numeric_limits<double>::quiet_NaN();
 
 		for (unsigned i = 0; i < we->getArgumentCount(); ++i) {
 			Argument* attr = we->getArgument(i);
@@ -1241,18 +1249,18 @@ IfcUtil::IfcBaseClass* IfcFile::addEntity(IfcUtil::IfcBaseClass* entity) {
 			} else if (entity->getArgumentEntity(i) == IfcSchema::Type::IfcLengthMeasure ||
 				entity->getArgumentEntity(i) == IfcSchema::Type::IfcPositiveLengthMeasure) 
 			{
-				if (!conversion_factor) {
+				if (boost::math::isnan(conversion_factor)) {
 					conversion_factor = other_file->getUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT).second / 
 						getUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT).second;
 				}
 				if (attr_type == IfcUtil::Argument_DOUBLE) {
 					double v = *attr;
-					v *= *conversion_factor;
+					v *= conversion_factor;
 					we->setArgument(i, v);
 				} else if (attr_type == IfcUtil::Argument_AGGREGATE_OF_DOUBLE) {
 					std::vector<double> v = *attr;
 					for (std::vector<double>::iterator it = v.begin(); it != v.end(); ++it) {
-						(*it) *= *conversion_factor;
+						(*it) *= conversion_factor;
 					}
 					we->setArgument(i, v);
 				}

src/ifcparse/IfcUtil.h

@@ -78,6 +78,7 @@ namespace IfcUtil {
 
 	class IFC_PARSE_API IfcBaseClass {
 	public:
+        virtual ~IfcBaseClass() {}
 		IfcAbstractEntity* entity;
 		virtual bool is(IfcSchema::Type::Enum v) const = 0;
 		virtual IfcSchema::Type::Enum type() const = 0;

src/ifcwrap/CMakeLists.txt

@@ -73,6 +73,8 @@ IF(PYTHONINTERP_FOUND)
                 "${CMAKE_BINARY_DIR}/ifcwrap/ifcopenshell_wrapper.py"
                 "${CMAKE_CURRENT_SOURCE_DIR}/../ifcopenshell-python/ifcopenshell/__init__.py"
                 "${CMAKE_CURRENT_SOURCE_DIR}/../ifcopenshell-python/ifcopenshell/guid.py"
+                "${CMAKE_CURRENT_SOURCE_DIR}/../ifcopenshell-python/ifcopenshell/file.py"
+                "${CMAKE_CURRENT_SOURCE_DIR}/../ifcopenshell-python/ifcopenshell/entity_instance.py"
             DESTINATION "${python_package_dir}/ifcopenshell")
         INSTALL(FILES
                 "${CMAKE_CURRENT_SOURCE_DIR}/../ifcopenshell-python/ifcopenshell/geom/__init__.py"

src/ifcwrap/IfcGeomWrapper.i

@@ -275,6 +275,9 @@ struct ShapeRTTI : public boost::static_visitor<PyObject*>
 				// First, try to find a representation based on the settings
 				for (IfcSchema::IfcRepresentation::list::it it = reps->begin(); it != reps->end(); ++it) {
 					IfcSchema::IfcRepresentation* rep = *it;
+					if (!rep->hasRepresentationIdentifier()) {
+						continue;
+					}
 					if (!settings.get(IfcGeom::IteratorSettings::EXCLUDE_SOLIDS_AND_SURFACES)) {
 						if (rep->RepresentationIdentifier() == "Body") {
 							ifc_representation = rep;
@@ -303,6 +306,7 @@ struct ShapeRTTI : public boost::static_visitor<PyObject*>
 							context_types.insert("model");
 							context_types.insert("design");
 							context_types.insert("model view");
+							context_types.insert("detail view");
 						}
 						if (settings.get(IfcGeom::IteratorSettings::INCLUDE_CURVES)) {
 							context_types.insert("plan");

src/ifcwrap/IfcParseWrapper.i

@@ -82,6 +82,10 @@ namespace IfcUtil {
 	IfcEntityList::ptr traverse(IfcParse::IfcLateBoundEntity* e, int max_level=-1) {
 		return $self->traverse(e, max_level);
 	}
+	IfcEntityList::ptr get_inverse(IfcParse::IfcLateBoundEntity* e) {
+		return $self->getInverse(e->id(), IfcSchema::Type::UNDEFINED, -1);
+	}
+
 	void write(const std::string& fn) {
 		std::ofstream f(fn.c_str());
 		f << (*$self);