Provide concrete C++ implementations for all multidimensional aggregate types in IFC4

src/ifcexpressparser/implementation.py

@@ -74,7 +74,7 @@ class Implementation:
                         select = arg['list_instance_type'] == "IfcUtil::IfcBaseClass"
                         express = mapping.flatten_type_string(arg['list_instance_type']) in mapping.express_to_cpp_typemapping
                         if arg['is_enum']: return templates.get_attr_stmt_enum
-                        elif arg['is_nested']: return templates.get_attr_stmt_nested_array
+                        elif arg['is_nested'] and arg['is_templated_list']: return templates.get_attr_stmt_nested_array
                         elif arg['is_templated_list'] and not (select or simple or express): return templates.get_attr_stmt_array
                         elif arg['non_optional_type'].endswith('*'): return templates.get_attr_stmt_entity
                         else: return templates.get_attr_stmt

src/ifcexpressparser/mapping.py

@@ -17,6 +17,7 @@
 #                                                                             #
 ###############################################################################
 
+import sys
 import nodes
 import templates
 
@@ -35,7 +36,7 @@ class Mapping:
     supported_argument_types = {
         'INT', 'BOOL', 'DOUBLE', 'STRING', 'BINARY', 'ENUMERATION', 'ENTITY_INSTANCE',
         'AGGREGATE_OF_INT', 'AGGREGATE_OF_DOUBLE', 'AGGREGATE_OF_STRING', 'AGGREGATE_OF_BINARY', 'AGGREGATE_OF_ENTITY_INSTANCE',
-        'AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE'
+        'AGGREGATE_OF_AGGREGATE_OF_INT', 'AGGREGATE_OF_AGGREGATE_OF_DOUBLE', 'AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE',
     }
 
     def __init__(self, schema):
@@ -96,9 +97,12 @@ class Mapping:
                 ty = _make_argument_type(type.type)
                 if ty == "UNKNOWN": return "UNKNOWN"
                 return "AGGREGATE_OF_" + ty
-            else: raise ValueError
+            else:
+                raise ValueError("Unable to map type %r for attribute %r" % (type, attr))
         ty = _make_argument_type(attr.type if hasattr(attr, 'type') else attr)
-        if ty not in self.supported_argument_types: ty = 'UNKNOWN'
+        if ty not in self.supported_argument_types:
+            print("Attribute %r mapped as 'unknown'" % (type, attr), file=sys.stderr)
+            ty = 'UNKNOWN'
         return "IfcUtil::Argument_%s" % ty
 
     def get_type_dep(self, type):
@@ -121,7 +125,8 @@ class Mapping:
             if self.schema.is_select(attr_type.type):
                 type_str = templates.untyped_list
             elif self.schema.is_simpletype(ty) or ty in self.express_to_cpp_typemapping.values():
-                type_str = templates.array_type % {
+                tmpl = templates.nested_array_type if is_nested_list else templates.array_type
+                type_str = tmpl % {
                     'instance_type' : ty,
                     'lower'         : attr_type.bounds.lower,
                     'upper'         : attr_type.bounds.upper

src/ifcexpressparser/templates.py

@@ -409,6 +409,7 @@ constructor_single_initlist = "%(class_name)s::%(class_name)s(%(arguments)s) : %
 cast_function = "%(class_name)s::operator %(return_type)s() const { %(body)s }"
 
 array_type = "std::vector< %(instance_type)s > /*[%(lower)s:%(upper)s]*/"
+nested_array_type = "std::vector< std::vector< %(instance_type)s > >"
 list_type = "IfcTemplatedEntityList< %(instance_type)s >::ptr"
 list_list_type = "IfcTemplatedEntityListList< %(instance_type)s >::ptr"
 untyped_list = "IfcEntityList::ptr"

src/ifcparse/Ifc4-latebound.cpp

@@ -663,6 +663,7 @@ void InitDescriptorMap() {
     current->add("Name",true,IfcUtil::Argument_STRING,Type::IfcLabel);
     current = entity_descriptor_map[Type::IfcStructuralLoadConfiguration] = new IfcEntityDescriptor(Type::IfcStructuralLoadConfiguration,entity_descriptor_map.find(Type::IfcStructuralLoad)->second);
     current->add("Values",false,IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE,Type::IfcStructuralLoadOrResult);
+    current->add("Locations",true,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,Type::IfcLengthMeasure);
     current = entity_descriptor_map[Type::IfcStructuralLoadOrResult] = new IfcEntityDescriptor(Type::IfcStructuralLoadOrResult,entity_descriptor_map.find(Type::IfcStructuralLoad)->second);
 
     current = entity_descriptor_map[Type::IfcStructuralLoadStatic] = new IfcEntityDescriptor(Type::IfcStructuralLoadStatic,entity_descriptor_map.find(Type::IfcStructuralLoadOrResult)->second);
@@ -771,7 +772,7 @@ void InitDescriptorMap() {
     current = entity_descriptor_map[Type::IfcTextureVertex] = new IfcEntityDescriptor(Type::IfcTextureVertex,entity_descriptor_map.find(Type::IfcPresentationItem)->second);
     current->add("Coordinates",false,IfcUtil::Argument_AGGREGATE_OF_DOUBLE,Type::IfcParameterValue);
     current = entity_descriptor_map[Type::IfcTextureVertexList] = new IfcEntityDescriptor(Type::IfcTextureVertexList,entity_descriptor_map.find(Type::IfcPresentationItem)->second);
-
+    current->add("TexCoordsList",false,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,Type::IfcParameterValue);
     current = entity_descriptor_map[Type::IfcTimePeriod] = new IfcEntityDescriptor(Type::IfcTimePeriod,0);
     current->add("StartTime",false,IfcUtil::Argument_STRING,Type::IfcTime);
     current->add("EndTime",false,IfcUtil::Argument_STRING,Type::IfcTime);
@@ -830,7 +831,7 @@ void InitDescriptorMap() {
     current->add("Description",true,IfcUtil::Argument_STRING,Type::IfcText);
     current->add("Sort",true,IfcUtil::Argument_STRING,Type::IfcIdentifier);
     current = entity_descriptor_map[Type::IfcColourRgbList] = new IfcEntityDescriptor(Type::IfcColourRgbList,entity_descriptor_map.find(Type::IfcPresentationItem)->second);
-
+    current->add("ColourList",false,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,Type::IfcNormalisedRatioMeasure);
     current = entity_descriptor_map[Type::IfcColourSpecification] = new IfcEntityDescriptor(Type::IfcColourSpecification,entity_descriptor_map.find(Type::IfcPresentationItem)->second);
     current->add("Name",true,IfcUtil::Argument_STRING,Type::IfcLabel);
     current = entity_descriptor_map[Type::IfcCompositeProfileDef] = new IfcEntityDescriptor(Type::IfcCompositeProfileDef,entity_descriptor_map.find(Type::IfcProfileDef)->second);
@@ -971,7 +972,7 @@ void InitDescriptorMap() {
     current->add("MappedTo",false,IfcUtil::Argument_ENTITY_INSTANCE,Type::IfcTessellatedFaceSet);
     current->add("TexCoords",false,IfcUtil::Argument_ENTITY_INSTANCE,Type::IfcTextureVertexList);
     current = entity_descriptor_map[Type::IfcIndexedTriangleTextureMap] = new IfcEntityDescriptor(Type::IfcIndexedTriangleTextureMap,entity_descriptor_map.find(Type::IfcIndexedTextureMap)->second);
-
+    current->add("TexCoordIndex",true,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT,Type::UNDEFINED);
     current = entity_descriptor_map[Type::IfcIrregularTimeSeries] = new IfcEntityDescriptor(Type::IfcIrregularTimeSeries,entity_descriptor_map.find(Type::IfcTimeSeries)->second);
     current->add("Values",false,IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE,Type::IfcIrregularTimeSeriesValue);
     current = entity_descriptor_map[Type::IfcLagTime] = new IfcEntityDescriptor(Type::IfcLagTime,entity_descriptor_map.find(Type::IfcSchedulingTime)->second);
@@ -1355,7 +1356,7 @@ void InitDescriptorMap() {
     current = entity_descriptor_map[Type::IfcCartesianPointList] = new IfcEntityDescriptor(Type::IfcCartesianPointList,entity_descriptor_map.find(Type::IfcGeometricRepresentationItem)->second);
 
     current = entity_descriptor_map[Type::IfcCartesianPointList3D] = new IfcEntityDescriptor(Type::IfcCartesianPointList3D,entity_descriptor_map.find(Type::IfcCartesianPointList)->second);
-
+    current->add("CoordList",false,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,Type::IfcLengthMeasure);
     current = entity_descriptor_map[Type::IfcCartesianTransformationOperator] = new IfcEntityDescriptor(Type::IfcCartesianTransformationOperator,entity_descriptor_map.find(Type::IfcGeometricRepresentationItem)->second);
     current->add("Axis1",true,IfcUtil::Argument_ENTITY_INSTANCE,Type::IfcDirection);
     current->add("Axis2",true,IfcUtil::Argument_ENTITY_INSTANCE,Type::IfcDirection);
@@ -1796,11 +1797,13 @@ void InitDescriptorMap() {
     current->add("WorkMethod",true,IfcUtil::Argument_STRING,Type::IfcLabel);
     current = entity_descriptor_map[Type::IfcTessellatedFaceSet] = new IfcEntityDescriptor(Type::IfcTessellatedFaceSet,entity_descriptor_map.find(Type::IfcTessellatedItem)->second);
     current->add("Coordinates",false,IfcUtil::Argument_ENTITY_INSTANCE,Type::IfcCartesianPointList3D);
+    current->add("Normals",true,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,Type::IfcParameterValue);
     current->add("Closed",true,IfcUtil::Argument_BOOL,Type::UNDEFINED);
     current = entity_descriptor_map[Type::IfcTransportElementType] = new IfcEntityDescriptor(Type::IfcTransportElementType,entity_descriptor_map.find(Type::IfcElementType)->second);
     current->add("PredefinedType",false,IfcUtil::Argument_ENUMERATION,Type::IfcTransportElementTypeEnum);
     current = entity_descriptor_map[Type::IfcTriangulatedFaceSet] = new IfcEntityDescriptor(Type::IfcTriangulatedFaceSet,entity_descriptor_map.find(Type::IfcTessellatedFaceSet)->second);
-
+    current->add("CoordIndex",false,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT,Type::UNDEFINED);
+    current->add("NormalIndex",true,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT,Type::UNDEFINED);
     current = entity_descriptor_map[Type::IfcWindowLiningProperties] = new IfcEntityDescriptor(Type::IfcWindowLiningProperties,entity_descriptor_map.find(Type::IfcPreDefinedPropertySet)->second);
     current->add("LiningDepth",true,IfcUtil::Argument_DOUBLE,Type::IfcPositiveLengthMeasure);
     current->add("LiningThickness",true,IfcUtil::Argument_DOUBLE,Type::IfcNonNegativeLengthMeasure);
@@ -2100,7 +2103,7 @@ void InitDescriptorMap() {
     current = entity_descriptor_map[Type::IfcRampType] = new IfcEntityDescriptor(Type::IfcRampType,entity_descriptor_map.find(Type::IfcBuildingElementType)->second);
     current->add("PredefinedType",false,IfcUtil::Argument_ENUMERATION,Type::IfcRampTypeEnum);
     current = entity_descriptor_map[Type::IfcRationalBSplineSurfaceWithKnots] = new IfcEntityDescriptor(Type::IfcRationalBSplineSurfaceWithKnots,entity_descriptor_map.find(Type::IfcBSplineSurfaceWithKnots)->second);
-
+    current->add("WeightsData",false,IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,Type::UNDEFINED);
     current = entity_descriptor_map[Type::IfcReinforcingElement] = new IfcEntityDescriptor(Type::IfcReinforcingElement,entity_descriptor_map.find(Type::IfcElementComponent)->second);
     current->add("SteelGrade",true,IfcUtil::Argument_STRING,Type::IfcLabel);
     current = entity_descriptor_map[Type::IfcReinforcingElementType] = new IfcEntityDescriptor(Type::IfcReinforcingElementType,entity_descriptor_map.find(Type::IfcElementComponentType)->second);

src/ifcparse/Ifc4.cpp

@@ -8729,11 +8729,13 @@ IfcCartesianPointList::IfcCartesianPointList(IfcAbstractEntity* e) : IfcGeometri
 IfcCartesianPointList::IfcCartesianPointList() : IfcGeometricRepresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcCartesianPointList3D
+std::vector< std::vector< double > > IfcCartesianPointList3D::CoordList() const { return *entity->getArgument(0); }
+void IfcCartesianPointList3D::setCoordList(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); }
 bool IfcCartesianPointList3D::is(Type::Enum v) const { return v == Type::IfcCartesianPointList3D || IfcCartesianPointList::is(v); }
 Type::Enum IfcCartesianPointList3D::type() const { return Type::IfcCartesianPointList3D; }
 Type::Enum IfcCartesianPointList3D::Class() { return Type::IfcCartesianPointList3D; }
 IfcCartesianPointList3D::IfcCartesianPointList3D(IfcAbstractEntity* e) : IfcCartesianPointList((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcCartesianPointList3D)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcCartesianPointList3D::IfcCartesianPointList3D() : IfcCartesianPointList((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); }
+IfcCartesianPointList3D::IfcCartesianPointList3D(std::vector< std::vector< double > > v1_CoordList) : IfcCartesianPointList((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_CoordList)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcCartesianTransformationOperator
 bool IfcCartesianTransformationOperator::hasAxis1() const { return !entity->getArgument(0)->isNull(); }
@@ -8968,11 +8970,13 @@ IfcColourRgb::IfcColourRgb(IfcAbstractEntity* e) : IfcColourSpecification((IfcAb
 IfcColourRgb::IfcColourRgb(boost::optional< std::string > v1_Name, double v2_Red, double v3_Green, double v4_Blue) : IfcColourSpecification((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Red)); e->setArgument(2,(v3_Green)); e->setArgument(3,(v4_Blue)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcColourRgbList
+std::vector< std::vector< double > > IfcColourRgbList::ColourList() const { return *entity->getArgument(0); }
+void IfcColourRgbList::setColourList(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); }
 bool IfcColourRgbList::is(Type::Enum v) const { return v == Type::IfcColourRgbList || IfcPresentationItem::is(v); }
 Type::Enum IfcColourRgbList::type() const { return Type::IfcColourRgbList; }
 Type::Enum IfcColourRgbList::Class() { return Type::IfcColourRgbList; }
 IfcColourRgbList::IfcColourRgbList(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcColourRgbList)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcColourRgbList::IfcColourRgbList() : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); }
+IfcColourRgbList::IfcColourRgbList(std::vector< std::vector< double > > v1_ColourList) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_ColourList)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcColourSpecification
 bool IfcColourSpecification::hasName() const { return !entity->getArgument(0)->isNull(); }
@@ -11392,11 +11396,14 @@ IfcIndexedTextureMap::IfcIndexedTextureMap(IfcAbstractEntity* e) : IfcTextureCoo
 IfcIndexedTextureMap::IfcIndexedTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords) : IfcTextureCoordinate((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcIndexedTriangleTextureMap
+bool IfcIndexedTriangleTextureMap::hasTexCoordIndex() const { return !entity->getArgument(3)->isNull(); }
+std::vector< std::vector< int > > IfcIndexedTriangleTextureMap::TexCoordIndex() const { return *entity->getArgument(3); }
+void IfcIndexedTriangleTextureMap::setTexCoordIndex(std::vector< std::vector< int > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); }
 bool IfcIndexedTriangleTextureMap::is(Type::Enum v) const { return v == Type::IfcIndexedTriangleTextureMap || IfcIndexedTextureMap::is(v); }
 Type::Enum IfcIndexedTriangleTextureMap::type() const { return Type::IfcIndexedTriangleTextureMap; }
 Type::Enum IfcIndexedTriangleTextureMap::Class() { return Type::IfcIndexedTriangleTextureMap; }
 IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcAbstractEntity* e) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcIndexedTriangleTextureMap)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); entity = e; EntityBuffer::Add(this); }
+IfcIndexedTriangleTextureMap::IfcIndexedTriangleTextureMap(IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords, boost::optional< std::vector< std::vector< int > > > v4_TexCoordIndex) : IfcIndexedTextureMap((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Maps)->generalize()); e->setArgument(1,(v2_MappedTo)); e->setArgument(2,(v3_TexCoords)); if (v4_TexCoordIndex) { e->setArgument(3,(*v4_TexCoordIndex)); } else { e->setArgument(3); } entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcInterceptor
 bool IfcInterceptor::hasPredefinedType() const { return !entity->getArgument(8)->isNull(); }
@@ -13520,11 +13527,13 @@ IfcRationalBSplineCurveWithKnots::IfcRationalBSplineCurveWithKnots(IfcAbstractEn
 IfcRationalBSplineCurveWithKnots::IfcRationalBSplineCurveWithKnots(int v1_Degree, IfcTemplatedEntityList< IfcCartesianPoint >::ptr v2_ControlPointsList, IfcBSplineCurveForm::IfcBSplineCurveForm v3_CurveForm, bool v4_ClosedCurve, bool v5_SelfIntersect, std::vector< int > /*[2:?]*/ v6_KnotMultiplicities, std::vector< double > /*[2:?]*/ v7_Knots, IfcKnotType::IfcKnotType v8_KnotSpec, std::vector< double > /*[2:?]*/ v9_WeightsData) : IfcBSplineCurveWithKnots((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Degree)); e->setArgument(1,(v2_ControlPointsList)->generalize()); e->setArgument(2,v3_CurveForm,IfcBSplineCurveForm::ToString(v3_CurveForm)); e->setArgument(3,(v4_ClosedCurve)); e->setArgument(4,(v5_SelfIntersect)); e->setArgument(5,(v6_KnotMultiplicities)); e->setArgument(6,(v7_Knots)); e->setArgument(7,v8_KnotSpec,IfcKnotType::ToString(v8_KnotSpec)); e->setArgument(8,(v9_WeightsData)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcRationalBSplineSurfaceWithKnots
+std::vector< std::vector< double > > IfcRationalBSplineSurfaceWithKnots::WeightsData() const { return *entity->getArgument(12); }
+void IfcRationalBSplineSurfaceWithKnots::setWeightsData(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(12,v); }
 bool IfcRationalBSplineSurfaceWithKnots::is(Type::Enum v) const { return v == Type::IfcRationalBSplineSurfaceWithKnots || IfcBSplineSurfaceWithKnots::is(v); }
 Type::Enum IfcRationalBSplineSurfaceWithKnots::type() const { return Type::IfcRationalBSplineSurfaceWithKnots; }
 Type::Enum IfcRationalBSplineSurfaceWithKnots::Class() { return Type::IfcRationalBSplineSurfaceWithKnots; }
 IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(IfcAbstractEntity* e) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcRationalBSplineSurfaceWithKnots)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); e->setArgument(7,(v8_UMultiplicities)); e->setArgument(8,(v9_VMultiplicities)); e->setArgument(9,(v10_UKnots)); e->setArgument(10,(v11_VKnots)); e->setArgument(11,v12_KnotSpec,IfcKnotType::ToString(v12_KnotSpec)); entity = e; EntityBuffer::Add(this); }
+IfcRationalBSplineSurfaceWithKnots::IfcRationalBSplineSurfaceWithKnots(int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec, std::vector< std::vector< double > > v13_WeightsData) : IfcBSplineSurfaceWithKnots((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_UDegree)); e->setArgument(1,(v2_VDegree)); e->setArgument(2,(v3_ControlPointsList)->generalize()); e->setArgument(3,v4_SurfaceForm,IfcBSplineSurfaceForm::ToString(v4_SurfaceForm)); e->setArgument(4,(v5_UClosed)); e->setArgument(5,(v6_VClosed)); e->setArgument(6,(v7_SelfIntersect)); e->setArgument(7,(v8_UMultiplicities)); e->setArgument(8,(v9_VMultiplicities)); e->setArgument(9,(v10_UKnots)); e->setArgument(10,(v11_VKnots)); e->setArgument(11,v12_KnotSpec,IfcKnotType::ToString(v12_KnotSpec)); e->setArgument(12,(v13_WeightsData)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcRectangleHollowProfileDef
 double IfcRectangleHollowProfileDef::WallThickness() const { return *entity->getArgument(5); }
@@ -15263,11 +15272,14 @@ IfcStructuralLoadCase::IfcStructuralLoadCase(std::string v1_GlobalId, IfcOwnerHi
 // Function implementations for IfcStructuralLoadConfiguration
 IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr IfcStructuralLoadConfiguration::Values() const { IfcEntityList::ptr es = *entity->getArgument(1); return es->as<IfcStructuralLoadOrResult>(); }
 void IfcStructuralLoadConfiguration::setValues(IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v->generalize()); }
+bool IfcStructuralLoadConfiguration::hasLocations() const { return !entity->getArgument(2)->isNull(); }
+std::vector< std::vector< double > > IfcStructuralLoadConfiguration::Locations() const { return *entity->getArgument(2); }
+void IfcStructuralLoadConfiguration::setLocations(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); }
 bool IfcStructuralLoadConfiguration::is(Type::Enum v) const { return v == Type::IfcStructuralLoadConfiguration || IfcStructuralLoad::is(v); }
 Type::Enum IfcStructuralLoadConfiguration::type() const { return Type::IfcStructuralLoadConfiguration; }
 Type::Enum IfcStructuralLoadConfiguration::Class() { return Type::IfcStructuralLoadConfiguration; }
 IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(IfcAbstractEntity* e) : IfcStructuralLoad((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcStructuralLoadConfiguration)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values) : IfcStructuralLoad((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Values)->generalize()); entity = e; EntityBuffer::Add(this); }
+IfcStructuralLoadConfiguration::IfcStructuralLoadConfiguration(boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values, boost::optional< std::vector< std::vector< double > > > v3_Locations) : IfcStructuralLoad((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); if (v1_Name) { e->setArgument(0,(*v1_Name)); } else { e->setArgument(0); } e->setArgument(1,(v2_Values)->generalize()); if (v3_Locations) { e->setArgument(2,(*v3_Locations)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcStructuralLoadGroup
 IfcLoadGroupTypeEnum::IfcLoadGroupTypeEnum IfcStructuralLoadGroup::PredefinedType() const { return IfcLoadGroupTypeEnum::FromString(*entity->getArgument(5)); }
@@ -16176,6 +16188,9 @@ IfcTendonType::IfcTendonType(std::string v1_GlobalId, IfcOwnerHistory* v2_OwnerH
 // Function implementations for IfcTessellatedFaceSet
 IfcCartesianPointList3D* IfcTessellatedFaceSet::Coordinates() const { return (IfcCartesianPointList3D*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); }
 void IfcTessellatedFaceSet::setCoordinates(IfcCartesianPointList3D* v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); }
+bool IfcTessellatedFaceSet::hasNormals() const { return !entity->getArgument(1)->isNull(); }
+std::vector< std::vector< double > > IfcTessellatedFaceSet::Normals() const { return *entity->getArgument(1); }
+void IfcTessellatedFaceSet::setNormals(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(1,v); }
 bool IfcTessellatedFaceSet::hasClosed() const { return !entity->getArgument(2)->isNull(); }
 bool IfcTessellatedFaceSet::Closed() const { return *entity->getArgument(2); }
 void IfcTessellatedFaceSet::setClosed(bool v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(2,v); }
@@ -16185,7 +16200,7 @@ bool IfcTessellatedFaceSet::is(Type::Enum v) const { return v == Type::IfcTessel
 Type::Enum IfcTessellatedFaceSet::type() const { return Type::IfcTessellatedFaceSet; }
 Type::Enum IfcTessellatedFaceSet::Class() { return Type::IfcTessellatedFaceSet; }
 IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcAbstractEntity* e) : IfcTessellatedItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTessellatedFaceSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< bool > v3_Closed) : IfcTessellatedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); }
+IfcTessellatedFaceSet::IfcTessellatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed) : IfcTessellatedItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v2_Normals) { e->setArgument(1,(*v2_Normals)); } else { e->setArgument(1); } if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcTessellatedItem
 bool IfcTessellatedItem::is(Type::Enum v) const { return v == Type::IfcTessellatedItem || IfcGeometricRepresentationItem::is(v); }
@@ -16338,11 +16353,13 @@ IfcTextureVertex::IfcTextureVertex(IfcAbstractEntity* e) : IfcPresentationItem((
 IfcTextureVertex::IfcTextureVertex(std::vector< double > /*[2:2]*/ v1_Coordinates) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcTextureVertexList
+std::vector< std::vector< double > > IfcTextureVertexList::TexCoordsList() const { return *entity->getArgument(0); }
+void IfcTextureVertexList::setTexCoordsList(std::vector< std::vector< double > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(0,v); }
 bool IfcTextureVertexList::is(Type::Enum v) const { return v == Type::IfcTextureVertexList || IfcPresentationItem::is(v); }
 Type::Enum IfcTextureVertexList::type() const { return Type::IfcTextureVertexList; }
 Type::Enum IfcTextureVertexList::Class() { return Type::IfcTextureVertexList; }
 IfcTextureVertexList::IfcTextureVertexList(IfcAbstractEntity* e) : IfcPresentationItem((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTextureVertexList)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcTextureVertexList::IfcTextureVertexList() : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); entity = e; EntityBuffer::Add(this); }
+IfcTextureVertexList::IfcTextureVertexList(std::vector< std::vector< double > > v1_TexCoordsList) : IfcPresentationItem((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_TexCoordsList)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcTimePeriod
 std::string IfcTimePeriod::StartTime() const { return *entity->getArgument(0); }
@@ -16459,11 +16476,16 @@ IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcAbstractEntity* e) : IfcParame
 IfcTrapeziumProfileDef::IfcTrapeziumProfileDef(IfcProfileTypeEnum::IfcProfileTypeEnum v1_ProfileType, boost::optional< std::string > v2_ProfileName, IfcAxis2Placement2D* v3_Position, double v4_BottomXDim, double v5_TopXDim, double v6_YDim, double v7_TopXOffset) : IfcParameterizedProfileDef((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,v1_ProfileType,IfcProfileTypeEnum::ToString(v1_ProfileType)); if (v2_ProfileName) { e->setArgument(1,(*v2_ProfileName)); } else { e->setArgument(1); } e->setArgument(2,(v3_Position)); e->setArgument(3,(v4_BottomXDim)); e->setArgument(4,(v5_TopXDim)); e->setArgument(5,(v6_YDim)); e->setArgument(6,(v7_TopXOffset)); entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcTriangulatedFaceSet
+std::vector< std::vector< int > > IfcTriangulatedFaceSet::CoordIndex() const { return *entity->getArgument(3); }
+void IfcTriangulatedFaceSet::setCoordIndex(std::vector< std::vector< int > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(3,v); }
+bool IfcTriangulatedFaceSet::hasNormalIndex() const { return !entity->getArgument(4)->isNull(); }
+std::vector< std::vector< int > > IfcTriangulatedFaceSet::NormalIndex() const { return *entity->getArgument(4); }
+void IfcTriangulatedFaceSet::setNormalIndex(std::vector< std::vector< int > > v) { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(4,v); }
 bool IfcTriangulatedFaceSet::is(Type::Enum v) const { return v == Type::IfcTriangulatedFaceSet || IfcTessellatedFaceSet::is(v); }
 Type::Enum IfcTriangulatedFaceSet::type() const { return Type::IfcTriangulatedFaceSet; }
 Type::Enum IfcTriangulatedFaceSet::Class() { return Type::IfcTriangulatedFaceSet; }
 IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcAbstractEntity* e) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { if (!e) return; if (!e->is(Type::IfcTriangulatedFaceSet)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
-IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< bool > v3_Closed) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } entity = e; EntityBuffer::Add(this); }
+IfcTriangulatedFaceSet::IfcTriangulatedFaceSet(IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed, std::vector< std::vector< int > > v4_CoordIndex, boost::optional< std::vector< std::vector< int > > > v5_NormalIndex) : IfcTessellatedFaceSet((IfcAbstractEntity*)0) { IfcWritableEntity* e = new IfcWritableEntity(Class()); e->setArgument(0,(v1_Coordinates)); if (v2_Normals) { e->setArgument(1,(*v2_Normals)); } else { e->setArgument(1); } if (v3_Closed) { e->setArgument(2,(*v3_Closed)); } else { e->setArgument(2); } e->setArgument(3,(v4_CoordIndex)); if (v5_NormalIndex) { e->setArgument(4,(*v5_NormalIndex)); } else { e->setArgument(4); } entity = e; EntityBuffer::Add(this); }
 
 // Function implementations for IfcTrimmedCurve
 IfcCurve* IfcTrimmedCurve::BasisCurve() const { return (IfcCurve*)((IfcUtil::IfcBaseClass*)(*entity->getArgument(0))); }

src/ifcparse/Ifc4.h

@@ -11970,8 +11970,10 @@ public:
     /// Whether the optional attribute Locations is defined for this IfcStructuralLoadConfiguration
     bool hasLocations() const;
     /// Locations of the load samples or result samples, given within the local coordinate system defined by the instance which uses this resource object.  Each item in the list of locations pertains to the values list item at the same list index.  This attribute is optional for configurations in which the locations are implicitly known from higher-level definitions.
+    std::vector< std::vector< double > > Locations() const;
+    void setLocations(std::vector< std::vector< double > > v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_UNKNOWN; } return IfcStructuralLoad::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 1: return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE; case 2: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcStructuralLoad::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 1: return Type::IfcStructuralLoadOrResult; case 2: return Type::IfcLengthMeasure; } return IfcStructuralLoad::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 1: return "Values"; case 2: return "Locations"; } return IfcStructuralLoad::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -11979,7 +11981,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcStructuralLoadConfiguration (IfcAbstractEntity* e);
-    IfcStructuralLoadConfiguration (boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values);
+    IfcStructuralLoadConfiguration (boost::optional< std::string > v1_Name, IfcTemplatedEntityList< IfcStructuralLoadOrResult >::ptr v2_Values, boost::optional< std::vector< std::vector< double > > > v3_Locations);
     typedef IfcTemplatedEntityList< IfcStructuralLoadConfiguration > list;
 };
 /// Definition from IAI: Abstract superclass of simple load or result classes.
@@ -13211,8 +13213,10 @@ public:
 
 class IfcTextureVertexList : public IfcPresentationItem {
 public:
+    std::vector< std::vector< double > > TexCoordsList() const;
+    void setTexCoordsList(std::vector< std::vector< double > > v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_UNKNOWN; } return IfcPresentationItem::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcPresentationItem::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcParameterValue; } return IfcPresentationItem::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "TexCoordsList"; } return IfcPresentationItem::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -13220,7 +13224,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcTextureVertexList (IfcAbstractEntity* e);
-    IfcTextureVertexList ();
+    IfcTextureVertexList (std::vector< std::vector< double > > v1_TexCoordsList);
     typedef IfcTemplatedEntityList< IfcTextureVertexList > list;
 };
 /// IfcTimePeriod defines a time period given by a start and end time. Both time definitions consider the time zone and allow for the daylight savings offset.
@@ -13936,8 +13940,10 @@ public:
 
 class IfcColourRgbList : public IfcPresentationItem {
 public:
+    std::vector< std::vector< double > > ColourList() const;
+    void setColourList(std::vector< std::vector< double > > v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_UNKNOWN; } return IfcPresentationItem::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcPresentationItem::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcNormalisedRatioMeasure; } return IfcPresentationItem::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "ColourList"; } return IfcPresentationItem::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -13945,7 +13951,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcColourRgbList (IfcAbstractEntity* e);
-    IfcColourRgbList ();
+    IfcColourRgbList (std::vector< std::vector< double > > v1_ColourList);
     typedef IfcTemplatedEntityList< IfcColourRgbList > list;
 };
 /// Definition from ISO/CD 10303-46:1992: The colour specification entity contains a direct colour definition. Colour component values refer directly to a specific colour space.
@@ -15651,8 +15657,10 @@ class IfcIndexedTriangleTextureMap : public IfcIndexedTextureMap {
 public:
     /// Whether the optional attribute TexCoordIndex is defined for this IfcIndexedTriangleTextureMap
     bool hasTexCoordIndex() const;
+    std::vector< std::vector< int > > TexCoordIndex() const;
+    void setTexCoordIndex(std::vector< std::vector< int > > v);
     virtual unsigned int getArgumentCount() const { return 4; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_UNKNOWN; } return IfcIndexedTextureMap::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT; } return IfcIndexedTextureMap::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::UNDEFINED; } return IfcIndexedTextureMap::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "TexCoordIndex"; } return IfcIndexedTextureMap::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -15660,7 +15668,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcIndexedTriangleTextureMap (IfcAbstractEntity* e);
-    IfcIndexedTriangleTextureMap (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords);
+    IfcIndexedTriangleTextureMap (IfcTemplatedEntityList< IfcSurfaceTexture >::ptr v1_Maps, IfcTessellatedFaceSet* v2_MappedTo, IfcTextureVertexList* v3_TexCoords, boost::optional< std::vector< std::vector< int > > > v4_TexCoordIndex);
     typedef IfcTemplatedEntityList< IfcIndexedTriangleTextureMap > list;
 };
 /// In an irregular time series, unpredictable bursts of data arrive at unspecified points in time, or most time stamps cannot be characterized by a repeating pattern.
@@ -20179,8 +20187,10 @@ public:
 
 class IfcCartesianPointList3D : public IfcCartesianPointList {
 public:
+    std::vector< std::vector< double > > CoordList() const;
+    void setCoordList(std::vector< std::vector< double > > v);
     virtual unsigned int getArgumentCount() const { return 1; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_UNKNOWN; } return IfcCartesianPointList::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcCartesianPointList::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcLengthMeasure; } return IfcCartesianPointList::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "CoordList"; } return IfcCartesianPointList::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -20188,7 +20198,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcCartesianPointList3D (IfcAbstractEntity* e);
-    IfcCartesianPointList3D ();
+    IfcCartesianPointList3D (std::vector< std::vector< double > > v1_CoordList);
     typedef IfcTemplatedEntityList< IfcCartesianPointList3D > list;
 };
 /// Definition from ISO/CD 10303-42:1992: A Cartesian transformation operator defines a geometric transformation composed of translation, rotation, mirroring and uniform scaling. The list of normalized vectors u defines the columns of an orthogonal matrix T. These vectors are computed, by the base axis function, from the direction attributes axis1, axis2 and, in Cartesian transformation operator 3d, axis3. If |T|= -1, the transformation includes mirroring. The local origin point A, the scale value S and the matrix T together define a transformation.  
@@ -28153,12 +28163,14 @@ public:
     void setCoordinates(IfcCartesianPointList3D* v);
     /// Whether the optional attribute Normals is defined for this IfcTessellatedFaceSet
     bool hasNormals() const;
+    std::vector< std::vector< double > > Normals() const;
+    void setNormals(std::vector< std::vector< double > > v);
     /// Whether the optional attribute Closed is defined for this IfcTessellatedFaceSet
     bool hasClosed() const;
     bool Closed() const;
     void setClosed(bool v);
     virtual unsigned int getArgumentCount() const { return 3; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_UNKNOWN; case 2: return IfcUtil::Argument_BOOL; } return IfcTessellatedItem::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 0: return IfcUtil::Argument_ENTITY_INSTANCE; case 1: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; case 2: return IfcUtil::Argument_BOOL; } return IfcTessellatedItem::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 0: return Type::IfcCartesianPointList3D; case 1: return Type::IfcParameterValue; case 2: return Type::UNDEFINED; } return IfcTessellatedItem::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 0: return "Coordinates"; case 1: return "Normals"; case 2: return "Closed"; } return IfcTessellatedItem::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -28168,7 +28180,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcTessellatedFaceSet (IfcAbstractEntity* e);
-    IfcTessellatedFaceSet (IfcCartesianPointList3D* v1_Coordinates, boost::optional< bool > v3_Closed);
+    IfcTessellatedFaceSet (IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed);
     typedef IfcTemplatedEntityList< IfcTessellatedFaceSet > list;
 };
 /// Definition from IAI: The element type
@@ -28254,10 +28266,14 @@ public:
 
 class IfcTriangulatedFaceSet : public IfcTessellatedFaceSet {
 public:
+    std::vector< std::vector< int > > CoordIndex() const;
+    void setCoordIndex(std::vector< std::vector< int > > v);
     /// Whether the optional attribute NormalIndex is defined for this IfcTriangulatedFaceSet
     bool hasNormalIndex() const;
+    std::vector< std::vector< int > > NormalIndex() const;
+    void setNormalIndex(std::vector< std::vector< int > > v);
     virtual unsigned int getArgumentCount() const { return 5; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_UNKNOWN; case 4: return IfcUtil::Argument_UNKNOWN; } return IfcTessellatedFaceSet::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 3: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT; case 4: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT; } return IfcTessellatedFaceSet::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 3: return Type::UNDEFINED; case 4: return Type::UNDEFINED; } return IfcTessellatedFaceSet::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 3: return "CoordIndex"; case 4: return "NormalIndex"; } return IfcTessellatedFaceSet::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -28265,7 +28281,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcTriangulatedFaceSet (IfcAbstractEntity* e);
-    IfcTriangulatedFaceSet (IfcCartesianPointList3D* v1_Coordinates, boost::optional< bool > v3_Closed);
+    IfcTriangulatedFaceSet (IfcCartesianPointList3D* v1_Coordinates, boost::optional< std::vector< std::vector< double > > > v2_Normals, boost::optional< bool > v3_Closed, std::vector< std::vector< int > > v4_CoordIndex, boost::optional< std::vector< std::vector< int > > > v5_NormalIndex);
     typedef IfcTemplatedEntityList< IfcTriangulatedFaceSet > list;
 };
 /// The window lining is the outer
@@ -35259,8 +35275,10 @@ public:
 class IfcRationalBSplineSurfaceWithKnots : public IfcBSplineSurfaceWithKnots {
 public:
     /// The weights associated with the control points in the rational case.
+    std::vector< std::vector< double > > WeightsData() const;
+    void setWeightsData(std::vector< std::vector< double > > v);
     virtual unsigned int getArgumentCount() const { return 13; }
-    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 12: return IfcUtil::Argument_UNKNOWN; } return IfcBSplineSurfaceWithKnots::getArgumentType(i); }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const { switch (i) {case 12: return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE; } return IfcBSplineSurfaceWithKnots::getArgumentType(i); }
     virtual Type::Enum getArgumentEntity(unsigned int i) const { switch (i) {case 12: return Type::UNDEFINED; } return IfcBSplineSurfaceWithKnots::getArgumentEntity(i); }
     virtual const char* getArgumentName(unsigned int i) const { switch (i) {case 12: return "WeightsData"; } return IfcBSplineSurfaceWithKnots::getArgumentName(i); }
     virtual Argument* getArgument(unsigned int i) const { return entity->getArgument(i); }
@@ -35268,7 +35286,7 @@ public:
     Type::Enum type() const;
     static Type::Enum Class();
     IfcRationalBSplineSurfaceWithKnots (IfcAbstractEntity* e);
-    IfcRationalBSplineSurfaceWithKnots (int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec);
+    IfcRationalBSplineSurfaceWithKnots (int v1_UDegree, int v2_VDegree, IfcTemplatedEntityListList< IfcCartesianPoint >::ptr v3_ControlPointsList, IfcBSplineSurfaceForm::IfcBSplineSurfaceForm v4_SurfaceForm, bool v5_UClosed, bool v6_VClosed, bool v7_SelfIntersect, std::vector< int > /*[2:?]*/ v8_UMultiplicities, std::vector< int > /*[2:?]*/ v9_VMultiplicities, std::vector< double > /*[2:?]*/ v10_UKnots, std::vector< double > /*[2:?]*/ v11_VKnots, IfcKnotType::IfcKnotType v12_KnotSpec, std::vector< std::vector< double > > v13_WeightsData);
     typedef IfcTemplatedEntityList< IfcRationalBSplineSurfaceWithKnots > list;
 };
 /// Definition from IAI: Bars, wires, strands, meshes, tendons, and other components embedded in concrete in such a manner that the reinforcement and the concrete act together in resisting forces.

src/ifcparse/IfcParse.cpp

@@ -549,6 +549,10 @@ IfcUtil::ArgumentType ArgumentList::type() const {
 		return IfcUtil::Argument_AGGREGATE_OF_BINARY;
 	} else if (elem_type == IfcUtil::Argument_ENTITY_INSTANCE) {
 		return IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE;
+	} else if (elem_type == IfcUtil::Argument_AGGREGATE_OF_INT) {
+		return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT;
+	} else if (elem_type == IfcUtil::Argument_AGGREGATE_OF_DOUBLE) {
+		return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE;
 	} else if (elem_type == IfcUtil::Argument_AGGREGATE_OF_ENTITY_INSTANCE) {
 		return IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE;
 	} else {
@@ -562,7 +566,7 @@ void ArgumentList::push(Argument* l) {
 
 // templated helper function for reading arguments into a list
 template<typename T>
-std::vector<T> read_list_as_vector(const std::vector<Argument*>& list) {
+std::vector<T> read_aggregate_as_vector(const std::vector<Argument*>& list) {
 	std::vector<T> return_value;
 	return_value.reserve(list.size());
 	std::vector<Argument*>::const_iterator it = list.begin();
@@ -571,6 +575,16 @@ std::vector<T> read_list_as_vector(const std::vector<Argument*>& list) {
 	}
 	return return_value;
 }
+template<typename T>
+std::vector< std::vector<T> > read_aggregate_of_aggregate_as_vector2(const std::vector<Argument*>& list) {
+	std::vector< std::vector<T> > return_value;
+	return_value.reserve(list.size());
+	std::vector<Argument*>::const_iterator it = list.begin();
+	for (; it != list.end(); ++it) {
+		return_value.push_back(**it);
+	}
+	return return_value;
+}
 
 //
 // Functions for casting the ArgumentList to other types
@@ -580,19 +594,25 @@ ArgumentList::operator bool() const { throw IfcException("Argument is not a bool
 ArgumentList::operator double() const { throw IfcException("Argument is not a number"); }
 ArgumentList::operator std::string() const { throw IfcException("Argument is not a string"); }
 ArgumentList::operator boost::dynamic_bitset<>() const { throw IfcException("Argument is not a binary"); }
+
 ArgumentList::operator std::vector<double>() const {
-	return read_list_as_vector<double>(list);
+	return read_aggregate_as_vector<double>(list);
 }
+
 ArgumentList::operator std::vector<int>() const {
-	return read_list_as_vector<int>(list);
+	return read_aggregate_as_vector<int>(list);
 }
+
 ArgumentList::operator std::vector<std::string>() const {
-	return read_list_as_vector<std::string>(list);
+	return read_aggregate_as_vector<std::string>(list);
 }
+
 ArgumentList::operator std::vector<boost::dynamic_bitset<> >() const {
-	return read_list_as_vector<boost::dynamic_bitset<> >(list);
+	return read_aggregate_as_vector<boost::dynamic_bitset<> >(list);
 }
+
 ArgumentList::operator IfcUtil::IfcBaseClass*() const { throw IfcException("Argument is not an entity instance"); }
+
 ArgumentList::operator IfcEntityList::ptr() const {
 	IfcEntityList::ptr l ( new IfcEntityList() );
 	std::vector<Argument*>::const_iterator it;
@@ -603,6 +623,15 @@ ArgumentList::operator IfcEntityList::ptr() const {
 	}
 	return l;
 }
+
+ArgumentList::operator std::vector< std::vector<int> >() const {
+	return read_aggregate_of_aggregate_as_vector2<int>(list);
+}
+
+ArgumentList::operator std::vector< std::vector<double> >() const {
+	return read_aggregate_of_aggregate_as_vector2<double>(list);
+}
+
 ArgumentList::operator IfcEntityListList::ptr() const {
 	IfcEntityListList::ptr l ( new IfcEntityListList() );
 	std::vector<Argument*>::const_iterator it;
@@ -616,13 +645,16 @@ ArgumentList::operator IfcEntityListList::ptr() const {
 	}
 	return l;
 }
+
 unsigned int ArgumentList::size() const { return (unsigned int) list.size(); }
+
 Argument* ArgumentList::operator [] (unsigned int i) const {
 	if ( i >= list.size() ) {
 		throw IfcException("Argument index out of range");
 	}
 	return list[i];
 }
+
 void ArgumentList::set(unsigned int i, Argument* argument) {
 	while (size() < i) {
 		push(new TokenArgument(Token(static_cast<IfcSpfLexer*>(0), '$')));
@@ -634,6 +666,7 @@ void ArgumentList::set(unsigned int i, Argument* argument) {
 		list.push_back(argument);
 	}	
 }
+
 std::string ArgumentList::toString(bool upper) const {
 	std::stringstream ss;
 	ss << "(";
@@ -644,7 +677,9 @@ std::string ArgumentList::toString(bool upper) const {
 	ss << ")";
 	return ss.str();
 }
+
 bool ArgumentList::isNull() const { return false; }
+
 ArgumentList::~ArgumentList() {
 	for( std::vector<Argument*>::iterator it = list.begin(); it != list.end(); it ++ ) {
 		delete (*it);
@@ -652,6 +687,7 @@ ArgumentList::~ArgumentList() {
 	list.clear();
 }
 
+
 IfcUtil::ArgumentType TokenArgument::type() const {
 	if (TokenFunc::isInt(token)) {
 		return IfcUtil::Argument_INT;
@@ -690,6 +726,8 @@ TokenArgument::operator std::vector<std::string>() const { throw IfcException("A
 TokenArgument::operator std::vector<boost::dynamic_bitset<> >() const { throw IfcException("Argument is not a list of binaries"); }
 TokenArgument::operator IfcUtil::IfcBaseClass*() const { return token.first->file->entityById(TokenFunc::asInt(token)); }
 TokenArgument::operator IfcEntityList::ptr() const { throw IfcException("Argument is not a list of entity instances"); }
+TokenArgument::operator std::vector< std::vector<int> >() const { throw IfcException("Argument is not a list of list of ints"); }
+TokenArgument::operator std::vector< std::vector<double> >() const { throw IfcException("Argument is not a list of list of floats"); }
 TokenArgument::operator IfcEntityListList::ptr() const { throw IfcException("Argument is not a list of list of entity instances"); }
 unsigned int TokenArgument::size() const { return 1; }
 Argument* TokenArgument::operator [] (unsigned int i) const { throw IfcException("Argument is not a list of attributes"); }
@@ -719,8 +757,9 @@ EntityArgument::operator std::vector<int>() const { throw IfcException("Argument
 EntityArgument::operator std::vector<std::string>() const { throw IfcException("Argument is not a list of strings"); }
 EntityArgument::operator std::vector<boost::dynamic_bitset<> >() const { throw IfcException("Argument is not a list of binaries"); }
 EntityArgument::operator IfcUtil::IfcBaseClass*() const { return entity; }
-//EntityArgument::operator IfcUtil::IfcAbstractSelect::ptr() const { return entity; }
 EntityArgument::operator IfcEntityList::ptr() const { throw IfcException("Argument is not a list of entity instances"); }
+EntityArgument::operator std::vector< std::vector<int> >() const { throw IfcException("Argument is not a list of list of ints"); }
+EntityArgument::operator std::vector< std::vector<double> >() const { throw IfcException("Argument is not a list of list of floats"); }
 EntityArgument::operator IfcEntityListList::ptr() const { throw IfcException("Argument is not a list of list of entity instances"); }
 unsigned int EntityArgument::size() const { return 1; }
 Argument* EntityArgument::operator [] (unsigned int i) const { throw IfcException("Argument is not a list of arguments"); }

src/ifcparse/IfcParse.h

@@ -149,6 +149,8 @@ namespace IfcParse {
 		operator std::vector<boost::dynamic_bitset<> >() const;
 		operator IfcEntityList::ptr() const;
 
+		operator std::vector< std::vector<int> >() const;
+		operator std::vector< std::vector<double> >() const;
 		operator IfcEntityListList::ptr() const;
 
 		bool isNull() const;
@@ -184,6 +186,9 @@ namespace IfcParse {
 		operator std::vector<std::string>() const;
 		operator std::vector<boost::dynamic_bitset<> >() const;
 		operator IfcEntityList::ptr() const;
+		
+		operator std::vector< std::vector<int> >() const;
+		operator std::vector< std::vector<double> >() const;
 		operator IfcEntityListList::ptr() const;
 
 		bool isNull() const;
@@ -218,6 +223,8 @@ namespace IfcParse {
 		operator std::vector<boost::dynamic_bitset<> >() const;
 		operator IfcEntityList::ptr() const;
 
+		operator std::vector< std::vector<int> >() const;
+		operator std::vector< std::vector<double> >() const;
 		operator IfcEntityListList::ptr() const;
 
 		bool isNull() const;

src/ifcparse/IfcUtil.h

@@ -61,7 +61,9 @@ namespace IfcUtil {
 		Argument_AGGREGATE_OF_STRING,
 		Argument_AGGREGATE_OF_BINARY, 
 		Argument_AGGREGATE_OF_ENTITY_INSTANCE,
-
+	
+		Argument_AGGREGATE_OF_AGGREGATE_OF_INT,
+		Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE,
 		Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE, 
 
 		Argument_UNKNOWN
@@ -276,9 +278,10 @@ public:
 	virtual operator std::vector<boost::dynamic_bitset<> >() const = 0;
 	virtual operator IfcEntityList::ptr() const = 0;
 
+	virtual operator std::vector< std::vector<int> >() const = 0;
+	virtual operator std::vector< std::vector<double> >() const = 0;
 	virtual operator IfcEntityListList::ptr() const = 0;
 
-
 	virtual bool isNull() const = 0;
 	virtual unsigned int size() const = 0;
 

src/ifcparse/IfcWritableEntity.h

@@ -63,22 +63,28 @@ namespace IfcWrite {
 		unsigned int id();
 		IfcWritableEntity* isWritable();
 
-		void setArgument(int i);
 		void setArgument(int i, Argument* a);
+
+		void setArgument(int i);
 		void setArgumentDerived(int i);
-		void setArgument(int i,bool v);
+		
 		void setArgument(int i,int v);
-		void setArgument(int i,int v, const char* c);
+		void setArgument(int i,bool v);
+		void setArgument(int i,double v);
 		void setArgument(int i,const std::string& v);
 		void setArgument(int i,const boost::dynamic_bitset<>& v);
-		void setArgument(int i,double v);
+		void setArgument(int i,int v, const char* c);
 		void setArgument(int i,IfcUtil::IfcBaseClass* v);
-		void setArgument(int i,IfcEntityList::ptr v);
+
-		void setArgument(int i,IfcEntityListList::ptr v);
+		void setArgument(int i,const std::vector<int>& v);
 		void setArgument(int i,const std::vector<double>& v);
 		void setArgument(int i,const std::vector<std::string>& v);
-		void setArgument(int i,const std::vector<int>& v);
 		void setArgument(int i,const std::vector< boost::dynamic_bitset<> >& v);
+		void setArgument(int i,IfcEntityList::ptr v);
+		
+		void setArgument(int i,const std::vector< std::vector<int> >& v);
+		void setArgument(int i,const std::vector< std::vector<double> >& v);
+		void setArgument(int i,IfcEntityListList::ptr v);		
 	};
 
 }

src/ifcparse/IfcWrite.cpp

@@ -198,6 +198,14 @@ void IfcWritableEntity::setArgument(int i, Argument* a) {
 		}
 		this->setArgument(i, mapped_instances); }
 		break;
+	case IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_INT: {
+		std::vector< std::vector<int> > attr_value = *a;
+		this->setArgument(i, attr_value); }
+		break;
+	case IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_DOUBLE: {
+		std::vector< std::vector<double> > attr_value = *a;
+		this->setArgument(i, attr_value); }
+		break;
 	case IfcUtil::Argument_AGGREGATE_OF_AGGREGATE_OF_ENTITY_INSTANCE: {
 		IfcEntityListList::ptr instances = *a;
 		IfcEntityListList::ptr mapped_instances(new IfcEntityListList);
@@ -263,12 +271,18 @@ void IfcWritableEntity::setArgument(int i,IfcEntityListList::ptr v){
 void IfcWritableEntity::setArgument(int i,const std::vector<double>& v){
 	_setArgument(i, v);
 }
+void IfcWritableEntity::setArgument(int i,const std::vector< std::vector<double> >& v){
+	_setArgument(i, v);
+}
 void IfcWritableEntity::setArgument(int i,const std::vector<std::string>& v){
 	_setArgument(i, v);
 }
 void IfcWritableEntity::setArgument(int i,const std::vector<int>& v){
 	_setArgument(i, v);
 }
+void IfcWritableEntity::setArgument(int i,const std::vector< std::vector<int> >& v){
+	_setArgument(i, v);
+}
 void IfcWritableEntity::setArgument(int i,const std::vector< boost::dynamic_bitset<> >& v){
 	_setArgument(i, v);
 }
@@ -284,6 +298,8 @@ public:
 	int operator()(const boost::dynamic_bitset<>& i) const { return -1; }
 	int operator()(const std::vector<int>& i) const { return i.size(); }
 	int operator()(const std::vector<double>& i) const { return i.size(); }
+	int operator()(const std::vector< std::vector<int> >& i) const { return i.size(); }
+	int operator()(const std::vector< std::vector<double> >& i) const { return i.size(); }
 	int operator()(const std::vector<std::string>& i) const { return i.size(); }
 	int operator()(const std::vector< boost::dynamic_bitset<> >& i) const { return i.size(); }
 	int operator()(const IfcWriteArgument::EnumerationReference& i) const { return -1; }
@@ -389,6 +405,8 @@ public:
 		}
 		data << ")";
 	}
+	void operator()(const std::vector< std::vector<int> >& i);
+	void operator()(const std::vector< std::vector<double> >& i);
 	void operator()(const IfcEntityListList::ptr& i) { 
 		data << "(";
 		for (IfcEntityListList::outer_it outer_it = i->begin(); outer_it != i->end(); ++outer_it) {
@@ -444,7 +462,22 @@ void StringBuilderVisitor::operator()(const std::vector<int>& i) { serialize(i);
 void StringBuilderVisitor::operator()(const std::vector<double>& i) { serialize(i); }
 void StringBuilderVisitor::operator()(const std::vector<std::string>& i) { serialize(i); }
 void StringBuilderVisitor::operator()(const std::vector< boost::dynamic_bitset<> >& i) { serialize(i); }
-	
+void StringBuilderVisitor::operator()(const std::vector< std::vector<int> >& i) {
+	data << "(";
+	for (std::vector< std::vector<int> >::const_iterator it = i.begin(); it != i.end(); ++it) {
+		if (it != i.begin()) data << ",";
+		serialize(*it);
+	}
+	data << ")";
+}
+void StringBuilderVisitor::operator()(const std::vector< std::vector<double> >& i) {
+	data << "(";
+	for (std::vector< std::vector<double> >::const_iterator it = i.begin(); it != i.end(); ++it) {
+		if (it != i.begin()) data << ",";
+		serialize(*it);
+	}
+	data << ")";
+}
 
 IfcWriteArgument::operator int() const { return as<int>(); }
 IfcWriteArgument::operator bool() const { return as<bool>(); }
@@ -462,6 +495,8 @@ IfcWriteArgument::operator std::vector<int>() const { return as<std::vector<int>
 IfcWriteArgument::operator std::vector<std::string>() const { return as<std::vector<std::string > >(); }
 IfcWriteArgument::operator std::vector< boost::dynamic_bitset<> >() const { return as< std::vector< boost::dynamic_bitset<> > >(); }
 IfcWriteArgument::operator IfcEntityList::ptr() const { return as<IfcEntityList::ptr>(); }
+IfcWriteArgument::operator std::vector< std::vector<int> >() const { return as<std::vector< std::vector<int> > >(); }
+IfcWriteArgument::operator std::vector< std::vector<double> >() const { return as<std::vector< std::vector<double> > >(); }
 IfcWriteArgument::operator IfcEntityListList::ptr() const { throw; }
 bool IfcWriteArgument::isNull() const { return type() == IfcUtil::Argument_NULL; }
 Argument* IfcWriteArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }

src/ifcparse/IfcWrite.h

@@ -98,6 +98,10 @@ namespace IfcWrite {
 			IfcEntityList::ptr,
 
 			// AGGREGATES OF AGGREGATES:
+			// An aggregate of an aggregate of ints. E.g. ((1, 2), (3))
+			std::vector< std::vector<int> >,
+			// An aggregate of an aggregate of floats. E.g. ((1., 2.3), (4.))
+			std::vector< std::vector<double> >,
 			// An aggregate of an aggregate of entities. E.g. ((#1, #2), (#3))
 			IfcEntityListList::ptr
 		> container;
@@ -127,6 +131,8 @@ namespace IfcWrite {
 		operator std::vector<boost::dynamic_bitset<> >() const;
 		operator IfcEntityList::ptr() const;
 
+		operator std::vector< std::vector<int> >() const;
+		operator std::vector< std::vector<double> >() const;
 		operator IfcEntityListList::ptr() const;
 
 		bool isNull() const;