First stab at a new express parser to have some more luck with Ifc4

cmake/CMakeLists.txt

@@ -125,6 +125,7 @@ INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES} ${OCC_INCLUDE_DIR} ${OPENCOLLADA_INCL
 
 ADD_LIBRARY(IfcParse STATIC 
   ../src/ifcparse/Ifc2x3.cpp
+  ../src/ifcparse/Ifc4.cpp
   ../src/ifcparse/IfcUtil.cpp
   ../src/ifcparse/IfcParse.cpp
   ../src/ifcparse/IfcCharacterDecoder.cpp

src/examples/IfcOpenHouse.cpp

@@ -31,7 +31,12 @@
 
 #include <Standard_Version.hxx>
 
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
 #include "../ifcparse/Ifc2x3.h"
+#endif
+
 #include "../ifcparse/IfcUtil.h"
 #include "../ifcparse/IfcHierarchyHelper.h"
 #include "../ifcgeom/IfcGeom.h"
@@ -53,7 +58,7 @@ int main(int argc, char** argv) {
 	file.filename("IfcOpenHouse.ifc");
 
 	// Start by adding a wall to the file, initially leaving most attributes blank.
-	Ifc2x3::IfcWallStandardCase* south_wall = new Ifc2x3::IfcWallStandardCase(
+	IfcSchema::IfcWallStandardCase* south_wall = new IfcSchema::IfcWallStandardCase(
 		guid(), 			// GlobalId
 		0, 					// OwnerHistory
 		S("South wall"), 	// Name
@@ -62,6 +67,9 @@ int main(int argc, char** argv) {
 		0, 					// ObjectPlacement
 		0, 					// Representation
 		null				// Tag
+#ifdef USE_IFC4
+		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
+#endif
 	);
 	file.addBuildingProduct(south_wall);
 
@@ -70,13 +78,13 @@ int main(int argc, char** argv) {
 
 	// Lateron changing the name of the IfcProject can be done by obtaining a reference to the 
 	// project, which has been created automatically.
-	file.getSingle<Ifc2x3::IfcProject>()->setName("IfcOpenHouse");
+	file.getSingle<IfcSchema::IfcProject>()->setName("IfcOpenHouse");
 
 	// An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
-	south_wall->setOwnerHistory(file.getSingle<Ifc2x3::IfcOwnerHistory>());
+	south_wall->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
 
 	// The wall will be shaped as a box, with the dimensions specified in millimeters.
-	Ifc2x3::IfcProductDefinitionShape* south_wall_shape = file.addBox(10000, 360, 3000);
+	IfcSchema::IfcProductDefinitionShape* south_wall_shape = file.addBox(10000, 360, 3000);
 
 	// The shape has to be assigned to the representation of the wall and is placed at the origin
 	// of the coordinate system.
@@ -84,59 +92,67 @@ int main(int argc, char** argv) {
 	south_wall->setObjectPlacement(file.addLocalPlacement());
 
 	// A pale white colour is assigned to the wall.
-	Ifc2x3::IfcPresentationStyleAssignment* wall_colour = file.setSurfaceColour(
+	IfcSchema::IfcPresentationStyleAssignment* wall_colour = file.setSurfaceColour(
 		south_wall->Representation(), 0.75, 0.73, 0.68);
 
 	// Now create a footing for the wall to rest on.
-	Ifc2x3::IfcFooting* footing = new Ifc2x3::IfcFooting(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcFooting* footing = new IfcSchema::IfcFooting(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		S("Footing"), null, null, 0, 0, null, Ifc2x3::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);
+		S("Footing"), null, null, 0, 0, null, IfcSchema::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);
 
 	file.addBuildingProduct(footing);
 
 	// The footing will span the entire floor plan of our building. The IfcRepresentationContext is
 	// something that has been created automatically as well, but representations could have been 
 	// assigned to a specific context, for example to add a two dimensional plan representation as well.
-	footing->setRepresentation(file.addBox(10100, 5460, 2000, 0, 0, 0, file.getSingle<Ifc2x3::IfcRepresentationContext>()));
+	footing->setRepresentation(file.addBox(10100, 5460, 2000, 0, 0, 0, file.getSingle<IfcSchema::IfcRepresentationContext>()));
 	footing->setObjectPlacement(file.addLocalPlacement(0, 2500, -2000));
 	// The footing will have a dark gray colour
-	Ifc2x3::IfcPresentationStyleAssignment* footing_colour = file.setSurfaceColour(footing->Representation(), 0.26, 0.22, 0.18);
+	IfcSchema::IfcPresentationStyleAssignment* footing_colour = file.setSurfaceColour(footing->Representation(), 0.26, 0.22, 0.18);
 
 	// IFC has two ways to apply boolean operations to geometry. IfcBooleanResults are commonly used 
 	// to clip geometry to a surface, for example to a slanted roof. For openings that are filled 
 	// with another element, for example a door or a window, an IfcOpeningElement is used instead.
 	// An opening element is created with rectangular geometry
-	Ifc2x3::IfcOpeningElement* west_opening = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcOpeningElement* west_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
 		null, null, null, file.addLocalPlacement(-2500, 0, 400),
-		file.addBox(6000, 3630, 1600, 0, 0, 0, file.getSingle<Ifc2x3::IfcRepresentationContext>()), null);
+		file.addBox(6000, 3630, 1600, 0, 0, 0, file.getSingle<IfcSchema::IfcRepresentationContext>()), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
+#endif
+	);
 	file.AddEntity(west_opening);
 
 	// Relate the opening element to the wall.
-	Ifc2x3::IfcRelVoidsElement* void_element = new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcRelVoidsElement* void_element = new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
 		null, null, south_wall, west_opening);
 	file.AddEntity(void_element);
 
 	// Now create an additional opening
-	Ifc2x3::IfcOpeningElement* south_opening = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcOpeningElement* south_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
 		null, null, null, file.addLocalPlacement(3000, 0, 400),
-		file.addBox(1860, 3000, 1600, 0, 0, 0, file.getSingle<Ifc2x3::IfcRepresentationContext>()), null);
+		file.addBox(1860, 3000, 1600, 0, 0, 0, file.getSingle<IfcSchema::IfcRepresentationContext>()), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
+#endif
+	);
 	file.AddEntity(south_opening);
-	file.AddEntity(new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, south_wall, south_opening));
+	file.AddEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, south_wall, south_opening));
 	
 	// Create a roof element
-	Ifc2x3::IfcRoof* south_roof = new Ifc2x3::IfcRoof(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), S("South roof"), null, null, 
+	IfcSchema::IfcRoof* south_roof = new IfcSchema::IfcRoof(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("South roof"), null, null, 
-		0, 0, null, Ifc2x3::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
+		0, 0, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
 	
 	// The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
 	south_roof->setRepresentation(file.addBox(10200, 360, sqrt(2.0*2900*2900), 0, file.addPlacement3d(0, 0, 0, 0, 1, 0),
-		file.addTriplet<Ifc2x3::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)), file.getSingle<Ifc2x3::IfcRepresentationContext>()));
+		file.addTriplet<IfcSchema::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)), file.getSingle<IfcSchema::IfcRepresentationContext>()));
 	south_roof->setObjectPlacement(file.addLocalPlacement(0, -400, 2700));
 	file.addBuildingProduct(south_roof);
 
 	// The same roof geometry is re-used on the north side of the roof, by inverting the X-axis of
 	// the local placement the roof is rotated 180 degrees around the Z-axis
-	Ifc2x3::IfcRoof* north_roof = new Ifc2x3::IfcRoof(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), S("North roof"),
+	IfcSchema::IfcRoof* north_roof = new IfcSchema::IfcRoof(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("North roof"),
-		null, null, 0, 0, null, Ifc2x3::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
+		null, null, 0, 0, null, IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
-	north_roof->setOwnerHistory(file.getSingle<Ifc2x3::IfcOwnerHistory>());
+	north_roof->setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
 	north_roof->setRepresentation(south_roof->Representation());
 	north_roof->setObjectPlacement(file.addLocalPlacement(0, 5400, 2700, 0, 0, 1, -1, 0, 0));
 	file.addBuildingProduct(north_roof);
@@ -146,12 +162,20 @@ int main(int argc, char** argv) {
 	file.setSurfaceColour(south_roof->Representation(), 0.24, 0.08, 0.04);
 
 	// Copy the south wall to the north
-	file.addBuildingProduct(new Ifc2x3::IfcWallStandardCase(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), S("North wall"),
+	file.addBuildingProduct(new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), S("North wall"),
-		null, null, file.addLocalPlacement(0, 5000, 0), south_wall->Representation(), null));
+		null, null, file.addLocalPlacement(0, 5000, 0), south_wall->Representation(), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
+#endif	
+	));
 
 	// Now create a wall on the east of the building, again starting with just a box shape
-	Ifc2x3::IfcWallStandardCase* east_wall = new Ifc2x3::IfcWallStandardCase(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcWallStandardCase* east_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		S("East wall"), null, null, file.addLocalPlacement(4820, 2500, 0, 0, 0, 1, 0, 1, 0), file.addBox(5000, 360, 6000), null);
+		S("East wall"), null, null, file.addLocalPlacement(4820, 2500, 0, 0, 0, 1, 0, 1, 0), file.addBox(5000, 360, 6000), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
+#endif	
+	);
 	file.addBuildingProduct(east_wall);
 
 	// The east wall geometry is clipped using two IfcHalfSpaceSolids, created from an 
@@ -162,8 +186,12 @@ int main(int argc, char** argv) {
 	file.setSurfaceColour(east_wall->Representation(), wall_colour);
 
 	// The east wall is copied to the west location of the house
-	Ifc2x3::IfcWallStandardCase* west_wall = new Ifc2x3::IfcWallStandardCase(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcWallStandardCase* west_wall = new IfcSchema::IfcWallStandardCase(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		S("West wall"), null, null, file.addLocalPlacement(-4820, 2500, 0, 0, 0, 1, 0, -1, 0), east_wall->Representation(), null);
+		S("West wall"), null, null, file.addLocalPlacement(-4820, 2500, 0, 0, 0, 1, 0, -1, 0), east_wall->Representation(), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD
+#endif	
+	);
 	file.addBuildingProduct(west_wall);
 
 	// The west wall is assigned an opening element we created for the south wall, opening elements are
@@ -171,10 +199,14 @@ int main(int argc, char** argv) {
 	// wall will not feature this opening.
 	// NB: an Opening Element can only be used to create a single void within a single Element, as per:
 	// http://www.buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcproductextension/lexical/ifcfeatureelementsubtraction.htm
-	Ifc2x3::IfcOpeningElement* west_opening_copy = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcOpeningElement* west_opening_copy = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, west_opening->ObjectPlacement(), west_opening->Representation(), null);
+		null, null, null, west_opening->ObjectPlacement(), west_opening->Representation(), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
+#endif	
+	);
 	file.AddEntity(west_opening_copy);
-	file.AddEntity(new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, west_wall, west_opening_copy));
+	file.AddEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, west_wall, west_opening_copy));
 	
 	// Up until now we have only used simple extrusions for the creation of the geometry. For the 
 	// ground mesh of the IfcSite we will use a Nurbs surface created in Open Cascade. The surface 
@@ -182,12 +214,12 @@ int main(int argc, char** argv) {
 	TopoDS_Shape shape;
 	createGroundShape(shape);
 	IfcEntities geometrical_entities(new IfcEntityList());
-	Ifc2x3::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(shape, 100., geometrical_entities);
+	IfcSchema::IfcProductDefinitionShape* ground_representation = IfcGeom::tesselate(shape, 100., geometrical_entities);
-	file.getSingle<Ifc2x3::IfcSite>()->setRepresentation(ground_representation);
+	file.getSingle<IfcSchema::IfcSite>()->setRepresentation(ground_representation);
 	file.AddEntities(geometrical_entities);
-	Ifc2x3::IfcShapeRepresentation::list ground_reps = geometrical_entities->as<Ifc2x3::IfcShapeRepresentation>();
+	IfcSchema::IfcShapeRepresentation::list ground_reps = geometrical_entities->as<IfcSchema::IfcShapeRepresentation>();
-	for (Ifc2x3::IfcShapeRepresentation::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
+	for (IfcSchema::IfcShapeRepresentation::it it = ground_reps->begin(); it != ground_reps->end(); ++it) {
-		(*it)->setContextOfItems(file.getSingle<Ifc2x3::IfcRepresentationContext>());
+		(*it)->setContextOfItems(file.getSingle<IfcSchema::IfcRepresentationContext>());
 	}
 	file.setSurfaceColour(ground_representation, 0.15, 0.25, 0.05);
 
@@ -198,18 +230,52 @@ int main(int argc, char** argv) {
 	// Some BIM authoring applications, such as Autodesk Revit, ignore the geometrical representation
 	// by and large and construct native walls using the layer thickness and reference line offset 
 	// provided here.
-	Ifc2x3::IfcMaterial* material = new Ifc2x3::IfcMaterial("Brick");
+#ifdef USE_IFC4
-	Ifc2x3::IfcMaterialLayer* layer = new Ifc2x3::IfcMaterialLayer(material, 360, null);
+	IfcSchema::IfcMaterial* material = new IfcSchema::IfcMaterial("Brick", null, null);
-	Ifc2x3::IfcMaterialLayer::list layers (new IfcTemplatedEntityList<Ifc2x3::IfcMaterialLayer>());
+#else
+	IfcSchema::IfcMaterial* material = new IfcSchema::IfcMaterial("Brick");
+#endif
+	IfcSchema::IfcMaterialLayer* layer = new IfcSchema::IfcMaterialLayer(
+		material, 
+		360, 
+		null
+#ifdef USE_IFC4
+		, null
+		, null 
+		, null
+		, null
+#endif
+	);
+	IfcSchema::IfcMaterialLayer::list layers (new IfcTemplatedEntityList<IfcSchema::IfcMaterialLayer>());
 	layers->push(layer);
-	Ifc2x3::IfcMaterialLayerSet* layer_set = new Ifc2x3::IfcMaterialLayerSet(layers, S("Wall"));
+	IfcSchema::IfcMaterialLayerSet* layer_set = new IfcSchema::IfcMaterialLayerSet(
-	Ifc2x3::IfcMaterialLayerSetUsage* layer_usage = new Ifc2x3::IfcMaterialLayerSetUsage(layer_set,
+		layers, 
-		Ifc2x3::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS2,
+		S("Wall")
-		Ifc2x3::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE, -180);
+#ifdef USE_IFC4
+		, null
+#endif
+	);
+	IfcSchema::IfcMaterialLayerSetUsage* layer_usage = new IfcSchema::IfcMaterialLayerSetUsage(
+		layer_set,
+		IfcSchema::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS2,
+		IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE,
+		-180
+#ifdef USE_IFC4
+		, null
+#endif
+	);
 
-	Ifc2x3::IfcRelAssociatesMaterial* associates_material = new Ifc2x3::IfcRelAssociatesMaterial(guid(),
+	IfcSchema::IfcRelAssociatesMaterial* associates_material = new IfcSchema::IfcRelAssociatesMaterial(
-		file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null,
+		guid(),
-		file.EntitiesByType<Ifc2x3::IfcWallStandardCase>()->as<Ifc2x3::IfcRoot>(), layer_usage);
+		file.getSingle<IfcSchema::IfcOwnerHistory>(), 
+		null, 
+		null,
+#ifdef USE_IFC4
+		file.EntitiesByType<IfcSchema::IfcWallStandardCase>()->generalize(),
+#else
+		file.EntitiesByType<IfcSchema::IfcWallStandardCase>()->as<IfcSchema::IfcRoot>(),
+#endif
+		layer_usage);
 
 	file.AddEntity(material);
 	file.AddEntity(layer);
@@ -226,30 +292,44 @@ int main(int argc, char** argv) {
 	stair_points.push_back(XY(500, 200));
 	stair_points.push_back(XY(500, 400));
 	stair_points.push_back(XY(  0, 400));
-	Ifc2x3::IfcStairFlight* stair = new Ifc2x3::IfcStairFlight(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcStairFlight* stair = new IfcSchema::IfcStairFlight(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
 		null, null, null, file.addLocalPlacement(5050, 1000, 0, 0, 1, 0, 1, 0, 0),
-		file.addExtrudedPolyline(stair_points, 1200), null, 2, 2, 0.2, 0.25);
+		file.addExtrudedPolyline(stair_points, 1200), null, 2, 2, 0.2, 0.25
+#ifdef USE_IFC4
+		, IfcSchema::IfcStairFlightTypeEnum::IfcStairFlightType_STRAIGHT
+#endif
+	);
 
 	file.addBuildingProduct(stair);
 	file.setSurfaceColour(stair->Representation(), footing_colour);
 
-	Ifc2x3::IfcOpeningElement* door_opening = new Ifc2x3::IfcOpeningElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+	IfcSchema::IfcOpeningElement* door_opening = new IfcSchema::IfcOpeningElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-		null, null, null, file.addLocalPlacement(5000-180, 2500-900, 0), file.addBox(1000, 1000, 2200), null);
+		null, null, null, file.addLocalPlacement(5000-180, 2500-900, 0), file.addBox(1000, 1000, 2200), null
+#ifdef USE_IFC4
+		, IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING
+#endif	
+	);
 	file.AddEntity(door_opening);
-	file.AddEntity(new Ifc2x3::IfcRelVoidsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, east_wall, door_opening));
+	file.AddEntity(new IfcSchema::IfcRelVoidsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, east_wall, door_opening));
 
 	// A single shape representation can contain multiple representiation items. This way a product
 	// can be a composition of multiple solids. The following door will be composed of four boxes
 	// which constitute the door and its frame.
-	Ifc2x3::IfcDoor* door = new Ifc2x3::IfcDoor(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, null,
+	IfcSchema::IfcDoor* door = new IfcSchema::IfcDoor(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, null,
-		file.addLocalPlacement(4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000);
+		file.addLocalPlacement(4800, 1600, 0, 0, 0, 1, 0, 1, 0), 0, null, 2200, 1000
+#ifdef USE_IFC4
+		, IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR
+		, IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT
+		, null
+#endif
+	);
 	door->setRepresentation(file.addBox(80, 80, 2120, 0, file.addPlacement3d(460, 0, 0)));
-	Ifc2x3::IfcRepresentation::list door_representations = door->Representation()->Representations();
+	IfcSchema::IfcRepresentation::list door_representations = door->Representation()->Representations();
-	Ifc2x3::IfcShapeRepresentation* door_body = 0;
+	IfcSchema::IfcShapeRepresentation* door_body = 0;
-	for (Ifc2x3::IfcRepresentation::it i = door_representations->begin(); i != door_representations->end(); ++i) {
+	for (IfcSchema::IfcRepresentation::it i = door_representations->begin(); i != door_representations->end(); ++i) {
-		Ifc2x3::IfcRepresentation* rep = *i;
+		IfcSchema::IfcRepresentation* rep = *i;
-		if (rep->is(Ifc2x3::Type::IfcShapeRepresentation) && rep->RepresentationIdentifier() == "Body") {
+		if (rep->is(IfcSchema::Type::IfcShapeRepresentation) && rep->RepresentationIdentifier() == "Body") {
-			door_body = (Ifc2x3::IfcShapeRepresentation*) rep;
+			door_body = (IfcSchema::IfcShapeRepresentation*) rep;
 		}
 	}
 	file.addBox(door_body,  80, 80, 2120, 0, file.addPlacement3d(-460, 0,   0));
@@ -257,7 +337,7 @@ int main(int argc, char** argv) {
 	file.addBox(door_body, 860, 30, 2120);
 	file.addBuildingProduct(door);
 	file.setSurfaceColour(door->Representation(), 0.9, 0.9, 0.9);
-	file.AddEntity(new Ifc2x3::IfcRelFillsElement(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null, null, door_opening, door));
+	file.AddEntity(new IfcSchema::IfcRelFillsElement(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null, null, door_opening, door));
 
 	// Surface styles are assigned to representation items, hence there is no real limitation to
 	// assign different colours within the same representation. However, some viewers have 
@@ -270,15 +350,15 @@ int main(int argc, char** argv) {
 	// Therefore the OverallWidth and OverallHeight of the window attributes will need to
 	// match the bounding box of the representation. Furthermore, the window placement needs
 	// to align with the lowerleft corner of the constituent parts.
-	Ifc2x3::IfcProductDefinitionShape::list frame_representations (new IfcTemplatedEntityList<Ifc2x3::IfcProductDefinitionShape>());
+	IfcSchema::IfcProductDefinitionShape::list frame_representations (new IfcTemplatedEntityList<IfcSchema::IfcProductDefinitionShape>());
 	frame_representations->push(file.addBox(1860, 90, 90));
 	frame_representations->push(*frame_representations->begin()); // Add a reference to the shape created above
 	frame_representations->push(file.addBox(90, 90, 1420));
 	frame_representations->push(*(frame_representations->end()-1)); // Add a reference to the shape created above
 
 	// The beams all have the same surface style assigned
-	Ifc2x3::IfcPresentationStyleAssignment* frame_style = 0;
+	IfcSchema::IfcPresentationStyleAssignment* frame_style = 0;
-	for (Ifc2x3::IfcProductDefinitionShape::it i = frame_representations->begin(); i != frame_representations->end(); ++i) {
+	for (IfcSchema::IfcProductDefinitionShape::it i = frame_representations->begin(); i != frame_representations->end(); ++i) {
 		if (frame_style) {
 			file.setSurfaceColour(*i, frame_style);
 		} else {
@@ -288,49 +368,63 @@ int main(int argc, char** argv) {
 
 	// This window will be placed at five locations within the building. A list of placements is 
 	// created and is iterated over to create all window instances.
-	Ifc2x3::IfcLocalPlacement::list window_placements (new IfcTemplatedEntityList<Ifc2x3::IfcLocalPlacement>());
+	IfcSchema::IfcLocalPlacement::list window_placements (new IfcTemplatedEntityList<IfcSchema::IfcLocalPlacement>());
 	window_placements->push(file.addLocalPlacement(2*-1770-430-930,   -45, 400));
 	window_placements->push(file.addLocalPlacement(  -1770-430-930,   -45, 400));
 	window_placements->push(file.addLocalPlacement(       -430-930,   -45, 400));
 	window_placements->push(file.addLocalPlacement(       3000-930,   -45, 400));
 	window_placements->push(file.addLocalPlacement(      -4855+45, 885-930, 400, 0, 0, 1, 0, 1, 0));
 	
-	for (Ifc2x3::IfcLocalPlacement::it it = window_placements->begin(); it != window_placements->end(); ++it) {
+	for (IfcSchema::IfcLocalPlacement::it it = window_placements->begin(); it != window_placements->end(); ++it) {
 		
 		// Create the window at the current location
-		Ifc2x3::IfcLocalPlacement* place = *it;
+		IfcSchema::IfcLocalPlacement* place = *it;
-		Ifc2x3::IfcWindow* window = new Ifc2x3::IfcWindow(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		IfcSchema::IfcWindow* window = new IfcSchema::IfcWindow(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-			null, null, null, place, 0, null, 1600, 1860);
+			null, null, null, place, 0, null, 1600, 1860
+#ifdef USE_IFC4
+			, IfcSchema::IfcWindowTypeEnum::IfcWindowType_WINDOW
+			, IfcSchema::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioning_SINGLE_PANEL
+			, null
+#endif
+	);
 		file.addBuildingProduct(window);		
 
 		// Initalize a list of parts for the window to be composed of
-		Ifc2x3::IfcObjectDefinition::list window_parts(new IfcTemplatedEntityList<Ifc2x3::IfcObjectDefinition>());
+		IfcSchema::IfcObjectDefinition::list window_parts(new IfcTemplatedEntityList<IfcSchema::IfcObjectDefinition>());
 
 		// The placements for the beams are not shared accross the different windows because every
 		// beam is placed relative to its parent window entity.
-		Ifc2x3::IfcLocalPlacement::list frame_placements (new IfcTemplatedEntityList<Ifc2x3::IfcLocalPlacement>());
+		IfcSchema::IfcLocalPlacement::list frame_placements (new IfcTemplatedEntityList<IfcSchema::IfcLocalPlacement>());
 		frame_placements->push(file.addLocalPlacement( 930,45));
 		frame_placements->push(file.addLocalPlacement( 930, 45, 1510));
 		frame_placements->push(file.addLocalPlacement(-885+930, 45,  90));
 		frame_placements->push(file.addLocalPlacement( 885+930, 45,  90));
 		
 		// Now iterate over the placements and representations of the beam and add them to list of parts
-		Ifc2x3::IfcLocalPlacement::it frame_placement;
+		IfcSchema::IfcLocalPlacement::it frame_placement;
-		Ifc2x3::IfcProductDefinitionShape::it frame_representation;
+		IfcSchema::IfcProductDefinitionShape::it frame_representation;
 		for (frame_placement = frame_placements->begin(), frame_representation = frame_representations->begin();
 			frame_placement != frame_placements->end() && frame_representation != frame_representations->end();
 			++frame_placement, ++frame_representation)
 		{
-			Ifc2x3::IfcMember* frame_part = new Ifc2x3::IfcMember(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+			IfcSchema::IfcMember* frame_part = new IfcSchema::IfcMember(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
-				null, null, null, *frame_placement, *frame_representation, null);
+				null, null, null, *frame_placement, *frame_representation, null
+#ifdef USE_IFC4
+				, IfcSchema::IfcMemberTypeEnum::IfcMemberType_MULLION
+#endif
+			);
 			file.AddEntity(frame_part);
 			window_parts->push(frame_part);
 			file.relatePlacements(window, frame_part);
 		}
 
 		// Add the glass plate to the list of parts
-		Ifc2x3::IfcPlate* glass_part = new Ifc2x3::IfcPlate(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(), null,
+		IfcSchema::IfcPlate* glass_part = new IfcSchema::IfcPlate(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(), null,
-			null, null, file.addLocalPlacement(930, 45, 90), file.addBox(1680, 10, 1420), null);
+			null, null, file.addLocalPlacement(930, 45, 90), file.addBox(1680, 10, 1420), null
+#ifdef USE_IFC4
+			, IfcSchema::IfcPlateTypeEnum::IfcPlateType_SHEET
+#endif
+		);
 		file.AddEntity(glass_part);
 		window_parts->push(glass_part);
 		file.relatePlacements(window, glass_part);
@@ -338,7 +432,7 @@ int main(int argc, char** argv) {
 		
 		// Now create a decomposition relation between the window and the parts. Most viewers and authoring
 		// tools will consider the window a single entity that can be selected as a whole.
-		Ifc2x3::IfcRelDecomposes* decomposition = new Ifc2x3::IfcRelAggregates(guid(), file.getSingle<Ifc2x3::IfcOwnerHistory>(),
+		IfcSchema::IfcRelDecomposes* decomposition = new IfcSchema::IfcRelAggregates(guid(), file.getSingle<IfcSchema::IfcOwnerHistory>(),
 			null, null, window, window_parts);
 		file.AddEntity(decomposition);		
 	}

src/examples/IfcParseExamples.cpp

@@ -19,7 +19,7 @@
 
 #include "../ifcparse/IfcParse.h"
 
-using namespace Ifc2x3;
+using namespace IfcSchema;
 
 int main(int argc, char** argv) {
 

src/ifcexpressparser/IfcExpressParser.py

@@ -1,659 +0,0 @@
-header = """
-/********************************************************************************
- *                                                                              *
- * This file is part of IfcOpenShell.                                           *
- *                                                                              *
- * IfcOpenShell is free software: you can redistribute it and/or modify         *
- * it under the terms of the Lesser GNU General Public License as published by  *
- * the Free Software Foundation, either version 3.0 of the License, or          *
- * (at your option) any later version.                                          *
- *                                                                              *
- * IfcOpenShell is distributed in the hope that it will be useful,              *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
- * Lesser GNU General Public License for more details.                          *
- *                                                                              *
- * You should have received a copy of the Lesser GNU General Public License     *
- * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
- *                                                                              *
- ********************************************************************************/
- """.strip()
-
-###############################################################################
-#                                                                             #
-# This file can be used to generate C++ code from Express schema files. The   #
-# generated code works alongside the IfcOpenShell IfcParse library. This      #
-# script has only been tested on IFC2X3_TC1.exp and will most probably not    #
-# work on any other schemas.                                                  #
-#                                                                             #
-# Note this script uses funcparserlib, which is available at:                 #
-# http://code.google.com/p/funcparserlib/                                     #
-# The script only works with revision 30f7ee896bc9 because it uses the some() #
-# parser and is incompatible with other changes as well.                      #
-#                                                                             #
-###############################################################################
-
-import os, sys
-import IfcDocumentation
-
-filename = sys.argv[1]
-
-#
-# A class to split the Express schema files into seperate tokens
-#
-class Tokenizer(object):
-    comment = ['(*','*)']
-    termchars = ',;()=[]:'
-    def __init__(self, fn):
-        if hasattr(fn,'read'): object.__setattr__(self,'f',fn)
-        else: object.__setattr__(self,'f',open(fn,'rb'))
-    def __getattr__(self, name):
-        return getattr(self.f, name)
-    def __setattr__(self, name, value):
-        setattr(self.f, name, value)
-    def __iter__(self): return self
-    def next(self):
-        def get():
-            buffer = ''
-            in_comment = False
-            in_string = False
-            offset = self.tell()
-            while True:
-                c = self.read(2)
-                if len(c) < 2: raise StopIteration
-                if c in Tokenizer.comment:
-                    in_comment = c == Tokenizer.comment[0]
-                    continue
-                if in_string and c == "''":
-                    buffer += "'"
-                    continue
-                self.seek(-1,1)
-                if not in_string and c[0].isspace():
-                    if ( len(buffer) ): return buffer
-                    else:
-                        offset = self.tell()
-                        continue
-                if not in_comment:
-                    if len(buffer) and (c[0] in Tokenizer.termchars or buffer[-1] in Tokenizer.termchars):
-                        self.seek(-1,1)
-                        return buffer
-                    buffer += c[0]
-        return get()
-
-#
-# Some global variables to keep track of variable names
-#
-express_to_cpp = {
-    'BOOLEAN':'bool',
-    'LOGICAL':'bool',
-    'INTEGER':'int',
-    'REAL':'double',
-    'NUMBER':'double',
-    'STRING':'std::string'
-}
-schema_version = ''
-enumerations = set()
-selections = set()
-entity_names = set()
-simple_types = {}
-selectable_simple_types = set()
-argument_count = {}
-parent_relations = {}
-argument_names_and_types = {}
-entity_map = {}
-
-#
-# Since inherited arguments of Express entities are placed in sequence before the 
-# non-inherited ones, we need to keep track of how many inherited arguments exist
-#
-def argument_start(c):
-    if c not in parent_relations: return 0
-    i = 0
-    while True:
-        c = parent_relations[c]
-        i += argument_count[c] if c in argument_count else 0
-        if not (c in parent_relations): break
-    return i
-    
-def parent_arguments(c):
-    if c not in parent_relations: return []
-    l = []
-    while True:
-        c = parent_relations[c]
-        i += argument_count[c] if c in argument_count else 0
-        if not (c in parent_relations): break
-    return []
-
-#
-# Every constructor also initializes their parent class members, hence they
-# need be stored as well.
-#    
-def parent_arguments(c):
-    if c not in parent_relations: return []
-    l = []
-    while True:
-        c = parent_relations[c]
-        i += argument_count[c] if c in argument_count else 0
-        if not (c in parent_relations): break
-    return []
-
-#
-# Several classes to generate code from Express types and entities
-#
-class ArrayType:
-    def __init__(self,l): 
-        self.type = express_to_cpp.get(l[3],l[3])
-        self.upper = l[2]
-        self.lower = l[1]
-    def is_select_list(self): return self.type in selections
-    def __str__(self):
-        if self.type in entity_names:
-            return "SHARED_PTR< IfcTemplatedEntityList< %s > >"%self.type
-        elif self.type in selections:
-            return "SHARED_PTR< IfcTemplatedEntityList< IfcAbstractSelect > >"
-        else:
-            return "std::vector< %(type)s > /*[%(lower)s:%(upper)s]*/"%self.__dict__
-    def is_shared_ptr(self): return self.type in entity_names or self.type in selections
-    def type_enum(self):
-        if self.type in simple_types:
-            t = simple_types[self.type].type_enum()
-        else:
-            t = self.type
-        if t in entity_names or t == "Argument_ENTITY":
-            return "Argument_ENTITY_LIST"
-        elif t in selections:
-            return "Argument_ENTITY_LIST"
-        elif t == "int":
-            return "Argument_VECTOR_INT"
-        elif t == "double" or t == "Argument_DOUBLE":
-            return "Argument_VECTOR_DOUBLE"
-        elif t == "std::string" or t == "Argument_STRING":
-            return "Argument_VECTOR_STRING"
-        elif isinstance(t, BinaryType):
-            return "Argument_UNKNOWN"
-        else:
-            assert False, t
-        
-class ScalarType:
-    def __init__(self,l): self.type = express_to_cpp.get(l,l)
-    def __str__(self): return self.type
-    def is_select_list(self): return False
-    def type_enum(self):
-        if self.type in simple_types:
-            return simple_types[self.type].type_enum()
-        elif self.type in entity_names:
-            return "Argument_ENTITY"
-        else:
-            return { "bool":"Argument_BOOL","int":"Argument_INT","double":"Argument_DOUBLE","std::string":"Argument_STRING"}[self.type]
-class EnumType:
-    def __init__(self,l):
-        self.v = [(x,'%s_%s'%('%(fancy_name)s',x)) for x in l]
-        self.maxlen = max([len(v) for v in self.v])
-    def __str__(self): 
-        if generator_mode == 'HEADER':
-            return "enum {%s}"%", ".join([v2 for v1,v2 in self.v])
-        elif generator_mode == 'SOURCE_TO':
-            return '{ "%s" }'%'","'.join([v1 for v1,v2 in self.v])
-        elif generator_mode == 'SOURCE_FROM':
-            return "".join(['    if(s=="%s"%s) return ::%s::%s::%s;\n'%(v1.upper()," "*(self.maxlen-len(v1)),schema_version,"%(name)s",v2) for v1,v2 in self.v])
-    def is_select_list(self): return False
-    def __len__(self): return len(self.v)
-    def type_enum(self):
-        return "Argument_ENUMERATION"
-class SelectType:
-    def __init__(self,l): 
-        for x in l: 
-            if x in simple_types: selectable_simple_types.add(x)
-    def __str__(self): return "IfcSchemaEntity"
-    def is_select_list(self): return False
-    def type_enum(self): return "Argument_ENTITY"
-class BinaryType:
-    def __init__(self,l): self.l = int(l)
-    def __str__(self): return "char[%s]"%self.l
-    def is_select_list(self): return False
-    def type_enum(self): raise NotImplementedError()
-class InverseType:
-    def __init__(self,l):
-        self.name, self.type, self.reference = l
-    def type_enum(self): return "Argument_ENTITY"
-    def is_select_list(self): return False
-class Typedef:
-    def __init__(self,l):
-        self.name,self.type=l[1:3]
-        self.fancy_name = self.name[:-4] if self.name.endswith("Enum") else self.name
-        if isinstance(self.type,EnumType): 
-            enumerations.add(self.name)
-            self.len = len(self.type)
-        elif isinstance(self.type,SelectType): selections.add(self.name)
-        simple_types[self.name] = self
-        comment = IfcDocumentation.description(self.name)
-        self.comment = comment+"\n" if comment else ''
-    def __str__(self):
-        global generator_mode
-        if generator_mode == 'HEADER' and isinstance(self.type,EnumType):
-            return ("namespace %(name)s {\n%(comment)stypedef %(type)s %(name)s;\nconst char* ToString(%(name)s v);\n%(name)s FromString(const std::string& s);\n}"%self.__dict__)%self.__dict__
-        elif generator_mode == 'HEADER':
-            return "%stypedef %s %s;"%(self.comment,self.type,self.name)
-        elif generator_mode == 'SOURCE' and isinstance(self.type,EnumType):
-            generator_mode = 'SOURCE_TO'
-            s =  "const char* %(name)s::ToString(%(name)s v) {\n    if ( v < 0 || v >= %(len)d ) throw IfcException(\"Unable to find find keyword in schema\");\n    const char* names[] = %(type)s;\n    return names[v];\n}\n"%self.__dict__
-            generator_mode = 'SOURCE_FROM'
-            s += ("%(name)s::%(name)s %(name)s::FromString(const std::string& s) {\n%(type)s    throw IfcException(\"Unable to find find keyword in schema\");\n}"%self.__dict__)%self.__dict__
-            generator_mode = 'SOURCE'
-            return s
-    def type_enum(self):
-        return self.type.type_enum()
-class Argument(object):
-    def __init__(self,l):
-        self.name, self.optional, self.type = l
-    def is_enum(self): return str(self.type) in enumerations
-    def type_str(self):
-        if self.type.is_select_list():
-            # This is extremely hackish indeed
-            return "optional< IfcEntities >" if self.optional else "IfcEntities"
-        elif str(self.type) in entity_names:
-            return "%(type)s*"%self.__dict__
-        else:
-            t = "%(type)s::%(type)s"%self.__dict__ if self.is_enum() else self.type
-            return "optional< %s >"%t if self.optional else t
-class ArgumentList:
-    def __init__(self,l):
-        self.l = [Argument(a) for a in l]
-        self.argstart = 0
-    def __len__(self): return len(self.l)
-    def __str__(self):
-        s = ""
-        argv = self.argstart
-        for a in self.l:
-            class_name = indent = comment = optional_comment = ""
-            is_array = isinstance(a.type,ArrayType) and a.type.is_shared_ptr()
-            return_type = str(a.type)
-            if generator_mode == 'SOURCE':
-                class_name = "%(class_name)s::"
-                if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)):
-                    function_body = " { throw; /* Not implemented argument*/ }"
-                elif isinstance(a.type,ArrayType) and str(a.type.type) in entity_names:
-                    function_body = " { RETURN_AS_LIST(%s,%d) }"%(a.type.type,argv)
-                elif isinstance(a.type,ArrayType) and str(a.type.type) in selections:
-                    function_body = " { RETURN_AS_LIST(IfcAbstractSelect,%d) }"%(argv)
-                elif return_type in entity_names:
-                    function_body = " { return reinterpret_pointer_cast<IfcBaseClass,%s>(*entity->getArgument(%d)); }"%(return_type,argv)
-                elif return_type in enumerations:
-                    function_body = " { return %s::FromString(*entity->getArgument(%d)); }"%(return_type,argv)
-                else:
-                    function_body = " { return *entity->getArgument(%d); }"%argv
-                function_body2 = " { return !entity->getArgument(%d)->isNull(); }"%argv
-                if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)):
-                    function_body3 = " { if ( ! entity->isWritable() ) { throw; } }"
-                elif return_type in enumerations:
-                    function_body3 = " { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%d,v%s,%s::ToString(v)); }"%(argv,"->generalize()" if is_array else "",return_type)
-                else:
-                    function_body3 = " { if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%d,v%s); }"%(argv,"->generalize()" if is_array else "")
-            else:
-                indent = "    "
-                function_body = function_body2 = function_body3 = ";"
-                comment = IfcDocumentation.description((self.class_name,a.name))
-                comment = comment+"\n" if comment else ''
-                comment = comment.replace("///","%s///"%indent)
-                optional_comment = "%s/// Whether the optional attribute %s is defined for this %s\n"%(indent,a.name,self.class_name)
-            if a.optional: s += "\n%s%sbool %shas%s()%s"%(optional_comment,indent,class_name,a.name,function_body2)
-            if ( str(a.type) in enumerations ):
-                return_type = "%(type)s::%(type)s"%a.__dict__
-            elif ( str(a.type) in entity_names ):
-                return_type = "%(type)s*"%a.__dict__
-            s += "\n%s%s%s %s%s()%s"%(comment,indent,return_type,class_name,a.name,function_body)
-            s += "\n%svoid %sset%s(%s v)%s"%(indent,class_name,a.name,return_type,function_body3)
-            argv += 1
-
-        if generator_mode == 'HEADER':
-            s += "\n virtual unsigned int getArgumentCount() const { return %(n_arguments)d; }" % dict(class_name=self.class_name, n_arguments=len(self.l) + argument_start(self.class_name))
-
-            s += "\n virtual ArgumentType getArgumentType(unsigned int i) const {"
-            if len(self.l):
-                s += " switch (i) {"
-                for i, a in enumerate(self.l):
-                    s += "case %d: " % (i + argument_start(self.class_name))
-                    s += "return %s; " % a.type.type_enum()
-                s += "}"
-            if self.parent_class is not None:
-                s += " return %s::getArgumentType(i); }" % self.parent_class
-            else:
-                s += " throw IfcException(\"argument out of range\"); }"
-
-            s += "\n virtual const char* getArgumentName(unsigned int i) const {"
-            if len(self.l):
-                s += " switch (i) {"
-                for i, a in enumerate(self.l):
-                    s += "case %d: " % (i + argument_start(self.class_name))
-                    s += "return \"%s\"; " % a.name
-                s += "}"
-            if self.parent_class is not None:
-                s += " return %s::getArgumentName(i); }" % self.parent_class
-            else:
-                s += " throw IfcException(\"argument out of range\"); }"
-
-            s += "\n virtual ArgumentPtr getArgument(unsigned int i) const { return entity->getArgument(i); }"
-        return s
-class InverseList:
-    def __init__(self,l):
-        self.l = l
-    def __str__(self):
-        if self.l is None: return ""
-        s = ""
-        for i in self.l:
-            if generator_mode == 'HEADER':
-                s += "\n    SHARED_PTR< IfcTemplatedEntityList< %s > > %s(); // INVERSE %s::%s"%(i.type.type,i.name,i.type.type,i.reference)
-            elif generator_mode == 'SOURCE':
-                s += "\n%s::list %s::%s() { RETURN_INVERSE(%s) }"%(i.type.type,"%(class_name)s",i.name,i.type.type)
-        return s
-class Classdef:
-    def __init__(self,l):
-        self.class_name, self.parent_class, self.arguments, derive, self.inverse = l
-        self.arguments.class_name = self.class_name
-        self.arguments.parent_class = self.parent_class
-        entity_names.add(self.class_name)
-        parent_relations[self.class_name] = self.parent_class
-        argument_count[self.class_name] = len(self.arguments)
-        entity_map[self.class_name] = self
-        # For derived attributes only a reference is kepts to overridden attributes in parent classes
-        self.derive = [x[0].split('.')[-1] for x in derive[1] if x[0].startswith("SELF\\")] if derive else []
-    def list_constructor_args(self):
-        s = entity_map[self.parent_class].list_constructor_args() if self.parent_class else []
-        i = len(s) + 1
-        s += [(a.type_str(),b+i,a.name) for a,b in zip(self.arguments.l,range(len(self.arguments)))]
-        return s
-    def get_constructor_args(self):
-        return ["%s v%d_%s"%x for x in self.list_constructor_args() if x[2] not in self.get_derived()]        
-    def get_constructor_implementation(self):
-        s = entity_map[self.parent_class].get_constructor_implementation() if self.parent_class else []
-        i = len(s) + 1
-        b = 0
-        for a in self.arguments.l:
-            is_enumeration = str(a.type) in enumerations
-            # boost::optional is not used for pointer types, because they are set to NULL using 0
-            use_boost_optional = a.optional and str(a.type) not in entity_names
-            # boost::optional types need to be dereferenced before passing to the writable entity
-            dereference = "*" if use_boost_optional else ""
-            generalize = "->generalize()" if (isinstance(a.type,ArrayType) and a.type.is_shared_ptr() and not a.type.is_select_list()) else ""
-            if isinstance(a.type,BinaryType) or (isinstance(a.type,ArrayType) and isinstance(a.type.type,BinaryType)):
-                continue
-            if is_enumeration:
-                impl = "e->setArgument(%d,%sv%d_%s,%s::ToString(%sv%d_%s))"%(b+i-1,dereference,b+i,a.name,str(a.type),dereference,b+i,a.name)
-            else:
-                impl = "e->setArgument(%d,(%sv%d_%s)%s)"%(b+i-1,dereference,b+i,a.name,generalize)            
-            if use_boost_optional:
-                s.append(["if (v%d_%s) { %s; } else { e->setArgument(%d); } "%(b+i,a.name,impl,b+i-1),a.name,i-1])
-            else: s.append([impl,a.name,i-1])
-            b += 1
-        return s
-    def get_derived(self):
-        s = entity_map[self.parent_class].get_derived() if self.parent_class else []
-        return s + self.derive
-    def __str__(self):
-        self.constructor_args_list = self.get_constructor_args()
-        self.constructor_args = ", ".join(self.constructor_args_list)
-        if generator_mode == 'HEADER':            
-            comment = IfcDocumentation.description(self.class_name)
-            comment = comment+"\n" if comment else ''
-            return "%sclass %s : public %s {\npublic:%s%s%s\n};" % (comment,self.class_name,
-                "IfcBaseEntity" if self.parent_class is None else self.parent_class,
-                self.arguments,
-                self.inverse,
-                ("\n    bool is(Type::Enum v) const;"+
-                "\n    Type::Enum type() const;"+
-                "\n    static Type::Enum Class();"+
-                "\n    %(class_name)s (IfcAbstractEntityPtr e = IfcAbstractEntityPtr());"+
-               ("\n    %(class_name)s (%(constructor_args)s);" if len(self.constructor_args_list) else "")+
-                "\n    typedef %(class_name)s* ptr;"+
-                "\n    typedef SHARED_PTR< IfcTemplatedEntityList< %(class_name)s > > list;"+
-                "\n    typedef IfcTemplatedEntityList< %(class_name)s >::it it;")%self.__dict__
-            )
-        elif generator_mode == 'SOURCE':
-            self.arguments.argstart = argument_start(self.class_name)
-            self.constructor_implementation = "; ".join([x[0] if x[1] not in self.get_derived() else "e->setArgumentDerived(%d)"%x[2] for x in self.get_constructor_implementation()])
-            return (("\n// Function implementations for %(class_name)s"+str(self.arguments)+str(self.inverse)+
-            ("\nbool %(class_name)s::is(Type::Enum v) const { return v == Type::%(class_name)s; }" if self.parent_class is None else
-            "\nbool %(class_name)s::is(Type::Enum v) const { return v == Type::%(class_name)s || %(parent_class)s::is(v); }")+
-            "\nType::Enum %(class_name)s::type() const { return Type::%(class_name)s; }"+
-            "\nType::Enum %(class_name)s::Class() { return Type::%(class_name)s; }"+
-            "\n%(class_name)s::%(class_name)s(IfcAbstractEntityPtr e) { if (!is(Type::%(class_name)s)) throw IfcException(\"Unable to find find keyword in schema\"); entity = e; }"+
-            ("\n%(class_name)s::%(class_name)s(%(constructor_args)s) { IfcWritableEntity* e = new IfcWritableEntity(Class()); %(constructor_implementation)s; entity = e; EntityBuffer::Add(this); }"  if len(self.constructor_args_list) else "")
-            )%self.__dict__)%self.__dict__
-
-
-from funcparserlib.parser import a, skip, many, maybe, some
-
-#
-# Lambda functions to map combinator output to classes
-# 
-array_type = lambda t: ArrayType(t)
-scalar_type = lambda t: ScalarType(t)
-enum_type = lambda t: EnumType(t)
-select_type = lambda t: SelectType(t)
-binary_type = lambda t: BinaryType(t)
-inverse_type = lambda t: InverseType(t)
-format_type = lambda t: Typedef(t)
-argument_list = lambda t: ArgumentList(t)
-inverse_list = lambda t: InverseList(t)
-format_options = lambda t: [t[0]]+t[1]
-
-#
-# The actual grammar definition
-#
-s = some(lambda t: not t in ['UNIQUE','WHERE','END_ENTITY','END_TYPE','INVERSE','DERIVE'])
-x = lambda s:skip(a(s))
-list_or_array = a('ARRAY') | a('LIST') | a('SET')
-binary = x('BINARY')+x('(') + s + x(')') >> binary_type
-array = list_or_array + x('[') + s + x(':') + s + x(']') + x('OF') + skip(maybe(a('UNIQUE'))) + (binary|s) >> array_type
-options = x('(') + s + many(x(',')+s) + x(')') >> format_options
-enum = x('ENUMERATION') + x('OF') + options >> enum_type
-select = x('SELECT') + options >> select_type
-single = s + skip(maybe(x('(')+s+x(')')) + maybe(a('FIXED'))) >> scalar_type
-type_type = array | enum | select | single
-type_start = a('TYPE') + s + x('=') + type_type + x(';')
-type_end = a('END_TYPE') + x(';')
-
-to_end = many(some(lambda t: t != ';'))
-clause = s + x(':') + to_end + x(';')
-where = a('WHERE') + many(clause)
-
-type = type_start + maybe(where) + type_end >> format_type
-
-subtype = x('SUBTYPE') + x('OF') + x('(') + s + x(')')
-supertype = maybe(x('ABSTRACT')) + x('SUPERTYPE') + x('OF') + x('(') + x('ONEOF') + options + x(')')
-entity_start = x('ENTITY') + s + skip(maybe(supertype)) + maybe(subtype) + x(';')
-entity_end = x('END_ENTITY') + x(';')
-key_value = s + x(':') + maybe(a('OPTIONAL')) + (array|binary|single) + x(';')
-arguments = many(key_value) >> argument_list
-unique_value = s + x(':') + s + many(a(',')+s) + a(';')
-unique = skip(a('UNIQUE') + many(unique_value))
-inverse_def = s + x(':') + (array|single) + x('FOR') + s + x(';') >> inverse_type
-inverse = maybe(x('INVERSE') + many( inverse_def )) >> inverse_list
-derive = a('DERIVE') + many(clause)
-
-entity = entity_start + arguments + skip(maybe(unique)) + maybe(derive) + inverse + skip(maybe(where)) + entity_end >> Classdef
-
-schema = skip(a('SCHEMA')) + s + x(';')
-
-express = schema + many(type) + many(entity)
-schema_version,types,entities = express.parse(list(Tokenizer(filename)))
-schema_version = schema_version.capitalize()
-
-#
-# Writing of the three generated files starts here
-#
-h_file = open("%s.h"%schema_version,'w')
-enumh_file = open("%senum.h"%schema_version,'w')
-cpp_file = open("%s.cpp"%schema_version,'w')
-
-header += """
-
-/********************************************************************************
- *                                                                              *
- * This file has been generated from %s. Do not make modifications  *
- * but instead modify the python script that has been used to generate this.    *
- *                                                                              *
- ********************************************************************************/
- """%filename
-
-generator_mode = 'HEADER'
- 
-print >>h_file, header
-print >>enumh_file, header
-print >>cpp_file, header
-print >>h_file, """#ifndef %(schema_upper)s_H
-#define %(schema_upper)s_H
-
-#include <string>
-#include <vector>
-#include <map>
-
-#include <boost/optional.hpp>
-
-#include "../ifcparse/IfcUtil.h"
-#include "../ifcparse/IfcException.h"
-#include "../ifcparse/%(schema)senum.h"
-
-using namespace IfcUtil;
-using IfcParse::IfcException;
-using boost::optional;
-
-#define RETURN_INVERSE(T) \\
-    IfcEntities e = entity->getInverse(T::Class()); \\
-    SHARED_PTR< IfcTemplatedEntityList<T> > l ( new IfcTemplatedEntityList<T>() ); \\
-    for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \\
-        l->push(reinterpret_pointer_cast<IfcBaseClass,T>(*it)); \\
-    } \\
-    return l;
-
-#define RETURN_AS_SINGLE(T,a) \\
-    return reinterpret_pointer_cast<IfcBaseClass,T>(*entity->getArgument(a));
-
-#define RETURN_AS_LIST(T,a)  \\
-    IfcEntities e = *entity->getArgument(a);  \\
-    SHARED_PTR< IfcTemplatedEntityList<T> > l ( new IfcTemplatedEntityList<T>() );  \\
-    for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) {  \\
-        l->push(reinterpret_pointer_cast<IfcBaseClass,T>(*it)); \\
-    }  \\
-    return l;
-
-namespace %(schema)s {
-"""%{'schema_upper':schema_version.upper(),'schema':schema_version}
-
-simple_enumerations = sorted(selectable_simple_types)
-entity_enumerations = sorted(entity_names)
-all_enumerations = simple_enumerations + entity_enumerations
-
-print >>enumh_file, """#ifndef IFC2X3ENUM_H
-#define IFC2X3ENUM_H
-
-namespace Ifc2x3 {
-
-namespace Type {
-    typedef enum {
-        %(enum)s
-    } Enum;
-    Enum Parent(Enum v);
-    Enum FromString(const std::string& s);
-    std::string ToString(Enum v);
-    bool IsSimple(Enum v);
-}
-
-}
-
-#endif
-"""%{'schema_upper':schema_version.upper(),'schema':schema_version,'enum':", ".join(all_enumerations + ["ALL"])}
-
-defined_types = set(express_to_cpp.values())
-deferred_types = []
-
-for t in [T for T in types if not (isinstance(T.type,EnumType) or isinstance(T.type,SelectType))]:
-    if isinstance(t.type,ScalarType) and str(t.type) not in defined_types:
-        deferred_types.append(t)
-    else:
-        print >>h_file, t
-for t in [T for T in types if isinstance(T.type,SelectType)]:
-    print >>h_file, t
-for t in deferred_types:
-    print >>h_file, t
-for t in [T for T in types if isinstance(T.type,EnumType)]:
-    print >>h_file, t
-    
-print >>h_file, "// Forward definitions"
-print >>h_file, "class %s;\n"%"; class ".join([e.class_name for e in entities])
-
-defined_classes = set()
-while True:
-    classes = [c for c in entities if c.class_name not in defined_classes]
-    if not len(classes): break
-    for c in classes:
-        if c.parent_class is None or c.parent_class in defined_classes:
-            defined_classes.add(c.class_name)
-            print >>h_file, c
-
-print >>h_file, "void InitStringMap();"
-print >>h_file, "IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = 0);"
-
-print >>h_file, "}\n\n#endif"
-
-generator_mode = 'SOURCE'
-
-print >>cpp_file, """#include "%(schema)s.h"
-#include "IfcException.h"
-#include "IfcWrite.h"
-#include "IfcWritableEntity.h"
-
-using namespace %(schema)s;
-using namespace IfcParse;
-using namespace IfcWrite;
-
-IfcSchemaEntity %(schema)s::SchemaEntity(IfcAbstractEntityPtr e) {
-    switch(e->type()){"""%{'schema':schema_version}
-
-for e in simple_enumerations:
-    print >>cpp_file, "        case Type::%s: return new IfcEntitySelect(e); break;"%e
-for e in entity_enumerations:
-    print >>cpp_file, "        case Type::%s: return new %s(e); break;"%(e,e)
-print >>cpp_file, "        default: throw IfcException(\"Unable to find find keyword in schema\"); break; "
-print >>cpp_file, "    }\n}"
-print >>cpp_file
-print >>cpp_file, "std::string Type::ToString(Enum v) {"
-print >>cpp_file, "    if (v < 0 || v >= %d) throw IfcException(\"Unable to find find keyword in schema\");"%len(all_enumerations)
-print >>cpp_file, '    const char* names[] = { "%s" };'%'","'.join(all_enumerations)
-print >>cpp_file, '    return names[v];'
-print >>cpp_file, "}"
-print >>cpp_file
-#print >>cpp_file, "Type::Enum Type::FromStringOld(const std::string& s){"
-#elseif = "if"
-#maxlen = max([len(e) for e in all_enumerations])
-#for e in all_enumerations:
-#    print >>cpp_file, '    %s(s=="%s"%s) { return %s; }'%(elseif,e.upper()," "*(maxlen-len(e)),e)
-#print >>cpp_file, "    throw;"
-#print >>cpp_file, "}"
-print >>cpp_file, "std::map<std::string,Type::Enum> string_map;"
-print >>cpp_file, "void Ifc2x3::InitStringMap() {"
-maxlen = max([len(e) for e in all_enumerations])
-for e in all_enumerations:
-    print >>cpp_file, '    string_map["%s"%s] = Type::%s;'%(e.upper()," "*(maxlen-len(e)),e)
-print >>cpp_file, """}
-Type::Enum Type::FromString(const std::string& s) {
-    std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
-    if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
-    else return it->second;
-}"""
-
-print >>cpp_file, "Type::Enum Type::Parent(Enum v){"
-print >>cpp_file, "    if (v < 0 || v >= %d) return (Enum)-1;"%len(all_enumerations)
-for e in entity_enumerations:
-    if e not in parent_relations or parent_relations[e] is None: continue
-    print >>cpp_file, '    if(v==%s%s) { return %s; }'%(e," "*(maxlen-len(e)),parent_relations[e])
-print >>cpp_file, "    return (Enum)-1;"
-print >>cpp_file, "}"
-
-print >>cpp_file, "bool Type::IsSimple(Enum v){"
-print >>cpp_file, "    return v == Type::%s;"%" || v == Type::".join(simple_enumerations)
-print >>cpp_file, "}"
-
-for t in [T for T in types if isinstance(T.type,EnumType)]:
-    print >>cpp_file, t
-for e in entities: print >>cpp_file, e,

src/ifcexpressparser/README.txt

@@ -0,0 +1,9 @@
+This folder contains Python code to generate C++ type information based on an
+Express schema. In particular is has only been tested using recent version of
+the IFC schema and will most likely fail on any other Express schema.
+
+The code can be invoked in the following way and results in two header files
+and a single implementation file named according to the schema name in the 
+Express file. A python 3 interpreter with the pyparsing library is required.
+
+$ python bootstrap.py express.bnf > express_parser.py && python express_parser.py IFC2X3_TC1.exp

src/ifcexpressparser/bootstrap.py

@@ -0,0 +1,182 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import sys
+import string
+from pyparsing import *
+
+class Expression:
+    def __init__(self, contents):
+        self.contents = contents[0]
+    def __repr__(self):
+        if self.op is None: return repr(self.contents)
+        c = [isinstance(c,str) and c or str(c) for c in self.contents]
+        if "%s" in self.op: return self.op % (" ".join(c))
+        else: return "(%s)" % (" %s "%self.op).join(c)
+    def __iter__(self):
+        return self.contents.__iter__()
+
+class Union(Expression):
+    op = "|"
+
+class Concat(Expression):
+    op = "+"
+
+class Optional(Expression):
+    op = "Optional(%s)"
+
+class Repeated(Expression):
+    op = "ZeroOrMore(%s)"
+
+class Term(Expression):
+    op = None
+
+class Keyword:
+    def __init__(self, contents):
+        self.contents = contents[0]
+    def __repr__(self):
+        return self.contents
+
+class Terminal:
+    def __init__(self, contents):
+        self.contents = contents[0]
+    def __repr__(self):
+        s = self.contents
+        is_keyword = len(s) >= 4 and s[0::len(s)-1] == '""' and \
+            all(c in alphanums+"_" for c in s[1:-1])
+        ty = "CaselessKeyword" if is_keyword else "CaselessLiteral"
+        return "%s(%s)" % (ty, s)
+
+
+LPAREN = Suppress("(")
+RPAREN = Suppress(")")
+LBRACK = Suppress("[")
+RBRACK = Suppress("]")
+LBRACE = Suppress("{")
+RBRACE = Suppress("}")
+EQUALS = Suppress("=")
+VBAR   = Suppress("|")
+PERIOD = Suppress(".")
+HASH   = Suppress("#")
+
+identifier = Word(alphanums+"_")
+keyword    = Word(alphanums+"_").setParseAction(Keyword)
+expression = Forward()
+optional   = Group(LBRACK + expression + RBRACK).setParseAction(Optional)
+repeated   = Group(LBRACE + expression + RBRACE).setParseAction(Repeated)
+terminal   = quotedString.setParseAction(Terminal)
+term       = (keyword | terminal | optional | repeated | (LPAREN + expression + RPAREN)).setParseAction(Term)
+concat     = Group(term + OneOrMore(term)).setParseAction(Concat)
+factor     = concat | term
+union      = Group(factor + OneOrMore(VBAR + factor)).setParseAction(Union)
+rule       = identifier + EQUALS + expression + PERIOD
+
+expression << (union | factor)
+
+grammar = OneOrMore(Group(rule))
+grammar.ignore(HASH + restOfLine)
+
+express = grammar.parseFile(sys.argv[1])
+
+def find_keywords(expr, li = None):
+    if li is None: li = []
+    if isinstance(expr, Term):
+        expr = expr.contents
+    if isinstance(expr, Keyword):
+        li.append(repr(expr))
+        return li
+    elif isinstance(expr, Expression):
+        for term in expr:
+            find_keywords(term, li)
+    return set(li)
+
+actions = {
+    'type_decl'                 : "lambda t: TypeDeclaration(t)",
+    'entity_decl'               : "lambda t: EntityDeclaration(t)",
+    'underlying_type'           : "lambda t: UnderlyingType(t)",
+    'enumeration_type'          : "lambda t: EnumerationType(t)",
+    'aggregation_types'         : "lambda t: AggregationType(t)",
+    'general_aggregation_types' : "lambda t: AggregationType(t)",
+    'select_type'               : "lambda t: SelectType(t)",
+    'binary_type'               : "lambda t: BinaryType(t)",
+    'subtype_declaration'       : "lambda t: SubtypeExpression(t)",
+    'derive_clause'             : "lambda t: AttributeList('derive', t)",
+    'derived_attr'              : "lambda t: DerivedAttribute(t)",
+    'inverse_clause'            : "lambda t: AttributeList('inverse', t)",
+    'inverse_attr'              : "lambda t: InverseAttribute(t)",
+    'bound_spec'                : "lambda t: BoundSpecification(t)",
+    'explicit_attr'             : "lambda t: ExplicitAttribute(t)",
+}
+
+to_emit = set(id for id, expr in express)
+emitted = set()
+to_combine = set(["simple_id"])
+to_ignore = set(["where_clause", "supertype_constraint", "unique_clause"])
+statements = []
+
+while True:
+    emitted_in_loop = set()
+    for id, expr in express:
+        kws = find_keywords(expr)
+        found = [k in emitted for k in kws]
+        if id in to_emit and all(found):
+            emitted_in_loop.add(id)
+            emitted.add(id)
+            stmt = "(%s)" % expr
+            if id in to_combine:
+                stmt = "originalTextFor(Combine%s)" % stmt
+            if id in actions:
+                stmt = "%s.setParseAction(%s)" % (stmt, actions[id])
+            statements.append("%s = %s" % (id, stmt))
+    to_emit -= emitted_in_loop
+    if not emitted_in_loop: break
+
+for id in to_emit:
+    action = ".setParseAction(%s)" % actions[id] if id in actions else ""
+    statements.append("%s = Forward()%s" % (id, action))
+
+for id in to_emit:
+    expr = [e for k, e in express if k == id][0]
+    stmt = "(%s)" % expr
+    if id in to_combine:
+        stmt = "Suppress%s" % stmt
+    statements.append("%s << %s" % (id, stmt))
+
+print ("""import sys
+from pyparsing import *
+from nodes import *
+
+%s
+
+import schema
+import mapping
+
+import header
+import enum_header
+import implementation
+
+syntax.ignore(Regex(r"\((?:\*(?:[^*]*\*+)+?\))"))
+ast = syntax.parseFile(sys.argv[1])
+schema = schema.Schema(ast)
+mapping = mapping.Mapping(schema)
+
+header.Header(mapping).emit()
+enum_header.EnumHeader(mapping).emit()
+implementation.Implementation(mapping).emit()
+"""%('\n'.join(statements)))

src/ifcexpressparser/documentation.py

@@ -36,7 +36,7 @@ name_to_oid = {}
 oid_to_desc = {}
 oid_to_name = {}
 oid_to_pid = {}
-regices = list(zip([re.compile(s,re.M) for s in [r'<[\w\n=" \-/\.;_\t:%#,\?\(\)]+>',r'(\n[\t ]*){2,}',r'^[\t ]+','^']],['','\n\n','  ','/// ']))
+regices = list(zip([re.compile(s,re.M) for s in [r'<[\w\n=" \-/\.;_\t:%#,\?\(\)]+>',r'(\n[\t ]*){2,}',r'^[\t ]+']],['','\n\n','  ']))
 
 definition_files = ['DocEntity.csv', 'DocEnumeration.csv', 'DocDefined.csv', 'DocSelect.csv']
 for fn in definition_files:
@@ -49,23 +49,22 @@ for fn in definition_files:
 with open('DocEntityAttributes.csv') as f:
     for pid, x, oid in csv.reader(f, delimiter=';', quotechar='"'):
         oid_to_pid[oid] = pid
-        
+
 with open('DocAttribute.csv') as f:
     for oid, name, desc in csv.reader(f, delimiter=';', quotechar='"'):
         pid = oid_to_pid[oid]
         pname = oid_to_name[pid]
         name_to_oid[(pname, name)] = oid
         oid_to_desc[oid] = desc
-        
+
 def description(item):
     global name_to_oid, oid_to_desc, oid_to_name, oid_to_pid
     oid = name_to_oid.get(item,0)
-    desc = oid_to_desc.get(oid,None)
+    desc = oid_to_desc.get(oid, None)
     if desc:
         for a,b in entitydefs.items(): desc = desc.replace("&%s;"%a,b)
         desc = desc.replace("\r","")
-        for r,s in regices[:-1]: desc = r.sub(s,desc)
+        for r,s in regices: desc = r.sub(s,desc)
         desc = desc.strip()
-        r,s = regices[-1]
+        return desc.split("\n")
-        desc = r.sub(s,desc)
+    else: return []
-    return desc

src/ifcexpressparser/enum_header.py

@@ -0,0 +1,39 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import templates
+
+class EnumHeader:
+    def __init__(self, mapping):
+        selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(mapping.schema.types.keys()))
+        enumerable_types = selectable_simple_types + [name for name, type in mapping.schema.entities.items()]
+        
+        self.str = templates.enum_header % {
+            'schema_name_upper' : mapping.schema.name.upper(),
+            'schema_name'       : mapping.schema.name.capitalize(),
+            'types'             : ', '.join(enumerable_types)
+        }
+        
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%senum.h'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()

src/ifcexpressparser/express.bnf

@@ -0,0 +1,344 @@
+# Taken from http://sourceforge.net/p/exp-engine/expresso/ci/master/tree/docs/iso-10303-11--2004.bnf
+
+ABS = "abs" .
+ABSTRACT = "abstract" .
+ACOS = "acos" .
+AGGREGATE = "aggregate" .
+ALIAS = "alias" .
+AND = "and" .
+ANDOR = "andor" .
+ARRAY = "array" .
+AS = "as" .
+ASIN = "asin" .
+ATAN = "atan" .
+BAG = "bag" .
+BASED_ON = "based_on" .
+BEGIN = "begin" .
+BINARY = "binary" .
+BLENGTH = "blength" .
+BOOLEAN = "boolean" .
+BY = "by" .
+CASE = "case" .
+CONSTANT = "constant" .
+CONST_E = "const_e" .
+COS = "cos" .
+DERIVE = "derive" .
+DIV = "div" .
+ELSE = "else" .
+END = "end" .
+END_ALIAS = "end_alias" .
+END_CASE = "end_case" .
+END_CONSTANT = "end_constant" .
+END_ENTITY = "end_entity" .
+END_FUNCTION = "end_function" .
+END_IF = "end_if" .
+END_LOCAL = "end_local" .
+END_PROCEDURE = "end_procedure" .
+END_REPEAT = "end_repeat" .
+END_RULE = "end_rule" .
+END_SCHEMA = "end_schema" .
+END_SUBTYPE_CONSTRAINT = "end_subtype_constraint" .
+END_TYPE = "end_type" .
+ENTITY = "entity" .
+ENUMERATION = "enumeration" .
+ESCAPE = "escape" .
+EXISTS = "exists" .
+EXTENSIBLE = "extensible" .
+EXP = "exp" .
+FALSE = "false" .
+FIXED = "fixed" .
+FOR = "for" .
+FORMAT = "format" .
+FROM = "from" .
+FUNCTION = "function" .
+GENERIC = "generic" .
+GENERIC_ENTITY = "generic_entity" .
+HIBOUND = "hibound" .
+HIINDEX = "hiindex" .
+IF = "if" .
+IN = "in" .
+INSERT = "insert" .
+INTEGER = "integer" .
+INVERSE = "inverse" .
+LENGTH = "length" .
+LIKE = "like" .
+LIST = "list" .
+LOBOUND = "lobound" .
+LOCAL = "local" .
+LOG = "log" .
+LOG10 = "log10" .
+LOG2 = "log2" .
+LOGICAL = "logical" .
+LOINDEX = "loindex" .
+MOD = "mod" .
+NOT = "not" .
+NUMBER = "number" .
+NVL = "nvl" .
+ODD = "odd" .
+OF = "of" .
+ONEOF = "oneof" .
+OPTIONAL = "optional" .
+OR = "or" .
+OTHERWISE = "otherwise" .
+PI = "pi" .
+PROCEDURE = "procedure" .
+QUERY = "query" .
+REAL = "real" .
+REFERENCE = "reference" .
+REMOVE = "remove" .
+RENAMED = "renamed" .
+REPEAT = "repeat" .
+RETURN = "return" .
+ROLESOF = "rolesof" .
+RULE = "rule" .
+SCHEMA = "schema" .
+SELECT = "select" .
+SELF = "self" .
+SET = "set" .
+SIN = "sin" .
+SIZEOF = "sizeof" .
+SKIP = "skip" .
+SQRT = "sqrt" .
+STRING = "string" .
+SUBTYPE = "subtype" .
+SUBTYPE_CONSTRAINT = "subtype_constraint" .
+SUPERTYPE = "supertype" .
+TAN = "tan" .
+THEN = "then" .
+TO = "to" .
+TOTAL_OVER = "total_over" .
+TRUE = "true" .
+TYPE = "type" .
+TYPEOF = "typeof" .
+UNIQUE = "unique" .
+UNKNOWN = "unknown" .
+UNTIL = "until" .
+USE = "use" .
+USEDIN = "usedin" .
+VALUE = "value" .
+VALUE_IN = "value_in" .
+VALUE_UNIQUE = "value_unique" .
+VAR = "var" .
+WHERE = "where" .
+WHILE = "while" .
+WITH = "with" .
+XOR = "xor" .
+bit = "0" | "1" .
+digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" .
+digits = digit { digit } .
+encoded_character = octet octet octet octet .
+hex_digit = digit | "a" | "b" | "c" | "d" | "e" | "f" .
+letter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" .
+lparen_then_not_lparen_star = "(" { "(" } not_lparen_star { not_lparen_star } .
+not_lparen_star = not_paren_star | ")" .
+not_paren_star = letter | digit | not_paren_star_special .
+not_paren_star_quote_special = "!" | "#" | "$" | "%" | "&" | "+" | "," | "-" | "." | "/" | ":" | ";" | "<" | "=" | ">" | "?" | "@" | "[" | "\\" | "]" | "^" | "_" | "{" | "|" | "}" | "~" .
+not_paren_star_special = not_paren_star_quote_special | "\"\"" .
+not_quote = not_paren_star_quote_special | letter | digit | "(" | ")" | "*" .
+not_rparen_star = not_paren_star | "(" .
+octet = hex_digit hex_digit .
+special = not_paren_star_quote_special | "(" | ")" | "*" | "\"\"" .
+not_rparen_star_then_rparen = not_rparen_star { not_rparen_star } ")" { ")" } .
+binary_literal = "%" bit { bit } .
+encoded_string_literal = "\"" encoded_character { encoded_character } "\"" .
+integer_literal = digits .
+real_literal = ( digits "." [ digits ] [ "e" [ sign ] digits ] ) | integer_literal .
+simple_id = letter { letter | digit | "_" } .
+simple_string_literal = "'" { ( "'" "'" ) | not_quote } "'" .
+embedded_remark = "(*" [ remark_tag ] { ( not_paren_star { not_paren_star } ) | lparen_then_not_lparen_star | ( "*" { "*" } ) | not_rparen_star_then_rparen | embedded_remark } "*)" .
+remark = embedded_remark | tail_remark .
+remark_tag = "\"" remark_ref { "." remark_ref } "\"" .
+remark_ref = attribute_ref | constant_ref | entity_ref | enumeration_ref | function_ref | parameter_ref | procedure_ref | rule_label_ref | rule_ref | schema_ref | subtype_constraint_ref | type_label_ref | type_ref | variable_ref .
+tail_remark = "--" [ remark_tag ] .
+attribute_ref = attribute_id .
+constant_ref = constant_id .
+entity_ref = entity_id .
+enumeration_ref = enumeration_id .
+function_ref = function_id .
+parameter_ref = parameter_id .
+procedure_ref = procedure_id .
+rule_label_ref = rule_label_id .
+rule_ref = rule_id .
+schema_ref = schema_id .
+subtype_constraint_ref = subtype_constraint_id .
+type_label_ref = type_label_id .
+type_ref = type_id .
+variable_ref = variable_id .
+abstract_entity_declaration = ABSTRACT .
+abstract_supertype = ABSTRACT SUPERTYPE ";" .
+abstract_supertype_declaration = ABSTRACT SUPERTYPE [ subtype_constraint ] .
+actual_parameter_list = "(" [ parameter ] { "," parameter } ")" .
+add_like_op = "+" | "-" | OR | XOR .
+aggregate_initializer = "[" [ element { "," element } ] "]" .
+aggregate_source = simple_expression .
+aggregate_type = AGGREGATE [ ":" type_label ] OF parameter_type .
+aggregation_types = array_type | bag_type | list_type | set_type .
+algorithm_head = { declaration } [ constant_decl ] [ local_decl ] .
+alias_stmt = ALIAS variable_id FOR general_ref { qualifier } ";" stmt { stmt } END_ALIAS ";" .
+array_type = ARRAY bound_spec OF [ OPTIONAL ] [ UNIQUE ] instantiable_type .
+assignment_stmt = general_ref { qualifier } ":=" expression ";" .
+attribute_decl = redeclared_attribute | attribute_id .
+attribute_id = simple_id .
+attribute_qualifier = "." attribute_ref .
+bag_type = BAG [ bound_spec ] OF instantiable_type .
+binary_type = BINARY [ width_spec ] .
+boolean_type = BOOLEAN .
+bound_1 = numeric_expression .
+bound_2 = numeric_expression .
+bound_spec = "[" bound_1 ":" bound_2 "]" .
+built_in_constant = CONST_E | PI | SELF | "?" .
+built_in_function = ABS | ACOS | ASIN | ATAN | BLENGTH | COS | EXISTS | EXP | FORMAT | HIBOUND | HIINDEX | LENGTH | LOBOUND | LOINDEX | LOG | LOG2 | LOG10 | NVL | ODD | ROLESOF | SIN | SIZEOF | SQRT | TAN | TYPEOF | USEDIN | VALUE | VALUE_IN | VALUE_UNIQUE .
+built_in_procedure = INSERT | REMOVE .
+case_action = case_label { "," case_label } ":" stmt .
+case_label = expression .
+case_stmt = CASE selector OF { case_action } [ OTHERWISE ":" stmt ] END_CASE ";" .
+compound_stmt = BEGIN stmt { stmt } END ";" .
+concrete_types = aggregation_types | simple_types | type_ref .
+constant_body = constant_id ":" instantiable_type ":=" expression ";" .
+constant_decl = CONSTANT constant_body { constant_body } END_CONSTANT ";" .
+constant_factor = built_in_constant | constant_ref .
+constant_id = simple_id .
+constructed_types = enumeration_type | select_type .
+declaration = entity_decl | function_decl | procedure_decl | subtype_constraint_decl | type_decl .
+derived_attr = attribute_decl ":" parameter_type ":=" expression ";" .
+derive_clause = DERIVE derived_attr { derived_attr } .
+domain_rule = rule_label_id ":" expression .
+element = expression [ ":" repetition ] .
+entity_body = { explicit_attr } [ derive_clause ] [ inverse_clause ] [ unique_clause ] [ where_clause ] .
+entity_constructor = entity_ref "(" [ expression { "," expression } ] ")" .
+entity_decl = entity_head entity_body END_ENTITY ";" .
+entity_head = ENTITY entity_id subsuper ";" .
+entity_id = simple_id .
+enumeration_extension = BASED_ON type_ref [ WITH enumeration_items ] .
+enumeration_id = simple_id .
+enumeration_items = "(" enumeration_id { "," enumeration_id } ")" .
+enumeration_reference = [ type_ref "." ] enumeration_ref .
+enumeration_type = [ EXTENSIBLE ] ENUMERATION [ ( OF enumeration_items ) | enumeration_extension ] .
+escape_stmt = ESCAPE ";" .
+explicit_attr = attribute_decl { "," attribute_decl } ":" [ OPTIONAL ] parameter_type ";" .
+expression = simple_expression [ rel_op_extended simple_expression ] .
+factor = simple_factor [ "**" simple_factor ] .
+formal_parameter = parameter_id { "," parameter_id } ":" parameter_type .
+function_call = ( built_in_function | function_ref ) actual_parameter_list .
+function_decl = function_head algorithm_head stmt { stmt } END_FUNCTION ";" .
+function_head = FUNCTION function_id [ "(" formal_parameter { ";" formal_parameter } ")" ] ":" parameter_type ";" .
+function_id = simple_id .
+generalized_types = aggregate_type | general_aggregation_types | generic_entity_type | generic_type .
+general_aggregation_types = general_array_type | general_bag_type | general_list_type | general_set_type .
+general_array_type = ARRAY [ bound_spec ] OF [ OPTIONAL ] [ UNIQUE ] parameter_type .
+general_bag_type = BAG [ bound_spec ] OF parameter_type .
+general_list_type = LIST [ bound_spec ] OF [ UNIQUE ] parameter_type .
+general_ref = parameter_ref | variable_ref .
+general_set_type = SET [ bound_spec ] OF parameter_type .
+generic_entity_type = GENERIC_ENTITY [ ":" type_label ] .
+generic_type = GENERIC [ ":" type_label ] .
+group_qualifier = "\\" entity_ref .
+if_stmt = IF logical_expression THEN stmt { stmt } [ ELSE stmt { stmt } ] END_IF ";" .
+increment = numeric_expression .
+increment_control = variable_id ":=" bound_1 TO bound_2 [ BY increment ] .
+index = numeric_expression .
+index_1 = index .
+index_2 = index .
+index_qualifier = "[" index_1 [ ":" index_2 ] "]" .
+instantiable_type = concrete_types | entity_ref .
+integer_type = INTEGER .
+interface_specification = reference_clause | use_clause .
+interval = "{" interval_low interval_op interval_item interval_op interval_high "}" .
+interval_high = simple_expression .
+interval_item = simple_expression .
+interval_low = simple_expression .
+interval_op = "<=" | "<" .
+inverse_attr = attribute_decl ":" [ ( SET | BAG ) [ bound_spec ] OF ] entity_ref FOR [ entity_ref "." ] attribute_ref ";" .
+inverse_clause = INVERSE inverse_attr { inverse_attr } .
+list_type = LIST [ bound_spec ] OF [ UNIQUE ] instantiable_type .
+literal = binary_literal | logical_literal | real_literal | string_literal .
+local_decl = LOCAL local_variable { local_variable } END_LOCAL ";" .
+local_variable = variable_id { "," variable_id } ":" parameter_type [ ":=" expression ] ";" .
+logical_expression = expression .
+logical_literal = FALSE | TRUE | UNKNOWN .
+logical_type = LOGICAL .
+multiplication_like_op = "*" | "/" | DIV | MOD | AND | "||" .
+named_types = entity_ref | type_ref .
+named_type_or_rename = named_types [ AS ( entity_id | type_id ) ] .
+null_stmt = ";" .
+number_type = NUMBER .
+numeric_expression = simple_expression .
+one_of = ONEOF "(" supertype_expression { "," supertype_expression } ")" .
+parameter = expression .
+parameter_id = simple_id .
+parameter_type = generalized_types | simple_types | named_types .
+population = entity_ref .
+precision_spec = numeric_expression .
+primary = literal | ( qualifiable_factor { qualifier } ) .
+procedure_call_stmt = ( built_in_procedure | procedure_ref ) actual_parameter_list ";" .
+procedure_decl = procedure_head algorithm_head { stmt } END_PROCEDURE ";" .
+procedure_head = PROCEDURE procedure_id [ "(" [ VAR ] formal_parameter { ";" [ VAR ] formal_parameter } ")" ] ";" .
+procedure_id = simple_id .
+qualifiable_factor = function_call | attribute_ref | constant_factor | general_ref | population .
+qualified_attribute = SELF group_qualifier attribute_qualifier .
+qualifier = attribute_qualifier | group_qualifier | index_qualifier .
+query_expression = QUERY "(" variable_id "<*" aggregate_source "|" logical_expression ")" .
+real_type = REAL [ "(" precision_spec ")" ] .
+redeclared_attribute = qualified_attribute [ RENAMED attribute_id ] .
+referenced_attribute = attribute_ref | qualified_attribute .
+reference_clause = REFERENCE FROM schema_ref [ "(" resource_or_rename { "," resource_or_rename } ")" ] ";" .
+rel_op = "<=" | ">=" | "<>" | "=" | ":<>:" | ":=:" | "<" | ">" .
+rel_op_extended = rel_op | IN | LIKE .
+rename_id = constant_id | entity_id | function_id | procedure_id | type_id .
+repeat_control = [ increment_control ] [ while_control ] [ until_control ] .
+repeat_stmt = REPEAT repeat_control ";" stmt { stmt } END_REPEAT ";" .
+repetition = numeric_expression .
+resource_or_rename = resource_ref [ AS rename_id ] .
+resource_ref = constant_ref | entity_ref | function_ref | procedure_ref | type_ref .
+return_stmt = RETURN [ "(" expression ")" ] ";" .
+rule_decl = rule_head algorithm_head { stmt } where_clause END_RULE ";" .
+rule_head = RULE rule_id FOR "(" entity_ref { "," entity_ref } ")" ";" .
+rule_id = simple_id .
+rule_label_id = simple_id .
+schema_body = { interface_specification } [ constant_decl ] { declaration | rule_decl } .
+schema_decl = SCHEMA schema_id [ schema_version_id ] ";" schema_body END_SCHEMA ";" .
+schema_id = simple_id .
+schema_version_id = string_literal .
+selector = expression .
+select_extension = BASED_ON type_ref [ WITH select_list ] .
+select_list = "(" named_types { "," named_types } ")" .
+select_type = [ EXTENSIBLE [ GENERIC_ENTITY ] ] SELECT [ select_list | select_extension ] .
+set_type = SET [ bound_spec ] OF instantiable_type .
+sign = "+" | "-" .
+simple_expression = term { add_like_op term } .
+simple_factor = aggregate_initializer | interval | query_expression | ( [ unary_op ] ( "(" expression ")" | primary ) ) | entity_constructor | enumeration_reference .
+simple_types = binary_type | boolean_type | integer_type | logical_type | number_type | real_type | string_type .
+skip_stmt = SKIP ";" .
+stmt = alias_stmt | assignment_stmt | case_stmt | compound_stmt | escape_stmt | if_stmt | null_stmt | procedure_call_stmt | repeat_stmt | return_stmt | skip_stmt .
+string_literal = simple_string_literal | encoded_string_literal .
+string_type = STRING [ width_spec ] .
+subsuper = [ supertype_constraint ] [ subtype_declaration ] .
+subtype_constraint = OF "(" supertype_expression ")" .
+subtype_constraint_body = [ abstract_supertype ] [ total_over ] [ supertype_expression ";" ] .
+subtype_constraint_decl = subtype_constraint_head subtype_constraint_body END_SUBTYPE_CONSTRAINT ";" .
+subtype_constraint_head = SUBTYPE_CONSTRAINT subtype_constraint_id FOR entity_ref ";" .
+subtype_constraint_id = simple_id .
+subtype_declaration = SUBTYPE OF "(" entity_ref { "," entity_ref } ")" .
+supertype_constraint = abstract_supertype_declaration | abstract_entity_declaration | supertype_rule .
+supertype_expression = supertype_factor { ANDOR supertype_factor } .
+supertype_factor = supertype_term { AND supertype_term } .
+supertype_rule = SUPERTYPE subtype_constraint .
+supertype_term = one_of | "(" supertype_expression ")" | entity_ref .
+syntax = schema_decl { schema_decl } .
+term = factor { multiplication_like_op factor } .
+total_over = TOTAL_OVER "(" entity_ref { "," entity_ref } ")" ";" .
+type_decl = TYPE type_id "=" underlying_type ";" [ where_clause ] END_TYPE ";" .
+type_id = simple_id .
+type_label = type_label_id | type_label_ref .
+type_label_id = simple_id .
+unary_op = "+" | "-" | NOT .
+underlying_type = constructed_types | concrete_types .
+unique_clause = UNIQUE unique_rule ";" { unique_rule ";" } .
+unique_rule = rule_label_id ":" referenced_attribute { "," referenced_attribute } .
+until_control = UNTIL logical_expression .
+use_clause = USE FROM schema_ref [ "(" named_type_or_rename { "," named_type_or_rename } ")" ] ";" .
+variable_id = simple_id .
+where_clause = WHERE domain_rule ";" { domain_rule ";" } .
+while_control = WHILE logical_expression .
+width = numeric_expression .
+width_spec = "(" width ")" [ FIXED ] .

src/ifcexpressparser/header.py

@@ -0,0 +1,127 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import templates
+import documentation
+
+class Header:
+    def __init__(self, mapping):
+        emitted_types = set(mapping.express_to_cpp_typemapping.values())
+        declarations = []
+
+        write = lambda str, **kwargs: declarations.append(str%dict({
+            'documentation': templates.multi_line_comment(documentation.description(kwargs['name']))}, **kwargs))
+
+        for name, type in mapping.schema.simpletypes.items():
+            type_str = mapping.make_type_string(type)
+            type_dep = mapping.get_type_dep(type)
+            if type_dep in emitted_types:
+                write(templates.simpletype, name=name, type=type_str)
+                emitted_types.add(name)
+
+        for name, type in mapping.schema.selects.items():
+            write(templates.select, name=name)
+            emitted_types.add(name)
+
+        for name, type in mapping.schema.simpletypes.items():
+            if name not in emitted_types:
+                type_str = mapping.make_type_string(type)
+                write(templates.simpletype, name=name, type=type_str)
+                emitted_types.add(name)
+
+        for name, type in mapping.schema.enumerations.items():
+            short_name = name[:-4] if name.endswith("Enum") else name
+            write(templates.enumeration, name=name, values=", ".join(["%s_%s"%(short_name, v) for v in type.values]))
+
+        forward_definitions = "".join(["class %s; "%n for n in mapping.schema.entities.keys()])
+
+        class_definitions = []
+
+        write = lambda str, **kwargs: class_definitions.append(str%dict({
+            'documentation': templates.multi_line_comment(documentation.description(kwargs['name']))}, **kwargs))
+
+        emitted_entities = set()
+        while len(emitted_entities) < len(mapping.schema.entities):
+            for name, type in mapping.schema.entities.items():
+                if name in emitted_entities: continue
+                if len(type.supertypes) == 0 or set(type.supertypes) < emitted_entities:
+                    attr_lines = []
+                    def write_method(attr):
+                        if attr.optional:
+                            attr_lines.append(templates.optional_attribute_description % (attr.name, name))
+                            attr_lines.append("bool has%s();"%(attr.name))
+                        attr_lines.extend(["/// %s"%d for d in documentation.description((name, attr.name))])
+                        type_str = mapping.get_parameter_type(attr, allow_optional=False, allow_entities=False)
+                        if mapping.make_argument_type(attr) != "IfcUtil::Argument_UNKNOWN":
+                            attr_lines.append("%s %s();"%(type_str, attr.name))
+                            attr_lines.append("void set%s(%s v);"%(attr.name, type_str))
+
+                    [write_method(attr) for attr in type.attributes]
+
+                    inv_lines = []
+                    def write_inverse(attr):
+                        inv_lines.append(templates.inverse_attr%{'name':attr.name, 'entity':attr.entity, 'attribute':attr.attribute})
+
+                    if type.inverse:
+                        [write_inverse(attr) for attr in type.inverse.elements]
+
+                    attributes = "\n".join(["%s%s"%(' '*4, a) for a in attr_lines])
+                    if len(attributes): attributes += '\n'
+
+                    inverse = "\n".join(["%s%s"%(' '*4, a) for a in inv_lines])
+                    if len(inverse): inverse += '\n'
+
+                    supertypes = type.supertypes if len(type.supertypes) else ['IfcUtil::IfcBaseEntity']
+                    superclass = ": %s "%(", ".join(["public %s"%c for c in supertypes]))
+
+                    argument_count = mapping.argument_count(type)
+
+                    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::IfcException("argument 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::IfcException("argument out of range"); '
+
+                    argument_type_function_body = argument_type_function_body_switch_stmt + argument_type_function_body_tail
+
+                    constructor_arguments = ", ".join("%(full_type)s v%(index)d_%(name)s"%a for a in mapping.get_assignable_arguments(type))
+
+                    write(templates.entity, **locals())
+                    emitted_entities.add(name)
+
+        self.str = templates.header % {
+            'schema_name_upper'   : mapping.schema.name.upper(),
+            'schema_name'         : mapping.schema.name.capitalize(),
+            'declarations'        : ''.join(declarations),
+            'forward_definitions' : forward_definitions,
+            'class_definitions'   : ''.join(class_definitions)
+        }
+
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%s.h'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
+

src/ifcexpressparser/implementation.py

@@ -0,0 +1,178 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import templates
+
+class Implementation:
+    def __init__(self, mapping):
+        enumeration_functions = []
+        entity_implementations = []
+        schema_entity_statements = []
+
+        schema_name = mapping.schema.name.capitalize()
+
+        stringify = lambda s: '"%s"'%s
+        cat = lambda vs: "".join(vs)
+        catc = lambda vs: ", ".join(vs)
+        catnl = lambda vs: "\n".join(vs)
+        cator = lambda vs: " || ".join(vs)
+        nl = lambda s: "%s\n"%s if len(s) else s
+
+        write = lambda str, **kwargs: enumeration_functions.append(str%kwargs)
+
+        for name, enum in mapping.schema.enumerations.items():
+            short_name = name[:-4] if name.endswith("Enum") else name
+            context = locals()
+            write(
+                templates.enumeration_function,
+                max_id = len(enum.values),
+                name = name,
+                values = catc(map(stringify, enum.values)),
+                from_string_statements = catnl(templates.enum_from_string_stmt%dict(context,**locals()) for value in enum.values)
+            )
+
+        write = lambda str, **kwargs: entity_implementations.append(str%kwargs)
+
+        for name, type in mapping.schema.entities.items():
+            parent_type_test = "" if not type.supertypes or len(type.supertypes) != 1 \
+                else templates.parent_type_test%(type.supertypes[0])
+            constructor_arguments = mapping.get_assignable_arguments(type, include_derived = True)
+            constructor_arguments_str = catc("%(full_type)s v%(index)d_%(name)s"%a for a in constructor_arguments if not a['is_derived'])
+            attributes = []
+            constructor_implementations = []
+            write_attr = lambda str, **kwargs: attributes.append(str%kwargs)
+            for arg in constructor_arguments:
+                if not arg['is_inherited'] and not arg['is_derived']:
+                    if arg['is_optional']:
+                        write_attr(
+                            templates.function,
+                            class_name  = name,
+                            name        = 'has%s'%arg['name'],
+                            arguments   = '',
+                            return_type = 'bool',
+                            body        = templates.optional_attr_stmt % {'index':arg['index']-1}
+                        )
+
+                    tmpl = templates.get_attr_stmt_enum if arg['is_enum'] else templates.get_attr_stmt_array if arg['is_array'] and not mapping.schema.is_simpletype(arg['list_instance_type']) and arg['list_instance_type'] not in mapping.express_to_cpp_typemapping else templates.get_attr_stmt_entity if arg['non_optional_type'].endswith('*') else templates.get_attr_stmt
+                    write_attr(
+                        templates.function,
+                        class_name  = name,
+                        name        = arg['name'],
+                        arguments   = '',
+                        return_type = arg['non_optional_type'],
+                        body        = tmpl % {'index': arg['index']-1,
+                                              'type' : arg['non_optional_type'].split('::')[0],
+                                              'list_instance_type' : arg['list_instance_type']}
+                    )
+
+                    tmpl = templates.set_attr_stmt_enum if arg['is_enum'] else templates.set_attr_stmt_array if arg['is_array'] and not mapping.schema.is_simpletype(arg['list_instance_type']) and arg['list_instance_type'] not in mapping.express_to_cpp_typemapping else templates.set_attr_stmt
+                    write_attr(
+                        templates.function,
+                        class_name  = name,
+                        name        = 'set%s'%arg['name'],
+                        arguments   = '%s v'%arg['non_optional_type'],
+                        return_type = 'void',
+                        body        = tmpl % {'index': arg['index']-1,
+                                              'type' : arg['non_optional_type'].split('::')[0]}
+                    )
+
+                if arg['is_derived']:
+                    constructor_implementations.append(templates.constructor_stmt_derived % {'index' : arg['index']-1})
+                else:
+                    is_optional_non_naked_ptr = arg['is_optional'] and not arg['non_optional_type'].endswith('*')
+                    arg_name = "v%(index)d_%(name)s"%arg
+                    deref_name = ("*%s"%arg_name) if is_optional_non_naked_ptr else arg_name
+
+                    tmpl = templates.constructor_stmt_array if arg['is_templated_list'] \
+                        else templates.constructor_stmt_enum if arg['is_enum'] \
+                        else templates.constructor_stmt
+                    impl = tmpl % {'name'  : deref_name,
+                                   'index' : arg['index']-1,
+                                   'type'  : arg['non_optional_type'].split('::')[0]}
+                    if is_optional_non_naked_ptr:
+                        impl = templates.constructor_stmt_optional%{'name'  : arg_name,
+                                                            'index' : arg['index']-1,
+                                                            'stmt'  : impl}
+                    constructor_implementations.append(impl)
+
+            inverse = [templates.function % {
+                'class_name'  : name,
+                'name'        : i.name,
+                'arguments'   : '',
+                'return_type' : '%s::list' % i.entity,
+                'body'        : templates.get_inverse % {'type': i.entity}
+            } for i in (type.inverse.elements if type.inverse else [])]
+
+            superclass = "%s((IfcAbstractEntityPtr)0)" % type.supertypes[0] if len(type.supertypes) == 1 else 'IfcUtil::IfcBaseEntity()'
+
+            write(
+                templates.entity_implementation,
+                name                       = name,
+                parent_type_test           = parent_type_test,
+                constructor_arguments      = constructor_arguments_str,
+                constructor_implementation = cat(constructor_implementations),
+                attributes                 = nl(catnl(attributes)),
+                inverse                    = nl(catnl(inverse)),
+                superclass                 = superclass
+            )
+
+        selectable_simple_types = sorted(set(sum([b.values for a,b in mapping.schema.selects.items()], [])) & set(mapping.schema.types.keys()))
+        schema_entity_statements += [templates.schema_simple_stmt%locals() for name in selectable_simple_types]
+        schema_entity_statements += [templates.schema_entity_stmt%locals() for name, type in mapping.schema.entities.items()]
+
+        enumerable_types = selectable_simple_types + [name for name, type in mapping.schema.entities.items()]
+        max_len = max(map(len, enumerable_types))
+        type_name_strings = catc(map(stringify, enumerable_types))
+        string_map_statements = [templates.string_map_statement % {
+            'uppercase_name' : name.upper(),
+            'name'           : name,
+            'padding'        : ' ' * (max_len - len(name))
+        } for name in enumerable_types]
+
+        parent_type_statements = [templates.parent_type_stmt % {
+            'name'    : name,
+            'parent'  : type.supertypes[0],
+            'padding' : ' ' * (max_len - len(name))
+        } for name, type in mapping.schema.entities.items() if type.supertypes and len(type.supertypes) == 1]
+
+        max_id = len(schema_entity_statements)
+
+        simple_type_statements = cator("v == Type::%s"%name for name in selectable_simple_types)
+
+        self.str = templates.implementation % {
+            'schema_name_upper'        : mapping.schema.name.upper(),
+            'schema_name'              : mapping.schema.name.capitalize(),
+            'max_id'                   : max_id,
+            'enumeration_functions'    : cat(enumeration_functions),
+            'schema_entity_statements' : catnl(schema_entity_statements),
+            'type_name_strings'        : type_name_strings,
+            'string_map_statements'    : catnl(string_map_statements),
+            'simple_type_statement'    : simple_type_statements,
+            'parent_type_statements'   : catnl(parent_type_statements),
+            'entity_implementations'   : catnl(entity_implementations)
+        }
+
+        self.schema_name = mapping.schema.name.capitalize()
+    def __repr__(self):
+        return self.str
+    def emit(self):
+        f = open('%s.cpp'%self.schema_name, 'w', encoding='utf-8')
+        f.write(str(self))
+        f.close()
+

src/ifcexpressparser/mapping.py

@@ -0,0 +1,169 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import nodes
+import templates
+
+class Mapping:
+
+    express_to_cpp_typemapping = {
+        'boolean' : 'bool',
+        'logical' : 'bool',
+        'integer' : 'int',
+        'real'    : 'double',
+        'number'  : 'double',
+        'string'  : 'std::string'
+    }
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def make_type_string(self, type):
+        if isinstance(type, str):
+            return self.express_to_cpp_typemapping.get(type, type)
+        else:
+            is_list = self.schema.is_entity(type.type)
+            tmpl = templates.list_type if is_list else templates.array_type
+            return tmpl % {
+                'instance_type' : self.make_type_string(type.type),
+                'lower'         : type.bounds.lower,
+                'upper'         : type.bounds.upper,
+            }
+
+    def is_array(self, type):
+        if isinstance(type, nodes.AggregationType):
+            return True
+        elif isinstance(type, str) and self.schema.is_type(type):
+            return self.is_array(self.schema.types[type].type.type)
+        else:
+            return False
+
+    def make_argument_type(self, attr):
+        def _make_argument_type(type):
+            if type in self.express_to_cpp_typemapping:
+                return self.express_to_cpp_typemapping.get(type, type).split('::')[-1].upper()
+            elif self.schema.is_entity(type):
+                return "ENTITY"
+            elif self.schema.is_type(type):
+                return _make_argument_type(self.schema.types[type].type.type)
+            elif isinstance(type, nodes.BinaryType):
+                return "UNKNOWN"
+            elif isinstance(type, nodes.EnumerationType):
+                return "ENUMERATION"
+            elif isinstance(type, nodes.SelectType):
+                return "ENTITY"
+            elif isinstance(type, nodes.AggregationType):
+                ty = _make_argument_type(type.type)
+                if ty == "UNKNOWN": return "UNKNOWN"
+                return "ENTITY_LIST" if ty == "ENTITY" else ("VECTOR_%s"%ty)
+            else: raise ValueError
+        supported = {'INT', 'BOOL', 'DOUBLE', 'STRING', 'VECTOR_INT', 'VECTOR_DOUBLE', 'VECTOR_STRING', 'ENTITY', 'ENTITY_LIST', 'ENUMERATION'}
+        ty = _make_argument_type(attr.type)
+        if ty not in supported: ty = 'UNKNOWN'
+        return "IfcUtil::Argument_%s" % ty
+
+    def get_type_dep(self, type):
+        if isinstance(type, str):
+            return self.express_to_cpp_typemapping.get(type, type)
+        else:
+            return self.get_type_dep(type.type)
+
+    def get_parameter_type(self, attr, allow_optional, allow_entities, allow_pointer = True):
+        type_str = self.express_to_cpp_typemapping.get(str(attr.type), attr.type)
+        is_ptr = False
+        if self.schema.is_enumeration(attr.type):
+            type_str = '%s::%s'%(attr.type, attr.type)
+        elif isinstance(type_str, nodes.AggregationType):
+            ty = self.get_parameter_type(attr.type, False, allow_entities, allow_pointer=False)
+            if allow_entities and 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 % {
+                    'instance_type' : ty,
+                    'lower'         : attr.type.bounds.lower,
+                    'upper'         : attr.type.bounds.upper
+                }
+            else:
+                type_str = templates.list_type % {
+                    'instance_type': ty
+                }
+        elif allow_pointer and self.schema.is_entity(type_str):
+            type_str += '*'
+            is_ptr = True
+        elif not allow_pointer and self.schema.is_select(type_str):
+            type_str = "IfcUtil::IfcAbstractSelect"
+            is_ptr = True
+        if allow_optional and attr.optional and not is_ptr:
+            type_str = "boost::optional< %s >"%type_str
+        return type_str
+
+    def argument_count(self, t):
+        c = sum([self.argument_count(self.schema.entities[s]) for s in t.supertypes])
+        return c + len(t.attributes)
+
+    def arguments(self, t):
+        c = sum([self.arguments(self.schema.entities[s]) for s in t.supertypes], [])
+        return c + t.attributes
+
+    def derived_in_supertype(self, t):
+        c = sum([self.derived_in_supertype(self.schema.entities[s]) for s in t.supertypes], [])
+        return c + ([str(s) for s in t.derive.elements] if t.derive else [])
+
+    def list_instance_type(self, attr):
+        f = lambda v : 'IfcUtil::IfcAbstractSelect' if self.schema.is_select(v) else v
+        if self.is_array(attr.type) and not isinstance(attr.type, str):
+            return f(attr.type.type)
+        elif self.is_array(attr.type) and isinstance(attr.type, str):
+            return f(attr.type)
+        else: return None
+
+    def is_templated_list(self, attr):
+        ty = self.list_instance_type(attr)
+        arr = self.is_array(attr.type)
+        simple = self.schema.is_simpletype(ty)
+        express = ty in self.express_to_cpp_typemapping
+        select = ty == 'IfcUtil::IfcAbstractSelect'
+        return arr and not simple and not express and not select
+
+    def get_assignable_arguments(self, t, include_derived = False):
+        count = self.argument_count(t)
+        num_inherited = count - len(t.attributes)
+        derived = set(self.derived_in_supertype(t))
+        attrs = enumerate(self.arguments(t))
+
+        def include(attr):
+            not_derived = include_derived or (attr.name not in derived)
+            supported = self.make_argument_type(attr) != "IfcUtil::Argument_UNKNOWN"
+            return not_derived and supported
+
+        return [{
+            'index'              : i+1,
+            'name'               : attr.name,
+            'full_type'          : self.get_parameter_type(attr, allow_optional=True, allow_entities=True),
+            'specialized_type'   : self.get_parameter_type(attr, allow_optional=True, allow_entities=False),
+            'non_optional_type'  : self.get_parameter_type(attr, allow_optional=False, allow_entities=False),
+            'list_instance_type' : self.list_instance_type(attr),
+            'is_optional'        : attr.optional,
+            'is_inherited'       : i < num_inherited,
+            'is_enum'            : attr.type in self.schema.enumerations,
+            'is_array'           : self.is_array(attr.type),
+            'is_derived'         : attr.name in derived,
+            'is_templated_list'  : self.is_templated_list(attr)
+        } for i, attr in attrs if include(attr)]
+

src/ifcexpressparser/nodes.py

@@ -0,0 +1,175 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import string
+import collections
+
+class Node:
+    def __init__(self, tokens):
+        self.tokens = tokens
+        self.init()
+    def tokens_of_type(self, cls):
+        return [t for t in self.tokens if isinstance(t, cls)]
+    def single_token_of_type(self, cls, k = None, v = None):
+        ts = [t for t in self.tokens if isinstance(t, cls) and (k is None or getattr(t, k) == v)]
+        return ts[0] if len(ts) == 1 else None
+
+
+class TypeDeclaration(Node):
+    name = property(lambda self: self.tokens[1])
+    type = property(lambda self: self.tokens[3])
+    def init(self):
+        assert self.tokens[0] == 'type'
+        assert isinstance(self.type, UnderlyingType)
+    def __repr__(self):
+        return "%s = TypeDeclaration(%s)" % (self.name, self.type)
+
+
+class EntityDeclaration(Node):
+    name = property(lambda self: self.tokens[1])
+    attributes = property(lambda self: self.tokens_of_type(ExplicitAttribute))
+    def init(self):
+        assert self.tokens[0] == 'entity'
+        s = self.single_token_of_type(SubtypeExpression)
+        self.inverse = self.single_token_of_type(AttributeList, 'type', 'inverse')
+        self.derive = self.single_token_of_type(AttributeList, 'type', 'derive')
+        self.supertypes = s.types if s else []
+    def __repr__(self):
+        builder = ""
+        builder += "Entity(%s)" % (self.name)
+        if len(self.supertypes):
+            builder += "\n  Supertypes: %s"%(",".join(self.supertypes))
+        if len(self.attributes):
+            builder += "\n  Attributes: %s"%("".join(["\n    %s"%a for a in self.attributes]))
+        if self.derive:
+            builder += "\n  Derive:"
+            builder += str(self.derive)
+        if self.inverse:
+            builder += "\n  Inverse:"
+            builder += str(self.inverse)
+        builder += "\n"
+        return builder
+
+
+class UnderlyingType(Node):
+    type = property(lambda self: self.tokens[0])
+    def init(self):
+        pass
+    def __repr__(self):
+        return repr(self.type)
+
+
+class EnumerationType(Node):
+    type = property(lambda self: self.tokens[0])
+    values = property(lambda self: self.tokens[3::2])
+    def init(self):
+        assert self.type == 'enumeration'
+    def __repr__(self):
+        return ",".join(self.values)
+
+
+class AggregationType(Node):
+    aggregate_type = property(lambda self: self.tokens[0])
+    bounds = property(lambda self: None if self.tokens[1] == 'of' else self.tokens[1])
+    type = property(lambda self: self.tokens[-1])
+    def init(self):
+        assert self.bounds is None or isinstance(self.bounds, BoundSpecification)
+    def __repr__(self):
+        return "%s%s of %s"%(self.aggregate_type, self.bounds, self.type)
+
+
+class SelectType(Node):
+    type = property(lambda self: self.tokens[0])
+    values = property(lambda self: self.tokens[2::2])
+    def init(self):
+        assert self.type == 'select'
+    def __repr__(self):
+        return ",".join(self.values)
+
+
+class SubSuperTypeExpression(Node):
+    type = property(lambda self: self.tokens[0])
+    types = property(lambda self: self.tokens[3::2])
+    def init(self):
+        assert self.type == self.class_type
+
+
+class SubtypeExpression(SubSuperTypeExpression):
+    class_type = 'subtype'
+
+
+class AttributeList(Node):
+    elements = property(lambda self: self.tokens[1:])
+    def __init__(self, ty, toks):
+        self.type = ty
+        Node.__init__(self, toks)
+    def init(self):
+        assert self.type == self.tokens[0]
+    def __repr__(self):
+        return "".join(["\n    %s"%s for s in self.elements])
+
+
+class InverseAttribute(Node):
+    name = property(lambda self: self.tokens[0])
+    type = property(lambda self: self.tokens[2])
+    bounds = property(lambda self: None if len(self.tokens) == 6 else self.tokens[3])
+    entity = property(lambda self: self.tokens[-4])
+    attribute = property(lambda self: self.tokens[-2])
+    def init(self):
+        assert self.bounds is None or isinstance(self.bounds, BoundSpecification)
+    def __repr__(self):
+        return "%s = %s.%s (%s%s)"%(self.name, self.entity, self.attribute, self.type, self.bounds or "")
+
+
+class DerivedAttribute(Node):
+    def init(self):
+        name_index = list(self.tokens).index(':') - 1
+        self.name = self.tokens[name_index]
+    def __repr__(self):
+        return str(self.name)
+
+
+class BinaryType(Node):
+    def init(self):
+        pass
+    def __repr__(self):
+        return "BINARY"
+
+
+class BoundSpecification(Node):
+    lower = property(lambda self: self.tokens[1])
+    upper = property(lambda self: self.tokens[3])
+    def init(self):
+        # assert self.lower in string.digits or self.lower == '?'
+        # assert self.upper in string.digits or self.upper == '?'
+        pass
+    def __repr__(self):
+        return "[%s:%s]"%(self.lower, self.upper)
+
+
+class ExplicitAttribute(Node):
+    name = property(lambda self: self.tokens[0])
+    type = property(lambda self: self.tokens[-2])
+    optional = property(lambda self: len(self.tokens) == 5 and self.tokens[-3] == 'optional')
+    def init(self):
+        # NB: This assumes a single name per attribute
+        # definition, which is not necessarily the case.
+        assert self.tokens[1] == ':'
+    def __repr__(self):
+        return "%s : %s%s" % (self.name, self.type, " ?" if self.optional else "")

src/ifcexpressparser/schema.py

@@ -0,0 +1,46 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+import nodes
+import collections
+
+class Schema:
+    def is_enumeration(self, v):
+        return v in self.enumerations
+    def is_select(self, v):
+        return v in self.selects
+    def is_simpletype(self, v):
+        return v in self.simpletypes
+    def is_type(self, v):
+        return v in self.types
+    def is_entity(self, v):
+        return v in self.entities
+    def __init__(self, parsetree):
+        self.name = parsetree[1]
+
+        sort = lambda d: collections.OrderedDict(sorted(d.items()))
+
+        self.types = sort({t.name:t for t in parsetree if isinstance(t, nodes.TypeDeclaration)})
+        self.entities = sort({t.name:t for t in parsetree if isinstance(t, nodes.EntityDeclaration)})
+
+        of_type = lambda *types: sort({a: b.type.type for a,b in self.types.items() if any(isinstance(b.type.type, ty) for ty in types)})
+
+        self.enumerations = of_type(nodes.EnumerationType)
+        self.selects = of_type(nodes.SelectType)
+        self.simpletypes = of_type(str, nodes.AggregationType)

src/ifcexpressparser/templates.py

@@ -0,0 +1,236 @@
+###############################################################################
+#                                                                             #
+# This file is part of IfcOpenShell.                                          #
+#                                                                             #
+# IfcOpenShell is free software: you can redistribute it and/or modify        #
+# it under the terms of the Lesser GNU General Public License as published by #
+# the Free Software Foundation, either version 3.0 of the License, or         #
+# (at your option) any later version.                                         #
+#                                                                             #
+# IfcOpenShell is distributed in the hope that it will be useful,             #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                #
+# Lesser GNU General Public License for more details.                         #
+#                                                                             #
+# You should have received a copy of the Lesser GNU General Public License    #
+# along with this program. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+
+header = """
+#ifndef %(schema_name_upper)s_H
+#define %(schema_name_upper)s_H
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include <boost/optional.hpp>
+
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcException.h"
+#include "../ifcparse/%(schema_name)senum.h"
+
+#define IfcSchema %(schema_name)s
+
+namespace %(schema_name)s {
+
+// Forward definitions
+%(forward_definitions)s
+
+%(declarations)s
+
+%(class_definitions)s
+void InitStringMap();
+IfcUtil::IfcSchemaEntity SchemaEntity(IfcAbstractEntityPtr e = 0);
+}
+
+#endif
+"""
+
+enum_header = """
+#ifndef %(schema_name_upper)sENUM_H
+#define %(schema_name_upper)sENUM_H
+
+#define IfcSchema %(schema_name)s
+
+namespace %(schema_name)s {
+
+namespace Type {
+    typedef enum {
+        %(types)s, ALL
+    } Enum;
+    Enum Parent(Enum v);
+    Enum FromString(const std::string& s);
+    std::string ToString(Enum v);
+    bool IsSimple(Enum v);
+}
+
+}
+
+#endif
+"""
+
+implementation= """
+#include "../ifcparse/%(schema_name)s.h"
+#include "../ifcparse/IfcException.h"
+#include "../ifcparse/IfcWrite.h"
+#include "../ifcparse/IfcWritableEntity.h"
+
+using namespace %(schema_name)s;
+using namespace IfcParse;
+using namespace IfcWrite;
+
+IfcUtil::IfcSchemaEntity %(schema_name)s::SchemaEntity(IfcAbstractEntityPtr e) {
+    switch(e->type()) {
+%(schema_entity_statements)s
+        default: throw IfcException("Unable to find find keyword in schema"); break;
+    }
+}
+
+std::string Type::ToString(Enum v) {
+    if (v < 0 || v >= %(max_id)d) throw IfcException("Unable to find find keyword in schema");
+    const char* names[] = { %(type_name_strings)s };
+    return names[v];
+}
+
+static std::map<std::string,Type::Enum> string_map;
+void %(schema_name)s::InitStringMap() {
+%(string_map_statements)s
+}
+
+Type::Enum Type::FromString(const std::string& s) {
+    std::map<std::string,Type::Enum>::const_iterator it = string_map.find(s);
+    if ( it == string_map.end() ) throw IfcException("Unable to find find keyword in schema");
+    else return it->second;
+}
+
+Type::Enum Type::Parent(Enum v){
+    if (v < 0 || v >= %(max_id)d) return (Enum)-1;
+%(parent_type_statements)s
+    return (Enum)-1;
+}
+
+bool Type::IsSimple(Enum v) {
+    return %(simple_type_statement)s;
+}
+
+%(enumeration_functions)s
+
+#define RETURN_INVERSE(T) \
+    IfcEntities e = entity->getInverse(T::Class()); \
+    SHARED_PTR< IfcTemplatedEntityList<T> > l ( new IfcTemplatedEntityList<T>() ); \
+    for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) { \
+        l->push(reinterpret_pointer_cast<IfcBaseClass,T>(*it)); \
+    } \
+    return l;
+
+#define RETURN_AS_SINGLE(T,a) \
+    return reinterpret_pointer_cast<IfcBaseClass,T>(*entity->getArgument(a));
+
+#define RETURN_AS_LIST(T,a)  \
+    IfcEntities e = *entity->getArgument(a);  \
+    SHARED_PTR< IfcTemplatedEntityList<T> > l ( new IfcTemplatedEntityList<T>() );  \
+    for ( IfcEntityList::it it = e->begin(); it != e->end(); ++ it ) {  \
+        l->push(reinterpret_pointer_cast<IfcBaseClass,T>(*it)); \
+    }  \
+    return l;
+
+%(entity_implementations)s
+"""
+
+simpletype = """%(documentation)s
+typedef %(type)s %(name)s;
+"""
+
+select = """%(documentation)s
+typedef IfcUtil::IfcSchemaEntity %(name)s;
+"""
+
+enumeration = """namespace %(name)s {
+%(documentation)s
+typedef enum {%(values)s} %(name)s;
+const char* ToString(%(name)s v);
+%(name)s FromString(const std::string& s);
+}
+"""
+
+entity = """%(documentation)s
+class %(name)s %(superclass)s{
+public:
+%(attributes)s    virtual unsigned int getArgumentCount() const { return %(argument_count)d; }
+    virtual IfcUtil::ArgumentType getArgumentType(unsigned int i) const {%(argument_type_function_body)s}
+    virtual const char* getArgumentName(unsigned int i) const {%(argument_name_function_body)s}
+    virtual ArgumentPtr getArgument(unsigned int i) const { return entity->getArgument(i); }
+%(inverse)s    bool is(Type::Enum v) const;
+    Type::Enum type() const;
+    static Type::Enum Class();
+    %(name)s (IfcAbstractEntityPtr e);
+    %(name)s (%(constructor_arguments)s);
+    typedef %(name)s* ptr;
+    typedef SHARED_PTR< IfcTemplatedEntityList< %(name)s > > list;
+    typedef IfcTemplatedEntityList< %(name)s >::it it;
+};
+"""
+
+enumeration_function="""
+const char* %(name)s::ToString(%(name)s v) {
+    if ( v < 0 || v >= %(max_id)d ) throw IfcException("Unable to find find keyword in schema");
+    const char* names[] = { %(values)s };
+    return names[v];
+}
+
+%(name)s::%(name)s %(name)s::FromString(const std::string& s) {
+%(from_string_statements)s
+    throw IfcException("Unable to find find keyword in schema");
+}
+"""
+
+entity_implementation = """// Function implementations for %(name)s
+%(attributes)s%(inverse)sbool %(name)s::is(Type::Enum v) const { return v == Type::%(name)s%(parent_type_test)s; }
+Type::Enum %(name)s::type() const { return Type::%(name)s; }
+Type::Enum %(name)s::Class() { return Type::%(name)s; }
+%(name)s::%(name)s(IfcAbstractEntityPtr e) : %(superclass)s { if (!e) return; if (!e->is(Type::%(name)s)) throw IfcException("Unable to find find keyword in schema"); entity = e; }
+%(name)s::%(name)s(%(constructor_arguments)s) : %(superclass)s { IfcWritableEntity* e = new IfcWritableEntity(Class());%(constructor_implementation)s entity = e; EntityBuffer::Add(this); }
+"""
+
+optional_attribute_description = "/// Whether the optional attribute %s is defined for this %s"
+
+function = "%(return_type)s %(class_name)s::%(name)s(%(arguments)s) { %(body)s }"
+
+array_type = "std::vector< %(instance_type)s > /*[%(lower)s:%(upper)s]*/"
+list_type = "SHARED_PTR< IfcTemplatedEntityList< %(instance_type)s > >"
+untyped_list = "IfcEntities"
+inverse_attr = "SHARED_PTR< IfcTemplatedEntityList< %(entity)s > > %(name)s(); // INVERSE %(entity)s::%(attribute)s"
+
+enum_from_string_stmt = '    if (s == "%(value)s") return ::%(schema_name)s::%(name)s::%(short_name)s_%(value)s;'
+
+schema_entity_stmt = '        case Type::%(name)s: return new %(name)s(e); break;'
+schema_simple_stmt = '        case Type::%(name)s: return new IfcUtil::IfcEntitySelect(e); break;'
+string_map_statement = '    string_map["%(uppercase_name)s"%(padding)s] = Type::%(name)s;'
+parent_type_stmt = '    if(v==%(name)s%(padding)s) { return %(parent)s; }'
+
+parent_type_test = " || %s::is(v)"
+
+optional_attr_stmt = "return !entity->getArgument(%(index)d)->isNull();"
+
+get_attr_stmt = "return *entity->getArgument(%(index)d);"
+get_attr_stmt_enum = "return %(type)s::FromString(*entity->getArgument(%(index)d));"
+get_attr_stmt_entity = "return (%(type)s)((IfcUtil::IfcSchemaEntity)(*entity->getArgument(%(index)d)));"
+get_attr_stmt_array = "RETURN_AS_LIST(%(list_instance_type)s,%(index)d)"
+
+get_inverse = "RETURN_INVERSE(%(type)s)"
+
+set_attr_stmt = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v);"
+set_attr_stmt_enum = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v,%(type)s::ToString(v));"
+set_attr_stmt_array = "if ( ! entity->isWritable() ) { entity = new IfcWritableEntity(entity); } ((IfcWritableEntity*)entity)->setArgument(%(index)d,v->generalize());"
+
+constructor_stmt = " e->setArgument(%(index)d,(%(name)s));"
+constructor_stmt_enum = " e->setArgument(%(index)d,%(name)s,%(type)s::ToString(%(name)s));"
+constructor_stmt_array = " e->setArgument(%(index)d,(%(name)s)->generalize());"
+constructor_stmt_optional = " if (%(name)s) {%(stmt)s } else { e->setArgument(%(index)d); }"
+constructor_stmt_derived = " e->setArgumentDerived(%(index)d);"
+
+def multi_line_comment(li):
+    return ("/// %s"%("\n/// ".join(li))) if len(li) else ""
+

src/ifcgeom/IfcGeom.h

@@ -86,9 +86,9 @@ namespace IfcGeom {
 	bool convert_wire(const IfcUtil::IfcBaseClass* L, TopoDS_Wire& result);
 	bool convert_curve(const IfcUtil::IfcBaseClass* L, Handle(Geom_Curve)& result);
 	bool convert_face(const IfcUtil::IfcBaseClass* L, TopoDS_Face& result);
-	bool convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	bool convert_openings(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
-	bool convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
+	bool convert_openings_fast(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes);
-	Ifc2x3::IfcSurfaceStyleShading* get_surface_style(Ifc2x3::IfcRepresentationItem* item);	
+	IfcSchema::IfcSurfaceStyleShading* get_surface_style(IfcSchema::IfcRepresentationItem* item);
 	bool create_solid_from_compound(const TopoDS_Shape& compound, TopoDS_Shape& solid);
 	bool is_compound(const TopoDS_Shape& shape);
 	bool is_convex(const TopoDS_Wire& wire);
@@ -102,7 +102,7 @@ namespace IfcGeom {
 	void apply_tolerance(TopoDS_Shape& s, double t);
 	void SetValue(GeomValue var, double value);
 	double GetValue(GeomValue var);
-	Ifc2x3::IfcProductDefinitionShape* tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es);
+	IfcSchema::IfcProductDefinitionShape* tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es);
 
 	
 	

src/ifcgeom/IfcGeomCurves.cpp

@@ -77,13 +77,13 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcCircle::ptr l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const IfcSchema::IfcCircle::ptr l, Handle(Geom_Curve)& curve) {
 	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	if ( r <= 0.0f ) { return false; }
 	gp_Trsf trsf;
-	Ifc2x3::IfcAxis2Placement placement = l->Position();
+	IfcSchema::IfcAxis2Placement placement = l->Position();
-	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
 		IfcGeom::convert((IfcAxis2Placement2D*)placement,trsf2d);
@@ -93,24 +93,24 @@ bool IfcGeom::convert(const Ifc2x3::IfcCircle::ptr l, Handle(Geom_Curve)& curve)
 	curve = new Geom_Circle(ax, r);
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcEllipse::ptr l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const IfcSchema::IfcEllipse::ptr l, Handle(Geom_Curve)& curve) {
 	double x = l->SemiAxis1() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	double y = l->SemiAxis2() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	if ( x == 0.0f || y == 0.0f || y > x ) { return false; }
 	gp_Trsf trsf;
-	Ifc2x3::IfcAxis2Placement placement = l->Position();
+	IfcSchema::IfcAxis2Placement placement = l->Position();
-	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement2D*)placement,trsf2d);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf2d);
 		trsf = trsf2d;
 	}
 	gp_Ax2 ax = gp_Ax2().Transformed(trsf);
 	curve = new Geom_Ellipse(ax, x, y);
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcLine::ptr l, Handle(Geom_Curve)& curve) {
+bool IfcGeom::convert(const IfcSchema::IfcLine::ptr l, Handle(Geom_Curve)& curve) {
 	gp_Pnt pnt;gp_Vec vec;
 	IfcGeom::convert(l->Pnt(),pnt);
 	IfcGeom::convert(l->Dir(),vec);	

src/ifcgeom/IfcGeomFaces.cpp

@@ -78,10 +78,10 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcFace::ptr l, TopoDS_Face& face) {
-	Ifc2x3::IfcFaceBound::list bounds = l->Bounds();
+	IfcSchema::IfcFaceBound::list bounds = l->Bounds();
-	Ifc2x3::IfcFaceBound::it it = bounds->begin();
+	IfcSchema::IfcFaceBound::it it = bounds->begin();
-	Ifc2x3::IfcLoop::ptr loop = (*it)->Bound();
+	IfcSchema::IfcLoop::ptr loop = (*it)->Bound();
 	TopoDS_Wire outer_wire;
 	if ( ! IfcGeom::convert_wire(loop,outer_wire) ) return false;
 	BRepBuilderAPI_MakeFace mf (outer_wire);
@@ -98,7 +98,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
 		face = mf.Face();
 	} else {
 		for( ++it; it != bounds->end(); ++ it) {
-			Ifc2x3::IfcLoop::ptr loop = (*it)->Bound();
+			IfcSchema::IfcLoop::ptr loop = (*it)->Bound();
 			TopoDS_Wire wire;
 			if ( ! IfcGeom::convert_wire(loop,wire) ) return false;
 			mf.Add(wire);
@@ -183,17 +183,17 @@ bool IfcGeom::convert(const Ifc2x3::IfcFace::ptr l, TopoDS_Face& face) {
 	// return face_area(face) > 0.0001;
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcArbitraryClosedProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcArbitraryClosedProfileDef::ptr l, TopoDS_Face& face) {
 	TopoDS_Wire wire;
 	if ( ! IfcGeom::convert_wire(l->OuterCurve(),wire) ) return false;
 	return IfcGeom::convert_wire_to_face(wire,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcArbitraryProfileDefWithVoids::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcArbitraryProfileDefWithVoids::ptr l, TopoDS_Face& face) {
 	TopoDS_Wire profile;
 	if ( ! IfcGeom::convert_wire(l->OuterCurve(),profile) ) return false;
 	BRepBuilderAPI_MakeFace mf(profile);
-	Ifc2x3::IfcCurve::list voids = l->InnerCurves();
+	IfcSchema::IfcCurve::list voids = l->InnerCurves();
-	for( Ifc2x3::IfcCurve::it it = voids->begin(); it != voids->end(); ++ it ) {
+	for( IfcSchema::IfcCurve::it it = voids->begin(); it != voids->end(); ++ it ) {
 		TopoDS_Wire hole;
 		if ( IfcGeom::convert_wire(*it,hole) ) {
 			mf.Add(hole);
@@ -204,7 +204,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcArbitraryProfileDefWithVoids::ptr l, Topo
 	face = TopoDS::Face(sfs.Shape());
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcRectangleProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcRectangleProfileDef::ptr l, TopoDS_Face& face) {
 	const double x = l->XDim() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double y = l->YDim() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
 
@@ -218,7 +218,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcRectangleProfileDef::ptr l, TopoDS_Face&
 	double coords[8] = {-x,-y,x,-y,x,y,-x,y};
 	return IfcGeom::profile_helper(4,coords,0,0,0,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcIShapeProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcIShapeProfileDef::ptr l, TopoDS_Face& face) {
 	const double x = l->OverallWidth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double y = l->OverallDepth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double d1 = l->WebThickness() / 2.0f  * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -242,7 +242,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcIShapeProfileDef::ptr l, TopoDS_Face& fac
 	double radii[4] = {f,f,f,f};
 	return IfcGeom::profile_helper(12,coords,doFillet ? 4 : 0,fillets,radii,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCShapeProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcCShapeProfileDef::ptr l, TopoDS_Face& face) {
 	const double x = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double y = l->Width() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double d1 = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -267,7 +267,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCShapeProfileDef::ptr l, TopoDS_Face& fac
 	double radii[8] = {f2,f2,f1,f1,f1,f1,f2,f2};
 	return IfcGeom::profile_helper(12,coords,doFillet ? 8 : 0,fillets,radii,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcLShapeProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcLShapeProfileDef::ptr l, TopoDS_Face& face) {
 	const double y = l->Depth() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double x = l->Width() / 2.0f * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double d = l->Thickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -294,7 +294,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcLShapeProfileDef::ptr l, TopoDS_Face& fac
 	double radii[3] = {f2,f1,f2};
 	return IfcGeom::profile_helper(6,coords,doFillet ? 3 : 0,fillets,radii,trsf2d,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCircleProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcCircleProfileDef::ptr l, TopoDS_Face& face) {
 	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	if ( r == 0.0f ) {
 		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
@@ -311,7 +311,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCircleProfileDef::ptr l, TopoDS_Face& fac
 	w.Add(edge);
 	return IfcGeom::convert_wire_to_face(w,face);
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCircleHollowProfileDef::ptr l, TopoDS_Face& face) {
+bool IfcGeom::convert(const IfcSchema::IfcCircleHollowProfileDef::ptr l, TopoDS_Face& face) {
 	const double r = l->Radius() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	const double t = l->WallThickness() * IfcGeom::GetValue(GV_LENGTH_UNIT);
 	

src/ifcgeom/IfcGeomFunctions.cpp

@@ -130,15 +130,15 @@ const TopoDS_Shape& IfcGeom::ensure_fit_for_subtraction(const TopoDS_Shape& shap
 	return solid;
 }
 
-bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, 
+bool IfcGeom::convert_openings(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, 
 							   const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes) {
 	// Iterate over IfcOpeningElements
 	IfcGeom::IfcRepresentationShapeItems opening_shapes;
 	unsigned int last_size = 0;
-	for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
+	for ( IfcSchema::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
-		Ifc2x3::IfcRelVoidsElement::ptr v = *it;
+		IfcSchema::IfcRelVoidsElement::ptr v = *it;
-		Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
+		IfcSchema::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
-		if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) {
+		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
 			gp_Trsf opening_trsf;
@@ -147,10 +147,10 @@ bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x
 			// Move the opening into the coordinate system of the IfcProduct
 			opening_trsf.PreMultiply(entity_trsf.Inverted());
 
-			Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation();
+			IfcSchema::IfcProductRepresentation::ptr prodrep = fes->Representation();
-			Ifc2x3::IfcRepresentation::list reps = prodrep->Representations();
+			IfcSchema::IfcRepresentation::list reps = prodrep->Representations();
 						
-			for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+			for ( IfcSchema::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
 				IfcGeom::convert_shapes(*it2,opening_shapes);
 			}
 
@@ -224,7 +224,7 @@ bool IfcGeom::convert_openings(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x
 	return true;
 }
 
-bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const Ifc2x3::IfcRelVoidsElement::list& openings, 
+bool IfcGeom::convert_openings_fast(const IfcSchema::IfcProduct::ptr entity, const IfcSchema::IfcRelVoidsElement::list& openings, 
 							   const IfcRepresentationShapeItems& entity_shapes, const gp_Trsf& entity_trsf, IfcRepresentationShapeItems& cut_shapes) {
 	
 	// Create a compound of all opening shapes in order to speed up the boolean operations
@@ -232,10 +232,10 @@ bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const
 	BRep_Builder builder;
 	builder.MakeCompound(opening_compound);
 
-	for ( Ifc2x3::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
+	for ( IfcSchema::IfcRelVoidsElement::it it = openings->begin(); it != openings->end(); ++ it ) {
-		Ifc2x3::IfcRelVoidsElement::ptr v = *it;
+		IfcSchema::IfcRelVoidsElement::ptr v = *it;
-		Ifc2x3::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
+		IfcSchema::IfcFeatureElementSubtraction::ptr fes = v->RelatedOpeningElement();
-		if ( fes->is(Ifc2x3::Type::IfcOpeningElement) ) {
+		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
 			gp_Trsf opening_trsf;
@@ -244,12 +244,12 @@ bool IfcGeom::convert_openings_fast(const Ifc2x3::IfcProduct::ptr entity, const
 			// Move the opening into the coordinate system of the IfcProduct
 			opening_trsf.PreMultiply(entity_trsf.Inverted());
 
-			Ifc2x3::IfcProductRepresentation::ptr prodrep = fes->Representation();
+			IfcSchema::IfcProductRepresentation::ptr prodrep = fes->Representation();
-			Ifc2x3::IfcRepresentation::list reps = prodrep->Representations();
+			IfcSchema::IfcRepresentation::list reps = prodrep->Representations();
 
 			IfcGeom::IfcRepresentationShapeItems opening_shapes;
 						
-			for ( Ifc2x3::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
+			for ( IfcSchema::IfcRepresentation::it it2 = reps->begin(); it2 != reps->end(); ++ it2 ) {
 				IfcGeom::convert_shapes(*it2,opening_shapes);
 			}
 
@@ -501,10 +501,10 @@ double IfcGeom::GetValue(GeomValue var) {
 	return 0;
 }
 
-Ifc2x3::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es) {
+IfcSchema::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, double deflection, IfcEntities es) {
 	BRepMesh::Mesh(shape, deflection);
 
-	Ifc2x3::IfcFace::list faces (new IfcTemplatedEntityList<Ifc2x3::IfcFace>());
+	IfcSchema::IfcFace::list faces (new IfcTemplatedEntityList<IfcSchema::IfcFace>());
 
 	for (TopExp_Explorer exp(shape, TopAbs_FACE); exp.More(); exp.Next()) {
 		const TopoDS_Face& face = TopoDS::Face(exp.Current());
@@ -513,11 +513,11 @@ Ifc2x3::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, doubl
 
 		if (! tri.IsNull()) {
 			const TColgp_Array1OfPnt& nodes = tri->Nodes();
-			std::vector<Ifc2x3::IfcCartesianPoint*> vertices;
+			std::vector<IfcSchema::IfcCartesianPoint*> vertices;
 			for (int i = 1; i <= nodes.Length(); ++i) {
 				const gp_Pnt& pnt = nodes(i);
 				std::vector<double> xyz; xyz.push_back(pnt.X()); xyz.push_back(pnt.Y()); xyz.push_back(pnt.Z());
-				Ifc2x3::IfcCartesianPoint* cpnt = new Ifc2x3::IfcCartesianPoint(xyz);
+				IfcSchema::IfcCartesianPoint* cpnt = new IfcSchema::IfcCartesianPoint(xyz);
 				vertices.push_back(cpnt);
 				es->push(cpnt);
 			}
@@ -525,15 +525,15 @@ Ifc2x3::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, doubl
 			for (int i = 1; i <= triangles.Length(); ++ i) {
 				int n1, n2, n3;
 				triangles(i).Get(n1, n2, n3);
-				Ifc2x3::IfcCartesianPoint::list points (new IfcTemplatedEntityList<Ifc2x3::IfcCartesianPoint>());
+				IfcSchema::IfcCartesianPoint::list points (new IfcTemplatedEntityList<IfcSchema::IfcCartesianPoint>());
 				points->push(vertices[n1-1]);
 				points->push(vertices[n2-1]);
 				points->push(vertices[n3-1]);
-				Ifc2x3::IfcPolyLoop* loop = new Ifc2x3::IfcPolyLoop(points);
+				IfcSchema::IfcPolyLoop* loop = new IfcSchema::IfcPolyLoop(points);
-				Ifc2x3::IfcFaceOuterBound* bound = new Ifc2x3::IfcFaceOuterBound(loop, face.Orientation() != TopAbs_REVERSED);
+				IfcSchema::IfcFaceOuterBound* bound = new IfcSchema::IfcFaceOuterBound(loop, face.Orientation() != TopAbs_REVERSED);
-				Ifc2x3::IfcFaceBound::list bounds (new IfcTemplatedEntityList<Ifc2x3::IfcFaceBound>());
+				IfcSchema::IfcFaceBound::list bounds (new IfcTemplatedEntityList<IfcSchema::IfcFaceBound>());
 				bounds->push(bound);
-				Ifc2x3::IfcFace* face = new Ifc2x3::IfcFace(bounds);
+				IfcSchema::IfcFace* face = new IfcSchema::IfcFace(bounds);
 				es->push(loop);
 				es->push(bound);
 				es->push(face);
@@ -541,21 +541,21 @@ Ifc2x3::IfcProductDefinitionShape* IfcGeom::tesselate(TopoDS_Shape& shape, doubl
 			}
 		}
 	}
-	Ifc2x3::IfcOpenShell* shell = new Ifc2x3::IfcOpenShell(faces);
+	IfcSchema::IfcOpenShell* shell = new IfcSchema::IfcOpenShell(faces);
-	Ifc2x3::IfcConnectedFaceSet::list shells (new IfcTemplatedEntityList<Ifc2x3::IfcConnectedFaceSet>());
+	IfcSchema::IfcConnectedFaceSet::list shells (new IfcTemplatedEntityList<IfcSchema::IfcConnectedFaceSet>());
 	shells->push(shell);
-	Ifc2x3::IfcFaceBasedSurfaceModel* surface_model = new Ifc2x3::IfcFaceBasedSurfaceModel(shells);
+	IfcSchema::IfcFaceBasedSurfaceModel* surface_model = new IfcSchema::IfcFaceBasedSurfaceModel(shells);
 
-	Ifc2x3::IfcRepresentation::list reps (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentation>());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	Ifc2x3::IfcRepresentationItem::list items (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentationItem>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 
 	items->push(surface_model);
 
-	Ifc2x3::IfcShapeRepresentation* rep = new Ifc2x3::IfcShapeRepresentation(
+	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
 		0, std::string("Facetation"), std::string("SurfaceModel"), items);
 
 	reps->push(rep);
-	Ifc2x3::IfcProductDefinitionShape* shapedef = new Ifc2x3::IfcProductDefinitionShape(0, 0, reps);
+	IfcSchema::IfcProductDefinitionShape* shapedef = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);
 
 	es->push(shell);
 	es->push(surface_model);

src/ifcgeom/IfcGeomHelpers.cpp

@@ -87,7 +87,7 @@ namespace IfcGeom {
 	if ( it != Cache::T.end() ) { e = it->second; return true; }
 #define CACHE(T,E,e) Cache::T[E->entity->id()] = e;
 
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianPoint::ptr l, gp_Pnt& point) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianPoint::ptr l, gp_Pnt& point) {
 	IN_CACHE(IfcCartesianPoint,l,gp_Pnt,point)
 	std::vector<double> xyz = l->Coordinates();
 	point = gp_Pnt(
@@ -98,7 +98,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianPoint::ptr l, gp_Pnt& point) {
 	CACHE(IfcCartesianPoint,l,point)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr l, gp_Dir& dir) {
+bool IfcGeom::convert(const IfcSchema::IfcDirection::ptr l, gp_Dir& dir) {
 	IN_CACHE(IfcDirection,l,gp_Dir,dir)
 	std::vector<double> xyz = l->DirectionRatios();
 	dir = gp_Dir(
@@ -109,7 +109,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcDirection::ptr l, gp_Dir& dir) {
 	CACHE(IfcDirection,l,dir)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcVector::ptr l, gp_Vec& v) {
+bool IfcGeom::convert(const IfcSchema::IfcVector::ptr l, gp_Vec& v) {
 	IN_CACHE(IfcVector,l,gp_Vec,v)
 	gp_Dir d;
 	IfcGeom::convert(l->Orientation(),d);
@@ -117,7 +117,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcVector::ptr l, gp_Vec& v) {
 	CACHE(IfcVector,l,v)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
 	IN_CACHE(IfcAxis2Placement3D,l,gp_Trsf,trsf)
 	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
 	IfcGeom::convert(l->Location(),o);
@@ -131,7 +131,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement3D::ptr l, gp_Trsf& trsf) {
 	CACHE(IfcAxis2Placement3D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3D::ptr l, gp_Trsf& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator3D::ptr l, gp_Trsf& trsf) {
 	IN_CACHE(IfcCartesianTransformationOperator3D,l,gp_Trsf,trsf)
 	gp_Pnt origin;
 	IfcGeom::convert(l->LocalOrigin(),origin);
@@ -150,7 +150,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3D::ptr l,
 	CACHE(IfcCartesianTransformationOperator3D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2D::ptr l, gp_Trsf2d& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator2D::ptr l, gp_Trsf2d& trsf) {
 	IN_CACHE(IfcCartesianTransformationOperator2D,l,gp_Trsf2d,trsf)
 	gp_Pnt origin;
 	IfcGeom::convert(l->LocalOrigin(),origin);
@@ -163,7 +163,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2D::ptr l,
 	CACHE(IfcCartesianTransformationOperator2D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3DnonUniform::ptr l, gp_GTrsf& gtrsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator3DnonUniform::ptr l, gp_GTrsf& gtrsf) {
 	IN_CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gp_GTrsf,gtrsf)
 	gp_Trsf trsf;
 	gp_Pnt origin;
@@ -190,7 +190,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator3DnonUnifo
 	CACHE(IfcCartesianTransformationOperator3DnonUniform,l,gtrsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2DnonUniform::ptr l, gp_GTrsf2d& gtrsf) {
+bool IfcGeom::convert(const IfcSchema::IfcCartesianTransformationOperator2DnonUniform::ptr l, gp_GTrsf2d& gtrsf) {
 	IN_CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gp_GTrsf2d,gtrsf)
 	gp_Trsf2d trsf;
 	gp_Pnt origin;
@@ -209,9 +209,9 @@ bool IfcGeom::convert(const Ifc2x3::IfcCartesianTransformationOperator2DnonUnifo
 	CACHE(IfcCartesianTransformationOperator2DnonUniform,l,gtrsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr pln, gp_Pln& plane) {
+bool IfcGeom::convert(const IfcSchema::IfcPlane::ptr pln, gp_Pln& plane) {
 	IN_CACHE(IfcPlane,pln,gp_Pln,plane)
-	Ifc2x3::IfcAxis2Placement3D::ptr l = pln->Position();
+	IfcSchema::IfcAxis2Placement3D::ptr l = pln->Position();
 	gp_Pnt o;gp_Dir axis = gp_Dir(0,0,1);gp_Dir refDirection;
 	IfcGeom::convert(l->Location(),o);
 	bool hasRef = l->hasRefDirection();
@@ -224,7 +224,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcPlane::ptr pln, gp_Pln& plane) {
 	CACHE(IfcPlane,pln,plane)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf) {
 	IN_CACHE(IfcAxis2Placement2D,l,gp_Trsf2d,trsf)
 	gp_Pnt P; gp_Dir V (1,0,0);
 	IfcGeom::convert(l->Location(),P);
@@ -236,21 +236,21 @@ bool IfcGeom::convert(const Ifc2x3::IfcAxis2Placement2D::ptr l, gp_Trsf2d& trsf)
 	CACHE(IfcAxis2Placement2D,l,trsf)
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcObjectPlacement::ptr l, gp_Trsf& trsf) {
+bool IfcGeom::convert(const IfcSchema::IfcObjectPlacement::ptr l, gp_Trsf& trsf) {
 	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
-	if ( ! l->is(Ifc2x3::Type::IfcLocalPlacement) ) return false;
+	if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) return false;
-	Ifc2x3::IfcLocalPlacement::ptr current = reinterpret_pointer_cast<Ifc2x3::IfcObjectPlacement,Ifc2x3::IfcLocalPlacement>(l);
+	IfcSchema::IfcLocalPlacement::ptr current = reinterpret_pointer_cast<IfcSchema::IfcObjectPlacement,IfcSchema::IfcLocalPlacement>(l);
 	while (1) {
 		gp_Trsf trsf2;
-		Ifc2x3::IfcAxis2Placement relplacement = current->RelativePlacement();
+		IfcSchema::IfcAxis2Placement relplacement = current->RelativePlacement();
-		if ( relplacement->is(Ifc2x3::Type::IfcAxis2Placement3D) ) {
+		if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {
-			IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)relplacement,trsf2);
+			IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
 			trsf.PreMultiply(trsf2);
 		}
 		if ( current->hasPlacementRelTo() ) {
-			Ifc2x3::IfcObjectPlacement::ptr relto = current->PlacementRelTo();
+			IfcSchema::IfcObjectPlacement::ptr relto = current->PlacementRelTo();
-			if ( relto->is(Ifc2x3::Type::IfcLocalPlacement) )
+			if ( relto->is(IfcSchema::Type::IfcLocalPlacement) )
-				current = reinterpret_pointer_cast<Ifc2x3::IfcObjectPlacement,Ifc2x3::IfcLocalPlacement>(current->PlacementRelTo());
+				current = reinterpret_pointer_cast<IfcSchema::IfcObjectPlacement,IfcSchema::IfcLocalPlacement>(current->PlacementRelTo());
 			else break;			
 		} else break;
 	}

src/ifcgeom/IfcGeomObjects.cpp

@@ -266,8 +266,8 @@ IfcGeomObjects::IfcGeomObject::IfcGeomObject(
 {}
 
 // A container and iterator for IfcShapeRepresentations
-static Ifc2x3::IfcShapeRepresentation::list shapereps;
+static IfcSchema::IfcShapeRepresentation::list shapereps;
-static Ifc2x3::IfcShapeRepresentation::it shaperep_iterator;
+static IfcSchema::IfcShapeRepresentation::it shaperep_iterator;
 
 // The object is fetched beforehand to be positive an entity actually exists
 static IfcGeomObjects::IfcGeomObject* current_geom_obj = 0;
@@ -275,8 +275,8 @@ static IfcGeomObjects::IfcGeomShapeModelObject* current_shape_model_obj = 0;
 static IfcGeomObjects::IfcGeomBrepDataObject* current_brep_data_obj = 0;
 
 // A container and iterator for IfcBuildingElements for the current IfcShapeRepresentation referenced by *shaperep_iterator
-static Ifc2x3::IfcProduct::list entities;
+static IfcSchema::IfcProduct::list entities;
-static Ifc2x3::IfcProduct::it ifcproduct_iterator;
+static IfcSchema::IfcProduct::it ifcproduct_iterator;
 
 static int done;
 static int total;
@@ -288,44 +288,53 @@ void _nextShape() {
 	++ done;
 }
 
-int _getParentId(const Ifc2x3::IfcProduct::ptr ifc_product) {
+int _getParentId(const IfcSchema::IfcProduct::ptr ifc_product) {
 	int parent_id = -1;
 	// In case of an opening element, parent to the RelatingBuildingElement
-	if ( ifc_product->is(Ifc2x3::Type::IfcOpeningElement ) ) {
+	if ( ifc_product->is(IfcSchema::Type::IfcOpeningElement ) ) {
-		Ifc2x3::IfcOpeningElement::ptr opening = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcOpeningElement>(ifc_product);
+		IfcSchema::IfcOpeningElement::ptr opening = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcOpeningElement>(ifc_product);
-		Ifc2x3::IfcRelVoidsElement::list voids = opening->VoidsElements();
+		IfcSchema::IfcRelVoidsElement::list voids = opening->VoidsElements();
 		if ( voids->Size() ) {
-			Ifc2x3::IfcRelVoidsElement::ptr ifc_void = *voids->begin();
+			IfcSchema::IfcRelVoidsElement::ptr ifc_void = *voids->begin();
 			parent_id = ifc_void->RelatingBuildingElement()->entity->id();
 		}
-	} else if ( ifc_product->is(Ifc2x3::Type::IfcElement ) ) {
+	} else if ( ifc_product->is(IfcSchema::Type::IfcElement ) ) {
-		Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
+		IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
-		Ifc2x3::IfcRelFillsElement::list fills = element->FillsVoids();
+		IfcSchema::IfcRelFillsElement::list fills = element->FillsVoids();
 		// Incase of a RelatedBuildingElement parent to the opening element
 		if ( fills->Size() ) {
-			for ( Ifc2x3::IfcRelFillsElement::it it = fills->begin(); it != fills->end(); ++ it ) {
+			for ( IfcSchema::IfcRelFillsElement::it it = fills->begin(); it != fills->end(); ++ it ) {
-				Ifc2x3::IfcRelFillsElement::ptr fill = *it;
+				IfcSchema::IfcRelFillsElement::ptr fill = *it;
-				Ifc2x3::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
+				IfcSchema::IfcObjectDefinition* ifc_objectdef = fill->RelatingOpeningElement();
 				if ( ifc_product == ifc_objectdef ) continue;
 				parent_id = ifc_objectdef->entity->id();
 			}
 		} 
 		// Else simply parent to the containing structure
 		if ( parent_id == -1 ) {
-			Ifc2x3::IfcRelContainedInSpatialStructure::list parents = element->ContainedInStructure();
+			IfcSchema::IfcRelContainedInSpatialStructure::list parents = element->ContainedInStructure();
 			if ( parents->Size() ) {
-				Ifc2x3::IfcRelContainedInSpatialStructure::ptr parent = *parents->begin();
+				IfcSchema::IfcRelContainedInSpatialStructure::ptr parent = *parents->begin();
 				parent_id = parent->RelatingStructure()->entity->id();
 			}
 		}
 	}
 	// Parent decompositions to the RelatingObject
 	if ( parent_id == -1 ) {
-		IfcEntities parents = ifc_product->entity->getInverse(Ifc2x3::Type::IfcRelAggregates);
+		IfcEntities parents = ifc_product->entity->getInverse(IfcSchema::Type::IfcRelAggregates);
-		parents->push(ifc_product->entity->getInverse(Ifc2x3::Type::IfcRelNests));
+		parents->push(ifc_product->entity->getInverse(IfcSchema::Type::IfcRelNests));
 		for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) {
-			Ifc2x3::IfcRelDecomposes::ptr decompose = reinterpret_pointer_cast<IfcBaseClass,Ifc2x3::IfcRelDecomposes>(*it);
+			IfcSchema::IfcRelDecomposes::ptr decompose = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcRelDecomposes>(*it);
-			Ifc2x3::IfcObjectDefinition* ifc_objectdef = decompose->RelatingObject();
+			IfcSchema::IfcObjectDefinition* ifc_objectdef;
+#ifdef USE_IFC4
+			if (decompose->is(IfcSchema::Type::IfcRelAggregates)) {
+				ifc_objectdef = ((IfcSchema::IfcRelAggregates*)decompose)->RelatingObject();
+			} else {
+				continue;
+			}
+#else
+			ifc_objectdef = decompose->RelatingObject();
+#endif
 			if ( ifc_product == ifc_objectdef ) continue;
 			parent_id = ifc_objectdef->entity->id();
 		}
@@ -335,7 +344,7 @@ int _getParentId(const Ifc2x3::IfcProduct::ptr ifc_product) {
 
 IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 	while ( true ) {
-		Ifc2x3::IfcShapeRepresentation::ptr shaperep;
+		IfcSchema::IfcShapeRepresentation::ptr shaperep;
 
 		// Have we reached the end of our list of representations?
 		if ( shaperep_iterator == shapereps->end() ) {
@@ -356,11 +365,11 @@ IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 						continue;
 				}
 			}
-			Ifc2x3::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation();
+			IfcSchema::IfcProductRepresentation::list prodreps = shaperep->OfProductRepresentation();
-			entities = Ifc2x3::IfcProduct::list( new IfcTemplatedEntityList<Ifc2x3::IfcProduct>() );
+			entities = IfcSchema::IfcProduct::list( new IfcTemplatedEntityList<IfcSchema::IfcProduct>() );
-			for ( Ifc2x3::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
+			for ( IfcSchema::IfcProductRepresentation::it it = prodreps->begin(); it != prodreps->end(); ++it ) {
-				if ( (*it)->is(Ifc2x3::Type::IfcProductDefinitionShape) ) {
+				if ( (*it)->is(IfcSchema::Type::IfcProductDefinitionShape) ) {
-					Ifc2x3::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast<Ifc2x3::IfcProductRepresentation,Ifc2x3::IfcProductDefinitionShape>(*it);
+					IfcSchema::IfcProductDefinitionShape::ptr pds = reinterpret_pointer_cast<IfcSchema::IfcProductRepresentation,IfcSchema::IfcProductDefinitionShape>(*it);
 					entities->push(pds->ShapeOfProduct());
 				} else {
 					// http://buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcrepresentationresource/lexical/ifcproductrepresentation.htm
@@ -369,9 +378,9 @@ IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 
 					// IfcProductRepresentation also lacks the INVERSE relation to IfcProduct
 					// Let's find the IfcProducts that reference the IfcProductRepresentation anyway
-					IfcEntities products = (*it)->entity->getInverse(Ifc2x3::Type::IfcProduct);
+					IfcEntities products = (*it)->entity->getInverse(IfcSchema::Type::IfcProduct);
 					for ( IfcEntityList::it it = products->begin(); it != products->end(); ++ it ) {
-						entities->push(reinterpret_pointer_cast<IfcBaseClass,Ifc2x3::IfcProduct>(*it));
+						entities->push(reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcProduct>(*it));
 					}
 				}
 			}
@@ -396,7 +405,7 @@ IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 			continue;
 		}
 
-		Ifc2x3::IfcProduct::ptr ifc_product = *ifcproduct_iterator;
+		IfcSchema::IfcProduct::ptr ifc_product = *ifcproduct_iterator;
 
 		int parent_id = -1;
 		try {
@@ -413,19 +422,24 @@ IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 
 		// Does the IfcElement have any IfcOpenings?
 		// Note that openings for IfcOpeningElements are not processed
-		Ifc2x3::IfcRelVoidsElement::list openings = Ifc2x3::IfcRelVoidsElement::list();
+		IfcSchema::IfcRelVoidsElement::list openings = IfcSchema::IfcRelVoidsElement::list();
-		if ( ifc_product->is(Ifc2x3::Type::IfcElement) && !ifc_product->is(Ifc2x3::Type::IfcOpeningElement) ) {
+		if ( ifc_product->is(IfcSchema::Type::IfcElement) && !ifc_product->is(IfcSchema::Type::IfcOpeningElement) ) {
-			Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcElement>(ifc_product);
+			IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcElement>(ifc_product);
 			openings = element->HasOpenings();
 		}
 		// Is the IfcElement a decomposition of an IfcElement with any IfcOpeningElements?
-		if ( ifc_product->is(Ifc2x3::Type::IfcBuildingElementPart ) ) {
+		if ( ifc_product->is(IfcSchema::Type::IfcBuildingElementPart ) ) {
-			Ifc2x3::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<Ifc2x3::IfcProduct,Ifc2x3::IfcBuildingElementPart>(ifc_product);
+			IfcSchema::IfcBuildingElementPart::ptr part = reinterpret_pointer_cast<IfcSchema::IfcProduct,IfcSchema::IfcBuildingElementPart>(ifc_product);
-			Ifc2x3::IfcRelDecomposes::list decomposes = part->Decomposes();
+#ifdef USE_IFC4
-			for ( Ifc2x3::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+			IfcSchema::IfcRelAggregates::list decomposes = part->Decomposes();
-				Ifc2x3::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
+			for ( IfcSchema::IfcRelAggregates::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
-				if ( obdef->is(Ifc2x3::Type::IfcElement) ) {
+#else
-					Ifc2x3::IfcElement::ptr element = reinterpret_pointer_cast<Ifc2x3::IfcObjectDefinition,Ifc2x3::IfcElement>(obdef);
+			IfcSchema::IfcRelDecomposes::list decomposes = part->Decomposes();
+			for ( IfcSchema::IfcRelDecomposes::it it = decomposes->begin(); it != decomposes->end(); ++ it ) {
+#endif
+				IfcSchema::IfcObjectDefinition::ptr obdef = (*it)->RelatingObject();
+				if ( obdef->is(IfcSchema::Type::IfcElement) ) {
+					IfcSchema::IfcElement::ptr element = reinterpret_pointer_cast<IfcSchema::IfcObjectDefinition,IfcSchema::IfcElement>(obdef);
 					openings->push(element->HasOpenings());
 				}
 			}
@@ -464,7 +478,7 @@ IfcGeomObjects::IfcGeomShapeModelObject* create_shape_model_for_next_entity() {
 		}
 
 		return new IfcGeomObjects::IfcGeomShapeModelObject(ifc_product->entity->id(), parent_id, name, 
-			Ifc2x3::Type::ToString(ifc_product->type()), guid, trsf, shape);
+			IfcSchema::Type::ToString(ifc_product->type()), guid, trsf, shape);
 	}	
 }
 
@@ -525,8 +539,8 @@ const IfcGeomObjects::IfcObject* IfcGeomObjects::GetObject(int id) {
 	IfcObject* ifc_object = 0;
 	try {
 		const IfcParse::IfcEntity& ifc_entity = ifc_file->EntityById(id);
-		if ( ifc_entity->is(Ifc2x3::Type::IfcProduct) ) {
+		if ( ifc_entity->is(IfcSchema::Type::IfcProduct) ) {
-			Ifc2x3::IfcProduct::ptr ifc_product = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,Ifc2x3::IfcProduct>(ifc_entity);
+			IfcSchema::IfcProduct::ptr ifc_product = reinterpret_pointer_cast<IfcUtil::IfcBaseClass,IfcSchema::IfcProduct>(ifc_entity);
 			int parent_id = -1;
 			try {
 				parent_id = _getParentId(ifc_product);
@@ -537,7 +551,7 @@ const IfcGeomObjects::IfcObject* IfcGeomObjects::GetObject(int id) {
 				IfcGeom::convert(ifc_product->ObjectPlacement(),trsf);
 			} catch (...) {}
 			ifc_object = new IfcObject(ifc_product->entity->id(),parent_id,name,
-				Ifc2x3::Type::ToString(ifc_product->type()),ifc_product->GlobalId(),trsf);
+				IfcSchema::Type::ToString(ifc_product->type()),ifc_product->GlobalId(),trsf);
 		}
 	} catch(...) {}
 	if ( !ifc_object ) ifc_object = new IfcObject(-1,-1,"","","",gp_Trsf());
@@ -559,28 +573,28 @@ const IfcGeomObjects::IfcGeomBrepDataObject* IfcGeomObjects::GetBrepData() {
 	}
 	return current_brep_data_obj;
 }
-double UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v ) {
+double UnitPrefixToValue( IfcSchema::IfcSIPrefix::IfcSIPrefix v ) {
-	if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_EXA   ) return (double) 1e18;
+	if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_EXA   ) return (double) 1e18;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_PETA  ) return (double) 1e15;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_PETA  ) return (double) 1e15;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_TERA  ) return (double) 1e12;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_TERA  ) return (double) 1e12;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_GIGA  ) return (double) 1e9;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_GIGA  ) return (double) 1e9;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MEGA  ) return (double) 1e6;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MEGA  ) return (double) 1e6;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_KILO  ) return (double) 1e3;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_KILO  ) return (double) 1e3;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_HECTO ) return (double) 1e2;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_HECTO ) return (double) 1e2;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_DECA  ) return (double) 1;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_DECA  ) return (double) 1;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_DECI  ) return (double) 1e-1;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_DECI  ) return (double) 1e-1;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_CENTI ) return (double) 1e-2;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_CENTI ) return (double) 1e-2;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MILLI ) return (double) 1e-3;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MILLI ) return (double) 1e-3;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_MICRO ) return (double) 1e-6;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_MICRO ) return (double) 1e-6;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_NANO  ) return (double) 1e-9;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_NANO  ) return (double) 1e-9;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_PICO  ) return (double) 1e-12;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_PICO  ) return (double) 1e-12;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_FEMTO ) return (double) 1e-15;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_FEMTO ) return (double) 1e-15;
-	else if ( v == Ifc2x3::IfcSIPrefix::IfcSIPrefix_ATTO  ) return (double) 1e-18;
+	else if ( v == IfcSchema::IfcSIPrefix::IfcSIPrefix_ATTO  ) return (double) 1e-18;
 	else return 1.0f;
 }
 
 void IfcGeomObjects::InitPrecision() {
-	Ifc2x3::IfcGeometricRepresentationContext::list rep_contexts = ifc_file->EntitiesByType<Ifc2x3::IfcGeometricRepresentationContext>();
+	IfcSchema::IfcGeometricRepresentationContext::list rep_contexts = ifc_file->EntitiesByType<IfcSchema::IfcGeometricRepresentationContext>();
 	// Currently, IfcGeometricRepresentationContext aren't used as much as they should be
 	// in the evaluation of shape representations, hence, we try to find the one with the
 	// lowest precision. Typically, a value of 1e-5 is encountered. This value is applied
@@ -589,9 +603,9 @@ void IfcGeomObjects::InitPrecision() {
 	// one that is defined in the model file.
 	double lowest_precision_encountered = std::numeric_limits<double>::infinity();
 	bool any_precision_encountered = false;
-	for (Ifc2x3::IfcGeometricRepresentationContext::it it = rep_contexts->begin(); it != rep_contexts->end(); ++it) {
+	for (IfcSchema::IfcGeometricRepresentationContext::it it = rep_contexts->begin(); it != rep_contexts->end(); ++it) {
-		Ifc2x3::IfcGeometricRepresentationContext* rep_context = *it;
+		IfcSchema::IfcGeometricRepresentationContext* rep_context = *it;
-		if (rep_context->is(Ifc2x3::Type::IfcGeometricRepresentationSubContext)) continue;
+		if (rep_context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) continue;
 		if (rep_context->hasPrecision()) {
 			const double precision = rep_context->Precision();
 			if (precision < lowest_precision_encountered) {
@@ -613,19 +627,19 @@ void IfcGeomObjects::InitUnits() {
 	IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,1.0);
 	IfcGeom::SetValue(IfcGeom::GV_PLANEANGLE_UNIT,-1.0);
 	
-	Ifc2x3::IfcUnitAssignment::list unit_assignments = ifc_file->EntitiesByType<Ifc2x3::IfcUnitAssignment>();
+	IfcSchema::IfcUnitAssignment::list unit_assignments = ifc_file->EntitiesByType<IfcSchema::IfcUnitAssignment>();
 	IfcUtil::IfcAbstractSelect::list units = IfcUtil::IfcAbstractSelect::list();
 	if ( unit_assignments->Size() ) {
-		Ifc2x3::IfcUnitAssignment::ptr unit_assignment = *unit_assignments->begin();
+		IfcSchema::IfcUnitAssignment::ptr unit_assignment = *unit_assignments->begin();
 		units = unit_assignment->Units();
 	}
 	if ( ! units ) {
 		// No units eh... Since tolerances and deflection are specified internally in meters
 		// we will try to find another indication of the model size.
-		Ifc2x3::IfcExtrudedAreaSolid::list extrusions = ifc_file->EntitiesByType<Ifc2x3::IfcExtrudedAreaSolid>();
+		IfcSchema::IfcExtrudedAreaSolid::list extrusions = ifc_file->EntitiesByType<IfcSchema::IfcExtrudedAreaSolid>();
 		if ( ! extrusions->Size() ) return;
 		double max_height = -1.0f;
-		for ( Ifc2x3::IfcExtrudedAreaSolid::it it = extrusions->begin(); it != extrusions->end(); ++ it ) {
+		for ( IfcSchema::IfcExtrudedAreaSolid::it it = extrusions->begin(); it != extrusions->end(); ++ it ) {
 			const double depth = (*it)->Depth();
 			if ( depth > max_height ) max_height = depth;
 		}
@@ -636,44 +650,44 @@ void IfcGeomObjects::InitUnits() {
 		for ( IfcUtil::IfcAbstractSelect::it it = units->begin(); it != units->end(); ++ it ) {
 			std::string current_unit_name = "";
 			const IfcUtil::IfcAbstractSelect::ptr base = *it;
-			Ifc2x3::IfcSIUnit::ptr unit = Ifc2x3::IfcSIUnit::ptr();
+			IfcSchema::IfcSIUnit::ptr unit = IfcSchema::IfcSIUnit::ptr();
 			double value = 1.0f;
-			if ( base->is(Ifc2x3::Type::IfcConversionBasedUnit) ) {
+			if ( base->is(IfcSchema::Type::IfcConversionBasedUnit) ) {
-				const Ifc2x3::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcConversionBasedUnit>(base);
+				const IfcSchema::IfcConversionBasedUnit::ptr u = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcConversionBasedUnit>(base);
 				current_unit_name = u->Name();
-				const Ifc2x3::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor();
+				const IfcSchema::IfcMeasureWithUnit::ptr u2 = u->ConversionFactor();
-				Ifc2x3::IfcUnit u3 = u2->UnitComponent();
+				IfcSchema::IfcUnit u3 = u2->UnitComponent();
-				if ( u3->is(Ifc2x3::Type::IfcSIUnit) ) {
+				if ( u3->is(IfcSchema::Type::IfcSIUnit) ) {
-					unit = (Ifc2x3::IfcSIUnit*) u3;
+					unit = (IfcSchema::IfcSIUnit*) u3;
 				}
-				Ifc2x3::IfcValue v = u2->ValueComponent();
+				IfcSchema::IfcValue v = u2->ValueComponent();
 				IfcUtil::IfcArgumentSelect* v2 = (IfcUtil::IfcArgumentSelect*) v;
 				const double f = *v2->wrappedValue();
 				value *= f;
-			} else if ( base->is(Ifc2x3::Type::IfcSIUnit) ) {
+			} else if ( base->is(IfcSchema::Type::IfcSIUnit) ) {
-				unit = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcSIUnit>(base);
+				unit = reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcSIUnit>(base);
 			}
 			if ( unit ) {
 				if ( unit->hasPrefix() ) {
 					value *= UnitPrefixToValue(unit->Prefix());
 				}
-				Ifc2x3::IfcUnitEnum::IfcUnitEnum type = unit->UnitType();
+				IfcSchema::IfcUnitEnum::IfcUnitEnum type = unit->UnitType();
-				if ( type == Ifc2x3::IfcUnitEnum::IfcUnit_LENGTHUNIT ) {
+				if ( type == IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT ) {
 					IfcGeom::SetValue(IfcGeom::GV_LENGTH_UNIT,value);
 					if (current_unit_name.empty()) {
 						if (unit->hasPrefix()) {
-							current_unit_name = Ifc2x3::IfcSIPrefix::ToString(unit->Prefix());
+							current_unit_name = IfcSchema::IfcSIPrefix::ToString(unit->Prefix());
 						}
-						current_unit_name += Ifc2x3::IfcSIUnitName::ToString(unit->Name());
+						current_unit_name += IfcSchema::IfcSIUnitName::ToString(unit->Name());
 					}
 					unit_magnitude = value;
 					unit_name = current_unit_name;
-				} else if ( type == Ifc2x3::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT ) {
+				} else if ( type == IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT ) {
 					IfcGeom::SetValue(IfcGeom::GV_PLANEANGLE_UNIT,value);
 				}
 			}
 		}
-	} catch ( IfcException ex ) {
+	} catch ( IfcParse::IfcException ex ) {
 		Logger::Message(Logger::LOG_ERROR,ex.what());
 	}
 }
@@ -685,7 +699,7 @@ bool _Init() {
 	IfcGeomObjects::InitUnits();
 	IfcGeomObjects::InitPrecision();
 
-	shapereps = ifc_file->EntitiesByType<Ifc2x3::IfcShapeRepresentation>();
+	shapereps = ifc_file->EntitiesByType<IfcSchema::IfcShapeRepresentation>();
 	if ( ! shapereps ) return false;
 	
 	shaperep_iterator = shapereps->begin();

src/ifcgeom/IfcGeomRenderStyles.cpp

@@ -30,7 +30,7 @@ namespace IfcGeom {
 	}
 }
 
-bool process_colour(Ifc2x3::IfcColourRgb* colour, std::tr1::array<double, 3>& rgb) {
+bool process_colour(IfcSchema::IfcColourRgb* colour, std::tr1::array<double, 3>& rgb) {
 	if (colour != 0) {
 		rgb[0] = colour->Red();
 		rgb[1] = colour->Green();
@@ -47,20 +47,20 @@ bool process_colour(IfcUtil::IfcArgumentSelect* factor, std::tr1::array<double,
 	return factor != 0;
 }
 
-bool process_colour(Ifc2x3::IfcColourOrFactor colour_or_factor, std::tr1::array<double, 3>& rgb) {
+bool process_colour(IfcSchema::IfcColourOrFactor colour_or_factor, std::tr1::array<double, 3>& rgb) {
 	if (colour_or_factor == 0) {
 		return false;
-	} else if (colour_or_factor->is(Ifc2x3::Type::IfcColourRgb)) {
+	} else if (colour_or_factor->is(IfcSchema::Type::IfcColourRgb)) {
-		return process_colour(static_cast<Ifc2x3::IfcColourRgb*>(colour_or_factor), rgb);
+		return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
-	} else if (colour_or_factor->is(Ifc2x3::Type::IfcNormalisedRatioMeasure)) {
+	} else if (colour_or_factor->is(IfcSchema::Type::IfcNormalisedRatioMeasure)) {
 		return process_colour(static_cast<IfcUtil::IfcArgumentSelect*>(colour_or_factor), rgb);
 	} else {
 		return false;
 	}
 }
 
-const IfcGeom::SurfaceStyle* IfcGeom::get_style(Ifc2x3::IfcRepresentationItem* item) {
+const IfcGeom::SurfaceStyle* IfcGeom::get_style(IfcSchema::IfcRepresentationItem* item) {
-	std::pair<Ifc2x3::IfcSurfaceStyle*, Ifc2x3::IfcSurfaceStyleShading*> shading_styles = get_surface_style<Ifc2x3::IfcSurfaceStyleShading>(item);
+	std::pair<IfcSchema::IfcSurfaceStyle*, IfcSchema::IfcSurfaceStyleShading*> shading_styles = get_surface_style<IfcSchema::IfcSurfaceStyleShading>(item);
 	if (shading_styles.second == 0) {
 		return 0;
 	}
@@ -79,8 +79,8 @@ const IfcGeom::SurfaceStyle* IfcGeom::get_style(Ifc2x3::IfcRepresentationItem* i
 	if (process_colour(shading_styles.second->SurfaceColour(), rgb)) {
 		surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(rgb[0], rgb[1], rgb[2]));
 	}
-	if (shading_styles.second->is(Ifc2x3::Type::IfcSurfaceStyleRendering)) {
+	if (shading_styles.second->is(IfcSchema::Type::IfcSurfaceStyleRendering)) {
-		Ifc2x3::IfcSurfaceStyleRendering* rendering_style = static_cast<Ifc2x3::IfcSurfaceStyleRendering*>(shading_styles.second);
+		IfcSchema::IfcSurfaceStyleRendering* rendering_style = static_cast<IfcSchema::IfcSurfaceStyleRendering*>(shading_styles.second);
 		if (rendering_style->hasDiffuseColour() && process_colour(rendering_style->DiffuseColour(), rgb)) {
 			SurfaceStyle::ColorComponent diffuse = surface_style.Diffuse().get_value_or(SurfaceStyle::ColorComponent(1,1,1));
 			surface_style.Diffuse().reset(SurfaceStyle::ColorComponent(diffuse.R() * rgb[0], diffuse.G() * rgb[1], diffuse.B() * rgb[2]));
@@ -96,12 +96,12 @@ const IfcGeom::SurfaceStyle* IfcGeom::get_style(Ifc2x3::IfcRepresentationItem* i
 		}
 		if (rendering_style->hasSpecularHighlight()) {
 			IfcUtil::IfcArgumentSelect* highlight = static_cast<IfcUtil::IfcArgumentSelect*>(rendering_style->SpecularHighlight());
-			if (highlight->is(Ifc2x3::Type::IfcSpecularRoughness)) {
+			if (highlight->is(IfcSchema::Type::IfcSpecularRoughness)) {
 				double roughness = *highlight->wrappedValue();
 				if (roughness >= 1e-9) {
 					surface_style.Specularity().reset(1.0 / roughness);
 				}
-			} else if (highlight->is(Ifc2x3::Type::IfcSpecularRoughness)) {
+			} else if (highlight->is(IfcSchema::Type::IfcSpecularRoughness)) {
 				surface_style.Specularity().reset(*highlight->wrappedValue());
 			}
 		}

src/ifcgeom/IfcGeomRenderStyles.h

@@ -26,7 +26,11 @@
 #include <array>
 #endif
 
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
 #include "../ifcparse/Ifc2x3.h"
+#endif
 
 namespace IfcGeom {
 	class SurfaceStyle {
@@ -97,19 +101,29 @@ namespace IfcGeom {
 		boost::optional<double>& Specularity() { return specularity; }
 	};
 
-	template <typename T> std::pair<Ifc2x3::IfcSurfaceStyle*, T*> get_surface_style(Ifc2x3::IfcRepresentationItem* representation_item) {
+	template <typename T> std::pair<IfcSchema::IfcSurfaceStyle*, T*> get_surface_style(IfcSchema::IfcRepresentationItem* representation_item) {
-		Ifc2x3::IfcStyledItem::list styled_items = representation_item->StyledByItem();
+		IfcSchema::IfcStyledItem::list styled_items = representation_item->StyledByItem();
-		for (Ifc2x3::IfcStyledItem::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
+		for (IfcSchema::IfcStyledItem::it jt = styled_items->begin(); jt != styled_items->end(); ++jt) {
-			Ifc2x3::IfcPresentationStyleAssignment::list style_assignments = (*jt)->Styles();
+#ifdef USE_IFC4
-			for (Ifc2x3::IfcPresentationStyleAssignment::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+			IfcUtil::IfcAbstractSelect::list style_assignments = (*jt)->Styles();
-				IfcAbstractSelect::list styles = (*kt)->Styles();
+			for (IfcUtil::IfcAbstractSelect::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-				for (IfcAbstractSelect::it lt = styles->begin(); lt != styles->end(); ++lt) {
+				if (!(*kt)->is(IfcSchema::Type::IfcPresentationStyleAssignment)) {
-					IfcAbstractSelect::ptr style = *lt;
+					continue;
-					if (style->is(Ifc2x3::Type::IfcSurfaceStyle)) {
+				}
-						Ifc2x3::IfcSurfaceStyle* surface_style = (Ifc2x3::IfcSurfaceStyle*) style;
+				IfcSchema::IfcPresentationStyleAssignment::ptr style_assignment = (IfcSchema::IfcPresentationStyleAssignment::ptr) *kt;
-						if (surface_style->Side() != Ifc2x3::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
+#else
-							IfcAbstractSelect::list styles_elements = surface_style->Styles();
+			IfcSchema::IfcPresentationStyleAssignment::list style_assignments = (*jt)->Styles();
-							for (IfcAbstractSelect::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
+			for (IfcSchema::IfcPresentationStyleAssignment::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
+				IfcSchema::IfcPresentationStyleAssignment::ptr style_assignment = *kt;
+#endif
+				IfcUtil::IfcAbstractSelect::list styles = style_assignment->Styles();
+				for (IfcUtil::IfcAbstractSelect::it lt = styles->begin(); lt != styles->end(); ++lt) {
+					IfcUtil::IfcAbstractSelect::ptr style = *lt;
+					if (style->is(IfcSchema::Type::IfcSurfaceStyle)) {
+						IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
+						if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
+							IfcUtil::IfcAbstractSelect::list styles_elements = surface_style->Styles();
+							for (IfcUtil::IfcAbstractSelect::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
 								if ((*mt)->is(T::Class())) {
 									return std::make_pair(surface_style, (T*) *mt);
 								}
@@ -124,10 +138,10 @@ namespace IfcGeom {
 			break;
 		}
 
-		return std::make_pair<Ifc2x3::IfcSurfaceStyle*, T*>(0,0);
+		return std::make_pair<IfcSchema::IfcSurfaceStyle*, T*>(0,0);
 	}
 
-	const SurfaceStyle* get_style(Ifc2x3::IfcRepresentationItem* representation_item);
+	const SurfaceStyle* get_style(IfcSchema::IfcRepresentationItem* representation_item);
 	const SurfaceStyle* get_default_style(const std::string& ifc_type);
 	
 	namespace Cache {

src/ifcgeom/IfcGeomShapes.cpp

@@ -78,7 +78,7 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& shape) {
 	TopoDS_Face face;
 	if ( ! IfcGeom::convert_face(l->SweptArea(),face) ) return false;
 	const double height = l->Depth() * IfcGeom::GetValue(GV_LENGTH_UNIT);
@@ -92,7 +92,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcExtrudedAreaSolid::ptr l, TopoDS_Shape& s
 	shape.Move(trsf);
 	return ! shape.IsNull();
 }
-bool IfcGeom::convert(const Ifc2x3::IfcFacetedBrep::ptr l, IfcRepresentationShapeItems& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcFacetedBrep::ptr l, IfcRepresentationShapeItems& shape) {
 	TopoDS_Shape s;
 	if (IfcGeom::convert_shape(l->Outer(),s) ) {
 		shape.push_back(IfcRepresentationShapeItem(s, get_style(l->Outer())));
@@ -100,10 +100,10 @@ bool IfcGeom::convert(const Ifc2x3::IfcFacetedBrep::ptr l, IfcRepresentationShap
 	}
 	return false;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcFaceBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::convert(const IfcSchema::IfcFaceBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
-	Ifc2x3::IfcConnectedFaceSet::list facesets = l->FbsmFaces();
+	IfcSchema::IfcConnectedFaceSet::list facesets = l->FbsmFaces();
 	const SurfaceStyle* collective_style = get_style(l);
-	for( Ifc2x3::IfcConnectedFaceSet::it it = facesets->begin(); it != facesets->end(); ++ it ) {
+	for( IfcSchema::IfcConnectedFaceSet::it it = facesets->begin(); it != facesets->end(); ++ it ) {
 		TopoDS_Shape s;
 		const SurfaceStyle* shell_style = get_style(*it);
 		if (IfcGeom::convert_shape(*it,s)) {
@@ -112,21 +112,21 @@ bool IfcGeom::convert(const Ifc2x3::IfcFaceBasedSurfaceModel::ptr l, IfcRepresen
 	}
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcHalfSpaceSolid::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcHalfSpaceSolid::ptr l, TopoDS_Shape& shape) {
-	Ifc2x3::IfcSurface::ptr surface = l->BaseSurface();
+	IfcSchema::IfcSurface::ptr surface = l->BaseSurface();
-	if ( ! surface->is(Ifc2x3::Type::IfcPlane) ) {
+	if ( ! surface->is(IfcSchema::Type::IfcPlane) ) {
 		// Not implemented
 		return false;
 	}
 	gp_Pln pln;
-	IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcSurface,Ifc2x3::IfcPlane>(surface),pln);
+	IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcSurface,IfcSchema::IfcPlane>(surface),pln);
 	const gp_Pnt pnt = pln.Location().Translated( l->AgreementFlag() ? -pln.Axis().Direction() : pln.Axis().Direction());
 	shape = BRepPrimAPI_MakeHalfSpace(BRepBuilderAPI_MakeFace(pln),pnt).Solid();
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_Shape& shape) {
 	TopoDS_Shape halfspace;
-	if ( ! IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcPolygonalBoundedHalfSpace,Ifc2x3::IfcHalfSpaceSolid>(l),halfspace) ) return false;	
+	if ( ! IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcPolygonalBoundedHalfSpace,IfcSchema::IfcHalfSpaceSolid>(l),halfspace) ) return false;	
 	TopoDS_Wire wire;
 	if ( ! IfcGeom::convert_wire(l->PolygonalBoundary(),wire) || ! wire.Closed() ) return false;	
 	gp_Trsf trsf;
@@ -137,14 +137,14 @@ bool IfcGeom::convert(const Ifc2x3::IfcPolygonalBoundedHalfSpace::ptr l, TopoDS_
 	shape = BRepAlgoAPI_Common(halfspace,prism);
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcShellBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::convert(const IfcSchema::IfcShellBasedSurfaceModel::ptr l, IfcRepresentationShapeItems& shapes) {
 	IfcUtil::IfcAbstractSelect::list shells = l->SbsmBoundary();
 	const SurfaceStyle* collective_style = get_style(l);
 	for( IfcUtil::IfcAbstractSelect::it it = shells->begin(); it != shells->end(); ++ it ) {
 		TopoDS_Shape s;
 		const SurfaceStyle* shell_style = 0;
-		if ((*it)->is(Ifc2x3::Type::IfcRepresentationItem)) {
+		if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) {
-			shell_style = get_style((Ifc2x3::IfcRepresentationItem*)*it);
+			shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
 		}
 		if (IfcGeom::convert_shape(*it,s)) {
 			shapes.push_back(IfcRepresentationShapeItem(s, shell_style ? shell_style : collective_style));
@@ -152,12 +152,12 @@ bool IfcGeom::convert(const Ifc2x3::IfcShellBasedSurfaceModel::ptr l, IfcReprese
 	}
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcBooleanClippingResult::ptr l, TopoDS_Shape& shape) {
 	TopoDS_Shape s1, s2;
 	TopoDS_Wire boundary_wire;
-	Ifc2x3::IfcBooleanOperand operand1 = l->FirstOperand();
+	IfcSchema::IfcBooleanOperand operand1 = l->FirstOperand();
-	Ifc2x3::IfcBooleanOperand operand2 = l->SecondOperand();
+	IfcSchema::IfcBooleanOperand operand2 = l->SecondOperand();
-	bool is_halfspace = operand2->is(Ifc2x3::Type::IfcHalfSpaceSolid);
+	bool is_halfspace = operand2->is(IfcSchema::Type::IfcHalfSpaceSolid);
 
 	if ( ! IfcGeom::convert_shape(operand1,s1) )
 		return false;
@@ -205,8 +205,8 @@ bool IfcGeom::convert(const Ifc2x3::IfcBooleanClippingResult::ptr l, TopoDS_Shap
 
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& shape) {
+bool IfcGeom::convert(const IfcSchema::IfcConnectedFaceSet::ptr l, TopoDS_Shape& shape) {
-	Ifc2x3::IfcFace::list faces = l->CfsFaces();
+	IfcSchema::IfcFace::list faces = l->CfsFaces();
 	bool facesAdded = false;
 	const unsigned int num_faces = faces->Size();
 	if ( num_faces < GetValue(GV_MAX_FACES_TO_SEW) ) {
@@ -214,7 +214,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& sh
 		builder.SetTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
 		builder.SetMaxTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
 		builder.SetMinTolerance(GetValue(GV_POINT_EQUALITY_TOLERANCE));
-		for( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
+		for( IfcSchema::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
 			TopoDS_Face face;
 			if ( IfcGeom::convert_face(*it,face) && face_area(face) > GetValue(GV_MINIMAL_FACE_AREA) ) {
 				builder.Add(face);
@@ -235,7 +235,7 @@ bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& sh
 		TopoDS_Compound compound;
 		BRep_Builder builder;
 		builder.MakeCompound(compound);
-		for( Ifc2x3::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
+		for( IfcSchema::IfcFace::it it = faces->begin(); it != faces->end(); ++ it ) {
 			TopoDS_Face face;
 			if ( IfcGeom::convert_face(*it,face) && face_area(face) > GetValue(GV_MINIMAL_FACE_AREA) ) {
 				builder.Add(compound,face);
@@ -249,33 +249,33 @@ bool IfcGeom::convert(const Ifc2x3::IfcConnectedFaceSet::ptr l, TopoDS_Shape& sh
 	}
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcMappedItem::ptr l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::convert(const IfcSchema::IfcMappedItem::ptr l, IfcRepresentationShapeItems& shapes) {
 	gp_GTrsf gtrsf;
-	Ifc2x3::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget();
+	IfcSchema::IfcCartesianTransformationOperator::ptr transform = l->MappingTarget();
-	if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
+	if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
-		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
+		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
-			Ifc2x3::IfcCartesianTransformationOperator3DnonUniform>(transform),gtrsf);
+			IfcSchema::IfcCartesianTransformationOperator3DnonUniform>(transform),gtrsf);
-	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
 		return false;
-	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator3D) ) {
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
 		gp_Trsf trsf;
-		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
+		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
-			Ifc2x3::IfcCartesianTransformationOperator3D>(transform),trsf);
+			IfcSchema::IfcCartesianTransformationOperator3D>(transform),trsf);
 		gtrsf = trsf;
-	} else if ( transform->is(Ifc2x3::Type::IfcCartesianTransformationOperator2D) ) {
+	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
 		gp_Trsf2d trsf_2d;
-		IfcGeom::convert(reinterpret_pointer_cast<Ifc2x3::IfcCartesianTransformationOperator,
+		IfcGeom::convert(reinterpret_pointer_cast<IfcSchema::IfcCartesianTransformationOperator,
-			Ifc2x3::IfcCartesianTransformationOperator2D>(transform),trsf_2d);
+			IfcSchema::IfcCartesianTransformationOperator2D>(transform),trsf_2d);
 		gtrsf = (gp_Trsf) trsf_2d;
 	}
-	Ifc2x3::IfcRepresentationMap::ptr map = l->MappingSource();
+	IfcSchema::IfcRepresentationMap::ptr map = l->MappingSource();
-	Ifc2x3::IfcAxis2Placement placement = map->MappingOrigin();
+	IfcSchema::IfcAxis2Placement placement = map->MappingOrigin();
 	gp_Trsf trsf;
-	if (placement->is(Ifc2x3::Type::IfcAxis2Placement3D)) {
+	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement3D*)placement,trsf);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf_2d;
-		IfcGeom::convert((Ifc2x3::IfcAxis2Placement2D*)placement,trsf_2d);
+		IfcGeom::convert((IfcSchema::IfcAxis2Placement2D*)placement,trsf_2d);
 		trsf = trsf_2d;
 	}
 	gtrsf.Multiply(trsf);
@@ -287,11 +287,11 @@ bool IfcGeom::convert(const Ifc2x3::IfcMappedItem::ptr l, IfcRepresentationShape
 	return b;
 }
 
-bool IfcGeom::convert(const Ifc2x3::IfcShapeRepresentation::ptr l, IfcRepresentationShapeItems& shapes) {
+bool IfcGeom::convert(const IfcSchema::IfcShapeRepresentation::ptr l, IfcRepresentationShapeItems& shapes) {
-	Ifc2x3::IfcRepresentationItem::list items = l->Items();
+	IfcSchema::IfcRepresentationItem::list items = l->Items();
 	if ( ! items->Size() ) return false;
-	for ( Ifc2x3::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) {
+	for ( IfcSchema::IfcRepresentationItem::it it = items->begin(); it != items->end(); ++ it ) {
-		Ifc2x3::IfcRepresentationItem* representation_item = *it;
+		IfcSchema::IfcRepresentationItem* representation_item = *it;
 		if ( IfcGeom::is_shape_collection(representation_item) ) IfcGeom::convert_shapes(*it,shapes);
 		else {
 			TopoDS_Shape s;

src/ifcgeom/IfcGeomWires.cpp

@@ -82,7 +82,7 @@
 
 #include "../ifcgeom/IfcGeom.h"
 
-bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire) {
+bool IfcGeom::convert(const IfcSchema::IfcCompositeCurve::ptr l, TopoDS_Wire& wire) {
 	if ( IfcGeom::GetValue(GV_PLANEANGLE_UNIT)<0 ) {
 		Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l->entity);
 
@@ -138,11 +138,11 @@ bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire)
 
 		return use_radians || use_degrees;
 	}
-	Ifc2x3::IfcCompositeCurveSegment::list segments = l->Segments();
+	IfcSchema::IfcCompositeCurveSegment::list segments = l->Segments();
 	BRepBuilderAPI_MakeWire w;
 	//TopoDS_Vertex last_vertex;
-	for( Ifc2x3::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) {
+	for( IfcSchema::IfcCompositeCurveSegment::it it = segments->begin(); it != segments->end(); ++ it ) {
-		const Ifc2x3::IfcCurve::ptr curve = (*it)->ParentCurve();
+		const IfcSchema::IfcCurve::ptr curve = (*it)->ParentCurve();
 		TopoDS_Wire wire2;
 		if ( ! IfcGeom::convert_wire(curve,wire2) ) {
 			Logger::Message(Logger::LOG_ERROR,"Failed to convert curve:",curve->entity);
@@ -171,13 +171,13 @@ bool IfcGeom::convert(const Ifc2x3::IfcCompositeCurve::ptr l, TopoDS_Wire& wire)
 	wire = w.Wire();
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
+bool IfcGeom::convert(const IfcSchema::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
-	Ifc2x3::IfcCurve::ptr basis_curve = l->BasisCurve();
+	IfcSchema::IfcCurve::ptr basis_curve = l->BasisCurve();
-	bool isConic = basis_curve->is(Ifc2x3::Type::IfcConic);
+	bool isConic = basis_curve->is(IfcSchema::Type::IfcConic);
 	double parameterFactor = isConic ? IfcGeom::GetValue(GV_PLANEANGLE_UNIT) : IfcGeom::GetValue(GV_LENGTH_UNIT);
 	Handle(Geom_Curve) curve;
 	if ( ! IfcGeom::convert_curve(basis_curve,curve) ) return false;
-	bool trim_cartesian = l->MasterRepresentation() == Ifc2x3::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
+	bool trim_cartesian = l->MasterRepresentation() == IfcSchema::IfcTrimmingPreference::IfcTrimmingPreference_CARTESIAN;
 	IfcUtil::IfcAbstractSelect::list trims1 = l->Trim1();
 	IfcUtil::IfcAbstractSelect::list trims2 = l->Trim2();
 	bool trimmed1 = false;
@@ -190,10 +190,10 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 	BRepBuilderAPI_MakeWire w;
 	for ( IfcUtil::IfcAbstractSelect::it it = trims1->begin(); it != trims1->end(); it ++ ) {
 		const IfcUtil::IfcAbstractSelect::ptr i = *it;
-		if ( i->is(Ifc2x3::Type::IfcCartesianPoint) ) {
+		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
-			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcCartesianPoint>(i), pnts[sense_agreement] );
+			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcCartesianPoint>(i), pnts[sense_agreement] );
 			has_pnts[sense_agreement] = true;
-		} else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) {
+		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
 			const double value = *reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcUtil::IfcArgumentSelect>(i)->wrappedValue();
 			flts[sense_agreement] = value * parameterFactor;
 			has_flts[sense_agreement] = true;
@@ -201,10 +201,10 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 	}
 	for ( IfcUtil::IfcAbstractSelect::it it = trims2->begin(); it != trims2->end(); it ++ ) {
 		const IfcUtil::IfcAbstractSelect::ptr i = *it;
-		if ( i->is(Ifc2x3::Type::IfcCartesianPoint) ) {
+		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
-			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,Ifc2x3::IfcCartesianPoint>(i), pnts[1-sense_agreement] );
+			IfcGeom::convert(reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcSchema::IfcCartesianPoint>(i), pnts[1-sense_agreement] );
 			has_pnts[1-sense_agreement] = true;
-		} else if ( i->is(Ifc2x3::Type::IfcParameterValue) ) {
+		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
 			const double value = *reinterpret_pointer_cast<IfcUtil::IfcAbstractSelect,IfcUtil::IfcArgumentSelect>(i)->wrappedValue();
 			flts[1-sense_agreement] = value * parameterFactor;
 			has_flts[1-sense_agreement] = true;
@@ -238,8 +238,8 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 		// is defined by an IfcCartesianPoint and an IfcVector with Magnitude. Because
 		// the vector is normalised when passed to Geom_Line constructor the magnitude
 		// needs to be factored in with the IfcParameterValue here.
-		if ( basis_curve->is(Ifc2x3::Type::IfcLine) ) {
+		if ( basis_curve->is(IfcSchema::Type::IfcLine) ) {
-			Ifc2x3::IfcLine* line = static_cast<Ifc2x3::IfcLine*>(basis_curve);
+			IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
 			const double magnitude = line->Dir()->Magnitude();
 			flts[0] *= magnitude; flts[1] *= magnitude;
 		}
@@ -259,12 +259,12 @@ bool IfcGeom::convert(const Ifc2x3::IfcTrimmedCurve::ptr l, TopoDS_Wire& wire) {
 		return false;
 	}
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPolyline::ptr l, TopoDS_Wire& result) {
+bool IfcGeom::convert(const IfcSchema::IfcPolyline::ptr l, TopoDS_Wire& result) {
-	Ifc2x3::IfcCartesianPoint::list points = l->Points();
+	IfcSchema::IfcCartesianPoint::list points = l->Points();
 
 	BRepBuilderAPI_MakeWire w;
 	gp_Pnt P1;gp_Pnt P2;
-	for( Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
+	for( IfcSchema::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
 		IfcGeom::convert(*it,P2);
 		if ( it != points->begin() && ( !P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) )
 			w.Add(BRepBuilderAPI_MakeEdge(P1,P2));
@@ -274,13 +274,13 @@ bool IfcGeom::convert(const Ifc2x3::IfcPolyline::ptr l, TopoDS_Wire& result) {
 	result = w.Wire();
 	return true;
 }
-bool IfcGeom::convert(const Ifc2x3::IfcPolyLoop::ptr l, TopoDS_Wire& result) {
+bool IfcGeom::convert(const IfcSchema::IfcPolyLoop::ptr l, TopoDS_Wire& result) {
-	Ifc2x3::IfcCartesianPoint::list points = l->Polygon();
+	IfcSchema::IfcCartesianPoint::list points = l->Polygon();
 
 	BRepBuilderAPI_MakeWire w;
 	gp_Pnt P1;gp_Pnt P2;gp_Pnt F;
 	int count = 0;
-	for( Ifc2x3::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
+	for( IfcSchema::IfcCartesianPoint::it it = points->begin(); it != points->end(); ++ it ) {
 		IfcGeom::convert(*it,P2);
 		if ( it != points->begin() && ( !P1.IsEqual(P2,GetValue(GV_POINT_EQUALITY_TOLERANCE)) ) ) {
 			w.Add(BRepBuilderAPI_MakeEdge(P1,P2));

src/ifcgeom/IfcRegister.cpp

@@ -28,7 +28,7 @@ namespace IfcGeom {
 	}
 }
 
-using namespace Ifc2x3;
+using namespace IfcSchema;
 using namespace IfcUtil;
 
 bool IfcGeom::convert_shapes(const IfcBaseClass* l, IfcRepresentationShapeItems& r) {

src/ifcgeom/IfcRegister.h

@@ -41,7 +41,7 @@
 #include "../ifcparse/IfcUtil.h"
 #include "../ifcparse/IfcParse.h"
 
-using namespace Ifc2x3;
+using namespace IfcSchema;
 
 SHAPES(IfcShellBasedSurfaceModel);
 SHAPES(IfcFaceBasedSurfaceModel);

src/ifcparse/IfcGuidHelper.cpp

@@ -26,23 +26,17 @@
 
 #include <time.h>
 #include <stdlib.h>
-
-#define HAS_BOOST_UUID
-
-#ifdef HAS_BOOST_UUID
 #include <algorithm>
 
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
-#endif
 
-#include "IfcWrite.h"
+#include "../ifcparse/IfcWrite.h"
+#include "../ifcparse/IfcException.h"
 
 static const char* chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_$";
 
-#ifdef HAS_BOOST_UUID
-
 // Converts an unsigned integer into a base64 string of length l
 std::string base64(unsigned v, int l) {
     std::string r;
@@ -64,7 +58,7 @@ unsigned from_base64(const std::string& s) {
         for ( std::string::const_iterator i = s.begin()+zeros; i != s.end(); ++ i ) {
             r *= 64;
             const char* c = strchr(chars,*i);
-            if ( !c ) throw IfcException("Failed to decode GlobalId");
+            if ( !c ) throw IfcParse::IfcException("Failed to decode GlobalId");
             r += (c-chars);
         }
     return r;
@@ -95,10 +89,7 @@ void expand(const std::string& s, std::vector<unsigned char>& v) {
 // A random number generator for the UUID
 static boost::uuids::basic_random_generator<boost::mt19937> gen;
 
-#endif
-
 IfcWrite::IfcGuidHelper::IfcGuidHelper() {
-#ifdef HAS_BOOST_UUID
     boost::uuids::uuid u = gen();
     std::vector<unsigned char> v(u.size());
     std::copy(u.begin(), u.end(), v.begin());
@@ -108,13 +99,6 @@ IfcWrite::IfcGuidHelper::IfcGuidHelper() {
     expand(data,v2);
     boost::uuids::uuid u2;
     std::copy(v2.begin(), v2.end(), u2.begin());
-#else
-    if ( ! seeded ) { srand((unsigned int)time(0)); seeded = true; }
-	data.resize(length);
-	for ( unsigned int i = 0; i < length; ++ i ) {
-		data[i] = chars[rand()%strlen(chars)];
-	}
-#endif
 }
 IfcWrite::IfcGuidHelper::operator std::string() const {
 	return data;

src/ifcparse/IfcHierarchyHelper.cpp

@@ -29,56 +29,56 @@
 
 #include "../ifcparse/IfcHierarchyHelper.h"
 	
-Ifc2x3::IfcAxis2Placement3D* IfcHierarchyHelper::addPlacement3d(
+IfcSchema::IfcAxis2Placement3D* IfcHierarchyHelper::addPlacement3d(
 	double ox, double oy, double oz,
 	double zx, double zy, double zz,
 	double xx, double xy, double xz) 
 {
-		Ifc2x3::IfcDirection* x = addTriplet<Ifc2x3::IfcDirection>(xx, xy, xz);
+		IfcSchema::IfcDirection* x = addTriplet<IfcSchema::IfcDirection>(xx, xy, xz);
-		Ifc2x3::IfcDirection* z = addTriplet<Ifc2x3::IfcDirection>(zx, zy, zz);
+		IfcSchema::IfcDirection* z = addTriplet<IfcSchema::IfcDirection>(zx, zy, zz);
-		Ifc2x3::IfcCartesianPoint* o = addTriplet<Ifc2x3::IfcCartesianPoint>(ox, oy, oz);
+		IfcSchema::IfcCartesianPoint* o = addTriplet<IfcSchema::IfcCartesianPoint>(ox, oy, oz);
-		Ifc2x3::IfcAxis2Placement3D* p3d = new Ifc2x3::IfcAxis2Placement3D(o, z, x);
+		IfcSchema::IfcAxis2Placement3D* p3d = new IfcSchema::IfcAxis2Placement3D(o, z, x);
 		AddEntity(p3d);
 		return p3d;
 }
 
-Ifc2x3::IfcAxis2Placement2D* IfcHierarchyHelper::addPlacement2d(
+IfcSchema::IfcAxis2Placement2D* IfcHierarchyHelper::addPlacement2d(
 	double ox, double oy,
 	double xx, double xy) 
 {
-		Ifc2x3::IfcDirection* x = addDoublet<Ifc2x3::IfcDirection>(xx, xy);
+		IfcSchema::IfcDirection* x = addDoublet<IfcSchema::IfcDirection>(xx, xy);
-		Ifc2x3::IfcCartesianPoint* o = addDoublet<Ifc2x3::IfcCartesianPoint>(ox, oy);
+		IfcSchema::IfcCartesianPoint* o = addDoublet<IfcSchema::IfcCartesianPoint>(ox, oy);
-		Ifc2x3::IfcAxis2Placement2D* p2d = new Ifc2x3::IfcAxis2Placement2D(o, x);
+		IfcSchema::IfcAxis2Placement2D* p2d = new IfcSchema::IfcAxis2Placement2D(o, x);
 		AddEntity(p2d);
 		return p2d;
 }
 
-Ifc2x3::IfcLocalPlacement* IfcHierarchyHelper::addLocalPlacement(
+IfcSchema::IfcLocalPlacement* IfcHierarchyHelper::addLocalPlacement(
 	double ox, double oy, double oz,
 	double zx, double zy, double zz,
 	double xx, double xy, double xz) 
 {
-		Ifc2x3::IfcLocalPlacement* lp = new Ifc2x3::IfcLocalPlacement(0, 
+		IfcSchema::IfcLocalPlacement* lp = new IfcSchema::IfcLocalPlacement(0, 
 			addPlacement3d(ox, oy, oz, zx, zy, zz, xx, xy, xz));
 
 		AddEntity(lp);
 		return lp;
 }
 
-Ifc2x3::IfcOwnerHistory* IfcHierarchyHelper::addOwnerHistory() {
+IfcSchema::IfcOwnerHistory* IfcHierarchyHelper::addOwnerHistory() {
-	Ifc2x3::IfcPerson* person = new Ifc2x3::IfcPerson(boost::none, boost::none, std::string(""), 
+	IfcSchema::IfcPerson* person = new IfcSchema::IfcPerson(boost::none, boost::none, std::string(""), 
 		boost::none, boost::none, boost::none, boost::none, boost::none);
 
-	Ifc2x3::IfcOrganization* organization = new Ifc2x3::IfcOrganization(boost::none, 
+	IfcSchema::IfcOrganization* organization = new IfcSchema::IfcOrganization(boost::none, 
 		"IfcOpenShell", boost::none, boost::none, boost::none);
 
-	Ifc2x3::IfcPersonAndOrganization* person_and_org = new Ifc2x3::IfcPersonAndOrganization(person, organization, boost::none);
+	IfcSchema::IfcPersonAndOrganization* person_and_org = new IfcSchema::IfcPersonAndOrganization(person, organization, boost::none);
-	Ifc2x3::IfcApplication* application = new Ifc2x3::IfcApplication(organization, 
+	IfcSchema::IfcApplication* application = new IfcSchema::IfcApplication(organization, 
 		IFCOPENSHELL_VERSION, "IfcOpenShell", "IfcOpenShell");
 
 	int timestamp = (int) time(0);
-	Ifc2x3::IfcOwnerHistory* owner_hist = new Ifc2x3::IfcOwnerHistory(person_and_org, application, 
+	IfcSchema::IfcOwnerHistory* owner_hist = new IfcSchema::IfcOwnerHistory(person_and_org, application, 
-		boost::none, Ifc2x3::IfcChangeActionEnum::IfcChangeAction_ADDED, boost::none, person_and_org, application, timestamp);
+		boost::none, IfcSchema::IfcChangeActionEnum::IfcChangeAction_ADDED, boost::none, person_and_org, application, timestamp);
 
 	AddEntity(person);
 	AddEntity(organization);
@@ -89,30 +89,30 @@ Ifc2x3::IfcOwnerHistory* IfcHierarchyHelper::addOwnerHistory() {
 	return owner_hist;
 }
 	
-Ifc2x3::IfcProject* IfcHierarchyHelper::addProject(Ifc2x3::IfcOwnerHistory* owner_hist) {
+IfcSchema::IfcProject* IfcHierarchyHelper::addProject(IfcSchema::IfcOwnerHistory* owner_hist) {
-	Ifc2x3::IfcRepresentationContext::list rep_contexts (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentationContext>());
+	IfcSchema::IfcRepresentationContext::list rep_contexts (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationContext>());
-	Ifc2x3::IfcGeometricRepresentationContext* rep_context = new Ifc2x3::IfcGeometricRepresentationContext(
+	IfcSchema::IfcGeometricRepresentationContext* rep_context = new IfcSchema::IfcGeometricRepresentationContext(
-		std::string("Plan"), std::string("Model"), 3, 1e-5, addPlacement3d(), addTriplet<Ifc2x3::IfcDirection>(0, 1, 0));
+		std::string("Plan"), std::string("Model"), 3, 1e-5, addPlacement3d(), addTriplet<IfcSchema::IfcDirection>(0, 1, 0));
 
 	rep_contexts->push(rep_context);
 
 	IfcEntities units (new IfcEntityList());
-	Ifc2x3::IfcDimensionalExponents* dimexp = new Ifc2x3::IfcDimensionalExponents(0, 0, 0, 0, 0, 0, 0);
+	IfcSchema::IfcDimensionalExponents* dimexp = new IfcSchema::IfcDimensionalExponents(0, 0, 0, 0, 0, 0, 0);
-	Ifc2x3::IfcSIUnit* unit1 = new Ifc2x3::IfcSIUnit(Ifc2x3::IfcUnitEnum::IfcUnit_LENGTHUNIT, 
+	IfcSchema::IfcSIUnit* unit1 = new IfcSchema::IfcSIUnit(IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT, 
-		Ifc2x3::IfcSIPrefix::IfcSIPrefix_MILLI, Ifc2x3::IfcSIUnitName::IfcSIUnitName_METRE);
+		IfcSchema::IfcSIPrefix::IfcSIPrefix_MILLI, IfcSchema::IfcSIUnitName::IfcSIUnitName_METRE);
-	Ifc2x3::IfcSIUnit* unit2a = new Ifc2x3::IfcSIUnit(Ifc2x3::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT, 
+	IfcSchema::IfcSIUnit* unit2a = new IfcSchema::IfcSIUnit(IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT, 
-		boost::none, Ifc2x3::IfcSIUnitName::IfcSIUnitName_RADIAN);
+		boost::none, IfcSchema::IfcSIUnitName::IfcSIUnitName_RADIAN);
-	Ifc2x3::IfcMeasureWithUnit* unit2b = new Ifc2x3::IfcMeasureWithUnit(
+	IfcSchema::IfcMeasureWithUnit* unit2b = new IfcSchema::IfcMeasureWithUnit(
-		new IfcWrite::IfcSelectHelper(0.017453293, Ifc2x3::Type::IfcPlaneAngleMeasure), unit2a);
+		new IfcWrite::IfcSelectHelper(0.017453293, IfcSchema::Type::IfcPlaneAngleMeasure), unit2a);
-	Ifc2x3::IfcConversionBasedUnit* unit2 = new Ifc2x3::IfcConversionBasedUnit(dimexp, 
+	IfcSchema::IfcConversionBasedUnit* unit2 = new IfcSchema::IfcConversionBasedUnit(dimexp, 
-		Ifc2x3::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT, "Degrees", unit2b);
+		IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT, "Degrees", unit2b);
 
 	units->push(unit1);
 	units->push(unit2);
 
-	Ifc2x3::IfcUnitAssignment* unit_assignment = new Ifc2x3::IfcUnitAssignment(units);
+	IfcSchema::IfcUnitAssignment* unit_assignment = new IfcSchema::IfcUnitAssignment(units);
 
-	Ifc2x3::IfcProject* project = new Ifc2x3::IfcProject(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, boost::none, 
+	IfcSchema::IfcProject* project = new IfcSchema::IfcProject(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, boost::none, 
 		boost::none, boost::none, boost::none, rep_contexts, unit_assignment);
 
 	AddEntity(rep_context);
@@ -127,128 +127,128 @@ Ifc2x3::IfcProject* IfcHierarchyHelper::addProject(Ifc2x3::IfcOwnerHistory* owne
 	return project;
 }
 
-void IfcHierarchyHelper::relatePlacements(Ifc2x3::IfcProduct* parent, Ifc2x3::IfcProduct* product) {
+void IfcHierarchyHelper::relatePlacements(IfcSchema::IfcProduct* parent, IfcSchema::IfcProduct* product) {
-	Ifc2x3::IfcObjectPlacement* place = product->hasObjectPlacement() ? product->ObjectPlacement() : 0;
+	IfcSchema::IfcObjectPlacement* place = product->hasObjectPlacement() ? product->ObjectPlacement() : 0;
-	if (place && place->is(Ifc2x3::Type::IfcLocalPlacement)) {
+	if (place && place->is(IfcSchema::Type::IfcLocalPlacement)) {
-		Ifc2x3::IfcLocalPlacement* local_place = (Ifc2x3::IfcLocalPlacement*) place;
+		IfcSchema::IfcLocalPlacement* local_place = (IfcSchema::IfcLocalPlacement*) place;
 		if (parent->hasObjectPlacement()) {
 			local_place->setPlacementRelTo(parent->ObjectPlacement());
 		}
 	}
 }
 	
-Ifc2x3::IfcSite* IfcHierarchyHelper::addSite(Ifc2x3::IfcProject* proj, Ifc2x3::IfcOwnerHistory* owner_hist) {
+IfcSchema::IfcSite* IfcHierarchyHelper::addSite(IfcSchema::IfcProject* proj, IfcSchema::IfcOwnerHistory* owner_hist) {
 	if (! owner_hist) {
-		owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+		owner_hist = getSingle<IfcSchema::IfcOwnerHistory>();
 	}
 	if (! owner_hist) {
 		owner_hist = addOwnerHistory();
 	}
 	if (! proj) {
-		proj = getSingle<Ifc2x3::IfcProject>();
+		proj = getSingle<IfcSchema::IfcProject>();
 	}
 	if (! proj) {
 		proj = addProject(owner_hist);
 	}
 
-	Ifc2x3::IfcSite* site = new Ifc2x3::IfcSite(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, 
+	IfcSchema::IfcSite* site = new IfcSchema::IfcSite(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, 
 		boost::none, boost::none, addLocalPlacement(), 0, boost::none, 
-		Ifc2x3::IfcElementCompositionEnum::IfcElementComposition_ELEMENT, 
+		IfcSchema::IfcElementCompositionEnum::IfcElementComposition_ELEMENT, 
 		boost::none, boost::none, boost::none, boost::none, 0);
 
 	AddEntity(site);
-	addRelatedObject<Ifc2x3::IfcRelAggregates>(proj, site);
+	addRelatedObject<IfcSchema::IfcRelAggregates>(proj, site);
 	return site;
 }
 	
-Ifc2x3::IfcBuilding* IfcHierarchyHelper::addBuilding(Ifc2x3::IfcSite* site, Ifc2x3::IfcOwnerHistory* owner_hist) {
+IfcSchema::IfcBuilding* IfcHierarchyHelper::addBuilding(IfcSchema::IfcSite* site, IfcSchema::IfcOwnerHistory* owner_hist) {
 	if (! owner_hist) {
-		owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+		owner_hist = getSingle<IfcSchema::IfcOwnerHistory>();
 	}
 	if (! owner_hist) {
 		owner_hist = addOwnerHistory();
 	}
 	if (! site) {
-		site = getSingle<Ifc2x3::IfcSite>();
+		site = getSingle<IfcSchema::IfcSite>();
 	}
 	if (! site) {
 		site = addSite(0, owner_hist);
 	}
-	Ifc2x3::IfcBuilding* building = new Ifc2x3::IfcBuilding(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, boost::none, boost::none, 
+	IfcSchema::IfcBuilding* building = new IfcSchema::IfcBuilding(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, boost::none, boost::none, 
-		addLocalPlacement(), 0, boost::none, Ifc2x3::IfcElementCompositionEnum::IfcElementComposition_ELEMENT, 
+		addLocalPlacement(), 0, boost::none, IfcSchema::IfcElementCompositionEnum::IfcElementComposition_ELEMENT, 
 		boost::none, boost::none, 0);
 
 	AddEntity(building);
-	addRelatedObject<Ifc2x3::IfcRelAggregates>(site, building);
+	addRelatedObject<IfcSchema::IfcRelAggregates>(site, building);
 	relatePlacements(site, building);
 
 	return building;
 }
 
-Ifc2x3::IfcBuildingStorey* IfcHierarchyHelper::addBuildingStorey(Ifc2x3::IfcBuilding* building, 
+IfcSchema::IfcBuildingStorey* IfcHierarchyHelper::addBuildingStorey(IfcSchema::IfcBuilding* building, 
-	Ifc2x3::IfcOwnerHistory* owner_hist) 
+	IfcSchema::IfcOwnerHistory* owner_hist) 
 {
 	if (! owner_hist) {
-		owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+		owner_hist = getSingle<IfcSchema::IfcOwnerHistory>();
 	}
 	if (! owner_hist) {
 		owner_hist = addOwnerHistory();
 	}
 	if (! building) {
-		building = getSingle<Ifc2x3::IfcBuilding>();
+		building = getSingle<IfcSchema::IfcBuilding>();
 	}
 	if (! building) {
 		building = addBuilding(0, owner_hist);
 	}
-	Ifc2x3::IfcBuildingStorey* storey = new Ifc2x3::IfcBuildingStorey(IfcWrite::IfcGuidHelper(), 
+	IfcSchema::IfcBuildingStorey* storey = new IfcSchema::IfcBuildingStorey(IfcWrite::IfcGuidHelper(), 
 		owner_hist, boost::none, boost::none, boost::none, addLocalPlacement(), 0, boost::none, 
-		Ifc2x3::IfcElementCompositionEnum::IfcElementComposition_ELEMENT, boost::none);
+		IfcSchema::IfcElementCompositionEnum::IfcElementComposition_ELEMENT, boost::none);
 
 	AddEntity(storey);
-	addRelatedObject<Ifc2x3::IfcRelAggregates>(building, storey);
+	addRelatedObject<IfcSchema::IfcRelAggregates>(building, storey);
 	relatePlacements(building, storey);
 
 	return storey;
 }
 
-Ifc2x3::IfcBuildingStorey* IfcHierarchyHelper::addBuildingProduct(Ifc2x3::IfcProduct* product, 
+IfcSchema::IfcBuildingStorey* IfcHierarchyHelper::addBuildingProduct(IfcSchema::IfcProduct* product, 
-	Ifc2x3::IfcBuildingStorey* storey, Ifc2x3::IfcOwnerHistory* owner_hist) 
+	IfcSchema::IfcBuildingStorey* storey, IfcSchema::IfcOwnerHistory* owner_hist) 
 {
 	if (! owner_hist) {
-		owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+		owner_hist = getSingle<IfcSchema::IfcOwnerHistory>();
 	}
 	if (! owner_hist) {
 		owner_hist = addOwnerHistory();
 	}
 	if (! storey) {
-		storey = getSingle<Ifc2x3::IfcBuildingStorey>();
+		storey = getSingle<IfcSchema::IfcBuildingStorey>();
 	}
 	if (! storey) {
 		storey = addBuildingStorey(0, owner_hist);
 	}
 	AddEntity(product);
-	addRelatedObject<Ifc2x3::IfcRelContainedInSpatialStructure>(storey, product);
+	addRelatedObject<IfcSchema::IfcRelContainedInSpatialStructure>(storey, product);
 	relatePlacements(storey, product);
 	return storey;
 }
 
-void IfcHierarchyHelper::addExtrudedPolyline(Ifc2x3::IfcShapeRepresentation* rep, const std::vector<std::pair<double, double> >& points, double h, 
+void IfcHierarchyHelper::addExtrudedPolyline(IfcSchema::IfcShapeRepresentation* rep, const std::vector<std::pair<double, double> >& points, double h, 
-	Ifc2x3::IfcAxis2Placement2D* place, Ifc2x3::IfcAxis2Placement3D* place2, 
+	IfcSchema::IfcAxis2Placement2D* place, IfcSchema::IfcAxis2Placement3D* place2, 
-	Ifc2x3::IfcDirection* dir, Ifc2x3::IfcRepresentationContext* context) 
+	IfcSchema::IfcDirection* dir, IfcSchema::IfcRepresentationContext* context) 
 {
-	Ifc2x3::IfcCartesianPoint::list cartesian_points (new IfcTemplatedEntityList<Ifc2x3::IfcCartesianPoint>());
+	IfcSchema::IfcCartesianPoint::list cartesian_points (new IfcTemplatedEntityList<IfcSchema::IfcCartesianPoint>());
 	for (std::vector<std::pair<double, double> >::const_iterator i = points.begin(); i != points.end(); ++i) {
-		cartesian_points->push(addDoublet<Ifc2x3::IfcCartesianPoint>(i->first, i->second));
+		cartesian_points->push(addDoublet<IfcSchema::IfcCartesianPoint>(i->first, i->second));
 	}
 	if (cartesian_points->Size()) cartesian_points->push(*cartesian_points->begin());
-	Ifc2x3::IfcPolyline* line = new Ifc2x3::IfcPolyline(cartesian_points);
+	IfcSchema::IfcPolyline* line = new IfcSchema::IfcPolyline(cartesian_points);
-	Ifc2x3::IfcArbitraryClosedProfileDef* profile = new Ifc2x3::IfcArbitraryClosedProfileDef(
+	IfcSchema::IfcArbitraryClosedProfileDef* profile = new IfcSchema::IfcArbitraryClosedProfileDef(
-		Ifc2x3::IfcProfileTypeEnum::IfcProfileType_AREA, boost::none, line);
+		IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, boost::none, line);
 
-	Ifc2x3::IfcExtrudedAreaSolid* solid = new Ifc2x3::IfcExtrudedAreaSolid(
+	IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(
-		profile, place2 ? place2 : addPlacement3d(), dir ? dir : addTriplet<Ifc2x3::IfcDirection>(0, 0, 1), h);
+		profile, place2 ? place2 : addPlacement3d(), dir ? dir : addTriplet<IfcSchema::IfcDirection>(0, 0, 1), h);
 
-	Ifc2x3::IfcRepresentationItem::list items = rep->Items();
+	IfcSchema::IfcRepresentationItem::list items = rep->Items();
 	items->push(solid);
 	rep->setItems(items);
 
@@ -257,17 +257,17 @@ void IfcHierarchyHelper::addExtrudedPolyline(Ifc2x3::IfcShapeRepresentation* rep
 	AddEntity(solid);
 }
 
-Ifc2x3::IfcProductDefinitionShape* IfcHierarchyHelper::addExtrudedPolyline(const std::vector<std::pair<double, double> >& points, double h, 
+IfcSchema::IfcProductDefinitionShape* IfcHierarchyHelper::addExtrudedPolyline(const std::vector<std::pair<double, double> >& points, double h, 
-	Ifc2x3::IfcAxis2Placement2D* place, Ifc2x3::IfcAxis2Placement3D* place2, Ifc2x3::IfcDirection* dir, 
+	IfcSchema::IfcAxis2Placement2D* place, IfcSchema::IfcAxis2Placement3D* place2, IfcSchema::IfcDirection* dir, 
-	Ifc2x3::IfcRepresentationContext* context) 
+	IfcSchema::IfcRepresentationContext* context) 
 {
-	Ifc2x3::IfcRepresentation::list reps (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentation>());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	Ifc2x3::IfcRepresentationItem::list items (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentationItem>());
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
-	Ifc2x3::IfcShapeRepresentation* rep = new Ifc2x3::IfcShapeRepresentation(context 
+	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(context 
 		? context 
-		: getSingle<Ifc2x3::IfcRepresentationContext>(), std::string("Body"), std::string("SweptSolid"), items);
+		: getSingle<IfcSchema::IfcRepresentationContext>(), std::string("Body"), std::string("SweptSolid"), items);
 	reps->push(rep);
-	Ifc2x3::IfcProductDefinitionShape* shape = new Ifc2x3::IfcProductDefinitionShape(0, 0, reps);		
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);		
 	AddEntity(rep);
 	AddEntity(shape);
 	addExtrudedPolyline(rep, points, h, place, place2, dir, context);
@@ -275,19 +275,19 @@ Ifc2x3::IfcProductDefinitionShape* IfcHierarchyHelper::addExtrudedPolyline(const
 	return shape;
 }
 
-void IfcHierarchyHelper::addBox(Ifc2x3::IfcShapeRepresentation* rep, double w, double d, double h, 
+void IfcHierarchyHelper::addBox(IfcSchema::IfcShapeRepresentation* rep, double w, double d, double h, 
-	Ifc2x3::IfcAxis2Placement2D* place, Ifc2x3::IfcAxis2Placement3D* place2, 
+	IfcSchema::IfcAxis2Placement2D* place, IfcSchema::IfcAxis2Placement3D* place2, 
-	Ifc2x3::IfcDirection* dir, Ifc2x3::IfcRepresentationContext* context) 
+	IfcSchema::IfcDirection* dir, IfcSchema::IfcRepresentationContext* context) 
 {
 	if (false) {
-		Ifc2x3::IfcRectangleProfileDef* profile = new Ifc2x3::IfcRectangleProfileDef(
+		IfcSchema::IfcRectangleProfileDef* profile = new IfcSchema::IfcRectangleProfileDef(
-			Ifc2x3::IfcProfileTypeEnum::IfcProfileType_AREA, 0, place ? place : addPlacement2d(), w, d);
+			IfcSchema::IfcProfileTypeEnum::IfcProfileType_AREA, 0, place ? place : addPlacement2d(), w, d);
-		Ifc2x3::IfcExtrudedAreaSolid* solid = new Ifc2x3::IfcExtrudedAreaSolid(profile, 
+		IfcSchema::IfcExtrudedAreaSolid* solid = new IfcSchema::IfcExtrudedAreaSolid(profile, 
-			place2 ? place2 : addPlacement3d(), dir ? dir : addTriplet<Ifc2x3::IfcDirection>(0, 0, 1), h);
+			place2 ? place2 : addPlacement3d(), dir ? dir : addTriplet<IfcSchema::IfcDirection>(0, 0, 1), h);
 
 		AddEntity(profile);
 		AddEntity(solid);
-		Ifc2x3::IfcRepresentationItem::list items = rep->Items();
+		IfcSchema::IfcRepresentationItem::list items = rep->Items();
 		items->push(solid);
 		rep->setItems(items);
 	} else {
@@ -301,39 +301,39 @@ void IfcHierarchyHelper::addBox(Ifc2x3::IfcShapeRepresentation* rep, double w, d
 	}
 }
 
-Ifc2x3::IfcProductDefinitionShape* IfcHierarchyHelper::addBox(double w, double d, double h, Ifc2x3::IfcAxis2Placement2D* place, 
+IfcSchema::IfcProductDefinitionShape* IfcHierarchyHelper::addBox(double w, double d, double h, IfcSchema::IfcAxis2Placement2D* place, 
-	Ifc2x3::IfcAxis2Placement3D* place2, Ifc2x3::IfcDirection* dir, Ifc2x3::IfcRepresentationContext* context) 
+	IfcSchema::IfcAxis2Placement3D* place2, IfcSchema::IfcDirection* dir, IfcSchema::IfcRepresentationContext* context) 
 {
-	Ifc2x3::IfcRepresentation::list reps (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentation>());
+	IfcSchema::IfcRepresentation::list reps (new IfcTemplatedEntityList<IfcSchema::IfcRepresentation>());
-	Ifc2x3::IfcRepresentationItem::list items (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentationItem>());		
+	IfcSchema::IfcRepresentationItem::list items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());		
-	Ifc2x3::IfcShapeRepresentation* rep = new Ifc2x3::IfcShapeRepresentation(
+	IfcSchema::IfcShapeRepresentation* rep = new IfcSchema::IfcShapeRepresentation(
-		context ? context : getSingle<Ifc2x3::IfcRepresentationContext>(), std::string("Body"), std::string("SweptSolid"), items);
+		context ? context : getSingle<IfcSchema::IfcRepresentationContext>(), std::string("Body"), std::string("SweptSolid"), items);
 	reps->push(rep);
-	Ifc2x3::IfcProductDefinitionShape* shape = new Ifc2x3::IfcProductDefinitionShape(0, 0, reps);		
+	IfcSchema::IfcProductDefinitionShape* shape = new IfcSchema::IfcProductDefinitionShape(0, 0, reps);		
 	AddEntity(rep);
 	AddEntity(shape);
 	addBox(rep, w, d, h, place, place2, dir, context);
 	return shape;
 }
 
-void IfcHierarchyHelper::clipRepresentation(Ifc2x3::IfcProductRepresentation* shape, 
+void IfcHierarchyHelper::clipRepresentation(IfcSchema::IfcProductRepresentation* shape, 
-	Ifc2x3::IfcAxis2Placement3D* place, bool agree) 
+	IfcSchema::IfcAxis2Placement3D* place, bool agree) 
 {
-	Ifc2x3::IfcPlane* plane = new Ifc2x3::IfcPlane(place);
+	IfcSchema::IfcPlane* plane = new IfcSchema::IfcPlane(place);
-	Ifc2x3::IfcHalfSpaceSolid* half_space = new Ifc2x3::IfcHalfSpaceSolid(plane, agree);
+	IfcSchema::IfcHalfSpaceSolid* half_space = new IfcSchema::IfcHalfSpaceSolid(plane, agree);
-	Ifc2x3::IfcRepresentation::list reps = shape->Representations();
+	IfcSchema::IfcRepresentation::list reps = shape->Representations();
-	for (Ifc2x3::IfcRepresentation::it j = reps->begin(); j != reps->end(); ++j) {
+	for (IfcSchema::IfcRepresentation::it j = reps->begin(); j != reps->end(); ++j) {
-		Ifc2x3::IfcRepresentation* rep = *j;
+		IfcSchema::IfcRepresentation* rep = *j;
 		if (rep->RepresentationIdentifier() != "Body") continue;
 		rep->setRepresentationType("Clipping");		
-		Ifc2x3::IfcRepresentationItem::list items = rep->Items();
+		IfcSchema::IfcRepresentationItem::list items = rep->Items();
-		Ifc2x3::IfcRepresentationItem::list new_items (new IfcTemplatedEntityList<Ifc2x3::IfcRepresentationItem>());
+		IfcSchema::IfcRepresentationItem::list new_items (new IfcTemplatedEntityList<IfcSchema::IfcRepresentationItem>());
 		AddEntity(plane);
 		AddEntity(half_space);
-		for (Ifc2x3::IfcRepresentationItem::it i = items->begin(); i != items->end(); ++i) {
+		for (IfcSchema::IfcRepresentationItem::it i = items->begin(); i != items->end(); ++i) {
-			Ifc2x3::IfcRepresentationItem* item = *i;
+			IfcSchema::IfcRepresentationItem* item = *i;
-			Ifc2x3::IfcBooleanClippingResult* clip = new Ifc2x3::IfcBooleanClippingResult(
+			IfcSchema::IfcBooleanClippingResult* clip = new IfcSchema::IfcBooleanClippingResult(
-				Ifc2x3::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE, item, half_space);
+				IfcSchema::IfcBooleanOperator::IfcBooleanOperator_DIFFERENCE, item, half_space);
 			AddEntity(clip);
 			new_items->push(clip);
 		}
@@ -341,24 +341,24 @@ void IfcHierarchyHelper::clipRepresentation(Ifc2x3::IfcProductRepresentation* sh
 	}
 }
 
-Ifc2x3::IfcPresentationStyleAssignment* IfcHierarchyHelper::setSurfaceColour(
+IfcSchema::IfcPresentationStyleAssignment* IfcHierarchyHelper::setSurfaceColour(
-	Ifc2x3::IfcProductRepresentation* shape, double r, double g, double b, double a) 
+	IfcSchema::IfcProductRepresentation* shape, double r, double g, double b, double a) 
 {
-	Ifc2x3::IfcColourRgb* colour = new Ifc2x3::IfcColourRgb(boost::none, r, g, b);
+	IfcSchema::IfcColourRgb* colour = new IfcSchema::IfcColourRgb(boost::none, r, g, b);
-	Ifc2x3::IfcSurfaceStyleRendering* rendering = a == 1.0
+	IfcSchema::IfcSurfaceStyleRendering* rendering = a == 1.0
-		? new Ifc2x3::IfcSurfaceStyleRendering(colour, boost::none, boost::none, boost::none, boost::none, boost::none, 
+		? new IfcSchema::IfcSurfaceStyleRendering(colour, boost::none, boost::none, boost::none, boost::none, boost::none, 
-			boost::none, boost::none, Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethod_FLAT)
+			boost::none, boost::none, IfcSchema::IfcReflectanceMethodEnum::IfcReflectanceMethod_FLAT)
-		: new Ifc2x3::IfcSurfaceStyleRendering(colour, 1.0-a, boost::none, boost::none, boost::none, boost::none, 
+		: new IfcSchema::IfcSurfaceStyleRendering(colour, 1.0-a, boost::none, boost::none, boost::none, boost::none, 
-			boost::none, boost::none, Ifc2x3::IfcReflectanceMethodEnum::IfcReflectanceMethod_FLAT);
+			boost::none, boost::none, IfcSchema::IfcReflectanceMethodEnum::IfcReflectanceMethod_FLAT);
 
 	IfcEntities styles(new IfcEntityList());
 	styles->push(rendering);
-	Ifc2x3::IfcSurfaceStyle* surface_style = new Ifc2x3::IfcSurfaceStyle(
+	IfcSchema::IfcSurfaceStyle* surface_style = new IfcSchema::IfcSurfaceStyle(
-		boost::none, Ifc2x3::IfcSurfaceSide::IfcSurfaceSide_BOTH, styles);
+		boost::none, IfcSchema::IfcSurfaceSide::IfcSurfaceSide_BOTH, styles);
 	IfcEntities surface_styles(new IfcEntityList());
 	surface_styles->push(surface_style);
-	Ifc2x3::IfcPresentationStyleAssignment* style_assignment = 
+	IfcSchema::IfcPresentationStyleAssignment* style_assignment = 
-		new Ifc2x3::IfcPresentationStyleAssignment(surface_styles);
+		new IfcSchema::IfcPresentationStyleAssignment(surface_styles);
 	AddEntity(colour);
 	AddEntity(rendering);
 	AddEntity(surface_style);
@@ -367,19 +367,23 @@ Ifc2x3::IfcPresentationStyleAssignment* IfcHierarchyHelper::setSurfaceColour(
 	return style_assignment;
 }
 
-void IfcHierarchyHelper::setSurfaceColour(Ifc2x3::IfcProductRepresentation* shape, 
+void IfcHierarchyHelper::setSurfaceColour(IfcSchema::IfcProductRepresentation* shape, 
-	Ifc2x3::IfcPresentationStyleAssignment* style_assignment) 
+	IfcSchema::IfcPresentationStyleAssignment* style_assignment) 
 {
-	Ifc2x3::IfcPresentationStyleAssignment::list style_assignments (new IfcTemplatedEntityList<Ifc2x3::IfcPresentationStyleAssignment>());
+#ifdef USE_IFC4 
+	IfcEntities style_assignments (new IfcEntityList());
+#else
+	IfcSchema::IfcPresentationStyleAssignment::list style_assignments (new IfcTemplatedEntityList<IfcSchema::IfcPresentationStyleAssignment>());
+#endif
 	style_assignments->push(style_assignment);
-	Ifc2x3::IfcRepresentation::list reps = shape->Representations();
+	IfcSchema::IfcRepresentation::list reps = shape->Representations();
-	for (Ifc2x3::IfcRepresentation::it j = reps->begin(); j != reps->end(); ++j) {
+	for (IfcSchema::IfcRepresentation::it j = reps->begin(); j != reps->end(); ++j) {
-		Ifc2x3::IfcRepresentation* rep = *j;
+		IfcSchema::IfcRepresentation* rep = *j;
 		if (rep->RepresentationIdentifier() != "Body" && rep->RepresentationIdentifier() != "Facetation") continue;
-		Ifc2x3::IfcRepresentationItem::list items = rep->Items();
+		IfcSchema::IfcRepresentationItem::list items = rep->Items();
-		for (Ifc2x3::IfcRepresentationItem::it i = items->begin(); i != items->end(); ++i) {
+		for (IfcSchema::IfcRepresentationItem::it i = items->begin(); i != items->end(); ++i) {
-			Ifc2x3::IfcRepresentationItem* item = *i;
+			IfcSchema::IfcRepresentationItem* item = *i;
-			Ifc2x3::IfcStyledItem* styled_item = new Ifc2x3::IfcStyledItem(item, style_assignments, boost::none);
+			IfcSchema::IfcStyledItem* styled_item = new IfcSchema::IfcStyledItem(item, style_assignments, boost::none);
 			AddEntity(styled_item);
 		}
 	}

src/ifcparse/IfcHierarchyHelper.h

@@ -28,7 +28,11 @@
 #ifndef IFCHIERARCHYHELPER_H
 #define IFCHIERARCHYHELPER_H
 
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
 #include "../ifcparse/Ifc2x3.h"
+#endif
 #include "../ifcparse/IfcFile.h"
 #include "../ifcparse/IfcWrite.h"
 
@@ -57,27 +61,27 @@ public:
 		return *ts->begin();
 	}
 	
-	Ifc2x3::IfcAxis2Placement3D* addPlacement3d(double ox=0.0, double oy=0.0, double oz=0.0,
+	IfcSchema::IfcAxis2Placement3D* addPlacement3d(double ox=0.0, double oy=0.0, double oz=0.0,
 		double zx=0.0, double zy=0.0, double zz=1.0,
 		double xx=1.0, double xy=0.0, double xz=0.0);
 
-	Ifc2x3::IfcAxis2Placement2D* addPlacement2d(double ox=0.0, double oy=0.0,
+	IfcSchema::IfcAxis2Placement2D* addPlacement2d(double ox=0.0, double oy=0.0,
 		double xx=1.0, double xy=0.0);
 
-	Ifc2x3::IfcLocalPlacement* addLocalPlacement(double ox=0.0, double oy=0.0, double oz=0.0,
+	IfcSchema::IfcLocalPlacement* addLocalPlacement(double ox=0.0, double oy=0.0, double oz=0.0,
 		double zx=0.0, double zy=0.0, double zz=1.0,
 		double xx=1.0, double xy=0.0, double xz=0.0);
 
 	template <class T>
-	void addRelatedObject(Ifc2x3::IfcObjectDefinition* related_object, 
+	void addRelatedObject(IfcSchema::IfcObjectDefinition* related_object, 
-		Ifc2x3::IfcObjectDefinition* relating_object, Ifc2x3::IfcOwnerHistory* owner_hist = 0)
+		IfcSchema::IfcObjectDefinition* relating_object, IfcSchema::IfcOwnerHistory* owner_hist = 0)
 	{
 		typename T::list li = EntitiesByType<T>();
 		bool found = false;
 		for (typename T::it i = li->begin(); i != li->end(); ++i) {
 			T* rel = *i;
 			if (rel->RelatingObject() == relating_object) {
-				Ifc2x3::IfcObjectDefinition::list products = rel->RelatedObjects();
+				IfcSchema::IfcObjectDefinition::list products = rel->RelatedObjects();
 				products->push(related_object);
 				rel->setRelatedObjects(products);
 				found = true;
@@ -86,67 +90,67 @@ public:
 		}
 		if (! found) {
 			if (! owner_hist) {
-				owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+				owner_hist = getSingle<IfcSchema::IfcOwnerHistory>();
 			}
 			if (! owner_hist) {
 				owner_hist = addOwnerHistory();
 			}
-			Ifc2x3::IfcObjectDefinition::list relating_objects (new IfcTemplatedEntityList<Ifc2x3::IfcObjectDefinition>());
+			IfcSchema::IfcObjectDefinition::list relating_objects (new IfcTemplatedEntityList<IfcSchema::IfcObjectDefinition>());
 			relating_objects->push(relating_object);
 			T* t = new T(IfcWrite::IfcGuidHelper(), owner_hist, boost::none, boost::none, related_object, relating_objects);
 			AddEntity(t);
 		}
 	}
 
-	Ifc2x3::IfcOwnerHistory* addOwnerHistory();	
+	IfcSchema::IfcOwnerHistory* addOwnerHistory();	
-	Ifc2x3::IfcProject* addProject(Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+	IfcSchema::IfcProject* addProject(IfcSchema::IfcOwnerHistory* owner_hist = 0);
-	void relatePlacements(Ifc2x3::IfcProduct* parent, Ifc2x3::IfcProduct* product);	
+	void relatePlacements(IfcSchema::IfcProduct* parent, IfcSchema::IfcProduct* product);	
-	Ifc2x3::IfcSite* addSite(Ifc2x3::IfcProject* proj = 0, Ifc2x3::IfcOwnerHistory* owner_hist = 0);	
+	IfcSchema::IfcSite* addSite(IfcSchema::IfcProject* proj = 0, IfcSchema::IfcOwnerHistory* owner_hist = 0);	
-	Ifc2x3::IfcBuilding* addBuilding(Ifc2x3::IfcSite* site = 0, Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+	IfcSchema::IfcBuilding* addBuilding(IfcSchema::IfcSite* site = 0, IfcSchema::IfcOwnerHistory* owner_hist = 0);
 
-	Ifc2x3::IfcBuildingStorey* addBuildingStorey(Ifc2x3::IfcBuilding* building = 0, 
+	IfcSchema::IfcBuildingStorey* addBuildingStorey(IfcSchema::IfcBuilding* building = 0, 
-		Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+		IfcSchema::IfcOwnerHistory* owner_hist = 0);
 
-	Ifc2x3::IfcBuildingStorey* addBuildingProduct(Ifc2x3::IfcProduct* product, 
+	IfcSchema::IfcBuildingStorey* addBuildingProduct(IfcSchema::IfcProduct* product, 
-		Ifc2x3::IfcBuildingStorey* storey = 0, Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+		IfcSchema::IfcBuildingStorey* storey = 0, IfcSchema::IfcOwnerHistory* owner_hist = 0);
 
-	void addExtrudedPolyline(Ifc2x3::IfcShapeRepresentation* rep, const std::vector<std::pair<double, double> >& points, double h, 
+	void addExtrudedPolyline(IfcSchema::IfcShapeRepresentation* rep, const std::vector<std::pair<double, double> >& points, double h, 
-		Ifc2x3::IfcAxis2Placement2D* place=0, Ifc2x3::IfcAxis2Placement3D* place2=0, 
+		IfcSchema::IfcAxis2Placement2D* place=0, IfcSchema::IfcAxis2Placement3D* place2=0, 
-		Ifc2x3::IfcDirection* dir=0, Ifc2x3::IfcRepresentationContext* context=0);
+		IfcSchema::IfcDirection* dir=0, IfcSchema::IfcRepresentationContext* context=0);
 
-	Ifc2x3::IfcProductDefinitionShape* addExtrudedPolyline(const std::vector<std::pair<double, double> >& points, double h, 
+	IfcSchema::IfcProductDefinitionShape* addExtrudedPolyline(const std::vector<std::pair<double, double> >& points, double h, 
-		Ifc2x3::IfcAxis2Placement2D* place=0, Ifc2x3::IfcAxis2Placement3D* place2=0, Ifc2x3::IfcDirection* dir=0, 
+		IfcSchema::IfcAxis2Placement2D* place=0, IfcSchema::IfcAxis2Placement3D* place2=0, IfcSchema::IfcDirection* dir=0, 
-		Ifc2x3::IfcRepresentationContext* context=0);
+		IfcSchema::IfcRepresentationContext* context=0);
 
-	void addBox(Ifc2x3::IfcShapeRepresentation* rep, double w, double d, double h, 
+	void addBox(IfcSchema::IfcShapeRepresentation* rep, double w, double d, double h, 
-		Ifc2x3::IfcAxis2Placement2D* place=0, Ifc2x3::IfcAxis2Placement3D* place2=0, 
+		IfcSchema::IfcAxis2Placement2D* place=0, IfcSchema::IfcAxis2Placement3D* place2=0, 
-		Ifc2x3::IfcDirection* dir=0, Ifc2x3::IfcRepresentationContext* context=0);
+		IfcSchema::IfcDirection* dir=0, IfcSchema::IfcRepresentationContext* context=0);
 
-	Ifc2x3::IfcProductDefinitionShape* addBox(double w, double d, double h, Ifc2x3::IfcAxis2Placement2D* place=0, 
+	IfcSchema::IfcProductDefinitionShape* addBox(double w, double d, double h, IfcSchema::IfcAxis2Placement2D* place=0, 
-		Ifc2x3::IfcAxis2Placement3D* place2=0, Ifc2x3::IfcDirection* dir=0, Ifc2x3::IfcRepresentationContext* context=0);
+		IfcSchema::IfcAxis2Placement3D* place2=0, IfcSchema::IfcDirection* dir=0, IfcSchema::IfcRepresentationContext* context=0);
 
-	void clipRepresentation(Ifc2x3::IfcProductRepresentation* shape, 
+	void clipRepresentation(IfcSchema::IfcProductRepresentation* shape, 
-		Ifc2x3::IfcAxis2Placement3D* place, bool agree);
+		IfcSchema::IfcAxis2Placement3D* place, bool agree);
 
-	Ifc2x3::IfcPresentationStyleAssignment* setSurfaceColour(Ifc2x3::IfcProductRepresentation* shape, 
+	IfcSchema::IfcPresentationStyleAssignment* setSurfaceColour(IfcSchema::IfcProductRepresentation* shape, 
 		double r, double g, double b, double a=1.0);
 
-	void setSurfaceColour(Ifc2x3::IfcProductRepresentation* shape, 
+	void setSurfaceColour(IfcSchema::IfcProductRepresentation* shape, 
-		Ifc2x3::IfcPresentationStyleAssignment* style_assignment);
+		IfcSchema::IfcPresentationStyleAssignment* style_assignment);
 
 };
 
 template <>
-inline void IfcHierarchyHelper::addRelatedObject <Ifc2x3::IfcRelContainedInSpatialStructure> (Ifc2x3::IfcObjectDefinition* related_object, 
+inline void IfcHierarchyHelper::addRelatedObject <IfcSchema::IfcRelContainedInSpatialStructure> (IfcSchema::IfcObjectDefinition* related_object, 
-	Ifc2x3::IfcObjectDefinition* relating_object, Ifc2x3::IfcOwnerHistory* owner_hist)
+	IfcSchema::IfcObjectDefinition* relating_object, IfcSchema::IfcOwnerHistory* owner_hist)
 {
-	Ifc2x3::IfcRelContainedInSpatialStructure::list li = EntitiesByType<Ifc2x3::IfcRelContainedInSpatialStructure>();
+	IfcSchema::IfcRelContainedInSpatialStructure::list li = EntitiesByType<IfcSchema::IfcRelContainedInSpatialStructure>();
 	bool found = false;
-	for (Ifc2x3::IfcRelContainedInSpatialStructure::it i = li->begin(); i != li->end(); ++i) {
+	for (IfcSchema::IfcRelContainedInSpatialStructure::it i = li->begin(); i != li->end(); ++i) {
-		Ifc2x3::IfcRelContainedInSpatialStructure* rel = *i;
+		IfcSchema::IfcRelContainedInSpatialStructure* rel = *i;
 		if (rel->RelatingStructure() == relating_object) {
-			Ifc2x3::IfcProduct::list products = rel->RelatedElements();
+			IfcSchema::IfcProduct::list products = rel->RelatedElements();
-			products->push((Ifc2x3::IfcProduct*)related_object);
+			products->push((IfcSchema::IfcProduct*)related_object);
 			rel->setRelatedElements(products);
 			found = true;
 			break;
@@ -154,15 +158,15 @@ inline void IfcHierarchyHelper::addRelatedObject <Ifc2x3::IfcRelContainedInSpati
 	}
 	if (! found) {
 		if (! owner_hist) {
-			owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+			owner_hist = getSingle<IfcSchema::IfcOwnerHistory>();
 		}
 		if (! owner_hist) {
 			owner_hist = addOwnerHistory();
 		}
-		Ifc2x3::IfcProduct::list relating_objects (new IfcTemplatedEntityList<Ifc2x3::IfcProduct>());
+		IfcSchema::IfcProduct::list relating_objects (new IfcTemplatedEntityList<IfcSchema::IfcProduct>());
-		relating_objects->push((Ifc2x3::IfcProduct*)relating_object);
+		relating_objects->push((IfcSchema::IfcProduct*)relating_object);
-		Ifc2x3::IfcRelContainedInSpatialStructure* t = new Ifc2x3::IfcRelContainedInSpatialStructure(IfcWrite::IfcGuidHelper(), owner_hist, 
+		IfcSchema::IfcRelContainedInSpatialStructure* t = new IfcSchema::IfcRelContainedInSpatialStructure(IfcWrite::IfcGuidHelper(), owner_hist, 
-			boost::none, boost::none, relating_objects, (Ifc2x3::IfcSpatialStructureElement*)related_object);
+			boost::none, boost::none, relating_objects, (IfcSchema::IfcSpatialStructureElement*)related_object);
 
 		AddEntity(t);
 	}

src/ifcparse/IfcParse.cpp

@@ -363,7 +363,7 @@ TokenArgument::TokenArgument(const Token& t) {
 	token = t;
 }
 
-EntityArgument::EntityArgument(Ifc2x3::Type::Enum ty, const Token& t) {
+EntityArgument::EntityArgument(IfcSchema::Type::Enum ty, const Token& t) {
 	entity = new IfcUtil::IfcArgumentSelect(ty,new TokenArgument(t));
 }
 
@@ -382,7 +382,7 @@ ArgumentList::ArgumentList(Tokens* t, std::vector<unsigned int>& ids) {
 			if ( TokenFunc::isDatatype(next) ) {
 				t->Next();
 				try {
-					Push ( new EntityArgument(Ifc2x3::Type::FromString(TokenFunc::asString(next)),t->Next()) );
+					Push ( new EntityArgument(IfcSchema::Type::FromString(TokenFunc::asString(next)),t->Next()) );
 				} catch ( IfcException& e ) {
 					Logger::Message(Logger::LOG_ERROR,e.what());
 				}
@@ -511,7 +511,7 @@ std::string EntityArgument::toString(bool upper) const {
 		? TokenFunc::asString(token_arg->token) 
 		: TokenFunc::toString(token_arg->token))
 		: std::string();
-	std::string dt = Ifc2x3::Type::ToString(entity->type());
+	std::string dt = IfcSchema::Type::ToString(entity->type());
 	if ( upper ) {
 		for (std::string::iterator p = dt.begin(); p != dt.end(); ++p ) *p = toupper(*p);
 		if (is_string) token_string = IfcWrite::IfcCharacterEncoder(token_string);
@@ -532,7 +532,7 @@ Entity::Entity(unsigned int i, IfcFile* f) { //: file(f) {
 	file = f;
 	Token datatype = f->tokens->Next();
 	if ( ! TokenFunc::isDatatype(datatype)) throw IfcException("Unexpected token while parsing entity");
-	_type = Ifc2x3::Type::FromString(TokenFunc::asString(datatype));
+	_type = IfcSchema::Type::FromString(TokenFunc::asString(datatype));
 	_id = i;
 	args = ArgumentPtr();
 	offset = datatype.second;
@@ -576,7 +576,7 @@ void Entity::Load(std::vector<unsigned int>& ids, bool seek) {
 		file->tokens->stream->Seek(offset);
 		Token datatype = file->tokens->Next();
 		if ( ! TokenFunc::isDatatype(datatype)) throw IfcException("Unexpected token while parsing entity");
-		_type = Ifc2x3::Type::FromString(TokenFunc::asString(datatype));
+		_type = IfcSchema::Type::FromString(TokenFunc::asString(datatype));
 	}
 	Token open = file->tokens->Next();
 	args = new ArgumentList(file->tokens, ids);
@@ -585,7 +585,7 @@ void Entity::Load(std::vector<unsigned int>& ids, bool seek) {
 	if ( ! TokenFunc::isOperator(semilocon,';') ) file->tokens->stream->Seek(old_offset);
 }
 
-Ifc2x3::Type::Enum Entity::type() const {
+IfcSchema::Type::Enum Entity::type() const {
 	return _type;
 }
 
@@ -593,7 +593,7 @@ Ifc2x3::Type::Enum Entity::type() const {
 // Returns the CamelCase string representation of the datatype as it is defined in the schema
 //
 std::string Entity::datatype() {
-	return Ifc2x3::Type::ToString(_type);
+	return IfcSchema::Type::ToString(_type);
 }
 
 //
@@ -621,18 +621,18 @@ Entity::~Entity() {
 //
 // Returns the entities of type c that have this entity in their ArgumentList
 //
-IfcEntities Entity::getInverse(Ifc2x3::Type::Enum c) {
+IfcEntities Entity::getInverse(IfcSchema::Type::Enum c) {
 	IfcEntities l = IfcEntities(new IfcEntityList());
 	IfcEntities all = file->EntitiesByReference(_id);
 	if ( ! all ) return l;
 	for( IfcEntityList::it it = all->begin(); it != all->end();++  it  ) {
-		if ( c == Ifc2x3::Type::ALL || (*it)->is(c) ) {
+		if ( c == IfcSchema::Type::ALL || (*it)->is(c) ) {
 			l->push(*it);
 		}
 	}
 	return l;
 }
-IfcEntities Entity::getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a) {
+IfcEntities Entity::getInverse(IfcSchema::Type::Enum c, int i, const std::string& a) {
 	IfcEntities l = IfcEntities(new IfcEntityList());
 	IfcEntities all = getInverse(c);
 	for( IfcEntityList::it it = all->begin(); it != all->end();++ it  ) {
@@ -643,7 +643,7 @@ IfcEntities Entity::getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a
 	}
 	return l;
 }
-bool Entity::is(Ifc2x3::Type::Enum v) const {	return _type == v; }
+bool Entity::is(IfcSchema::Type::Enum v) const {	return _type == v; }
 unsigned int Entity::id() { return _id; }
 
 bool Entity::isWritable() {
@@ -673,7 +673,7 @@ bool IfcFile::Init(void* data, int len) {
 	return IfcFile::Init(new IfcSpfStream(data,len));
 }
 bool IfcFile::Init(IfcParse::IfcSpfStream* f) {
-	Ifc2x3::InitStringMap();
+	IfcSchema::InitStringMap();
 	file = f;
 	if ( ! file->valid ) return false;
 	tokens = new Tokens (file,this);
@@ -689,7 +689,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* f) {
 		if ( currentId ) {
 			try {
 				e = new Entity(currentId,this);
-				entity = Ifc2x3::SchemaEntity(e);
+				entity = IfcSchema::SchemaEntity(e);
 			} catch (IfcException ex) {
 				currentId = 0;
 				Logger::Message(Logger::LOG_ERROR,ex.what());
@@ -700,8 +700,8 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* f) {
 				std::stringstream ss; ss << "\r#" << currentId;
 				Logger::Status(ss.str(), false);
 			}
-			if ( entity->is(Ifc2x3::Type::IfcRoot) ) {
+			if ( entity->is(IfcSchema::Type::IfcRoot) ) {
-				Ifc2x3::IfcRoot::ptr ifc_root = (Ifc2x3::IfcRoot::ptr) entity;
+				IfcSchema::IfcRoot::ptr ifc_root = (IfcSchema::IfcRoot::ptr) entity;
 				try {
 					const std::string guid = ifc_root->GlobalId();
 					if ( byguid.find(guid) != byguid.end() ) {
@@ -714,7 +714,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* f) {
 					Logger::Message(Logger::LOG_ERROR,ex.what());
 				}
 			}
-			Ifc2x3::Type::Enum ty = entity->type();
+			IfcSchema::Type::Enum ty = entity->type();
 			do {
 				IfcEntities L = EntitiesByType(ty);
 				if ( L == 0 ) {
@@ -722,7 +722,7 @@ bool IfcFile::Init(IfcParse::IfcSpfStream* f) {
 					bytype[ty] = L;
 				}
 				L->push(entity);
-				ty = Ifc2x3::Type::Parent(ty);
+				ty = IfcSchema::Type::Parent(ty);
 			} while ( ty > -1 );
 			if ( byid.find(currentId) != byid.end() ) {
 				std::stringstream ss;
@@ -761,8 +761,8 @@ void IfcFile::AddEntities(IfcEntities es) {
 	}
 }
 void IfcFile::AddEntity(IfcUtil::IfcSchemaEntity entity) {
-	if ( entity->is(Ifc2x3::Type::IfcRoot) ) {
+	if ( entity->is(IfcSchema::Type::IfcRoot) ) {
-		Ifc2x3::IfcRoot::ptr ifc_root = (Ifc2x3::IfcRoot::ptr) entity;
+		IfcSchema::IfcRoot::ptr ifc_root = (IfcSchema::IfcRoot::ptr) entity;
 		try {
 			const std::string guid = ifc_root->GlobalId();
 			if ( byguid.find(guid) != byguid.end() ) {
@@ -775,7 +775,7 @@ void IfcFile::AddEntity(IfcUtil::IfcSchemaEntity entity) {
 			Logger::Message(Logger::LOG_ERROR,ex.what());
 		}
 	}
-	Ifc2x3::Type::Enum ty = entity->type();
+	IfcSchema::Type::Enum ty = entity->type();
 	do {
 		IfcEntities L = EntitiesByType(ty);
 		if ( L == 0 ) {
@@ -783,7 +783,7 @@ void IfcFile::AddEntity(IfcUtil::IfcSchemaEntity entity) {
 			bytype[ty] = L;
 		}
 		L->push(entity);
-		ty = Ifc2x3::Type::Parent(ty);
+		ty = IfcSchema::Type::Parent(ty);
 	} while ( ty > -1 );
 	int new_id = -1;
 	// For newly created entities ensure a valid ENTITY_INSTANCE_NAME is set
@@ -802,14 +802,14 @@ void IfcFile::AddEntity(IfcUtil::IfcSchemaEntity entity) {
 	byid[new_id] = entity;
 
 }
-IfcEntities IfcFile::EntitiesByType(Ifc2x3::Type::Enum t) {
+IfcEntities IfcFile::EntitiesByType(IfcSchema::Type::Enum t) {
 	MapEntitiesByType::const_iterator it = bytype.find(t);
 	return (it == bytype.end()) ? IfcEntities() : it->second;
 }
 IfcEntities IfcFile::EntitiesByType(const std::string& t) {
 	std::string ty = t;
 	for (std::string::iterator p = ty.begin(); p != ty.end(); ++p ) *p = toupper(*p);
-	return EntitiesByType(Ifc2x3::Type::FromString(ty));
+	return EntitiesByType(IfcSchema::Type::FromString(ty));
 }
 IfcEntities IfcFile::EntitiesByReference(int t) {
 	MapEntitiesByRef::const_iterator it = byref.find(t);
@@ -822,13 +822,13 @@ IfcUtil::IfcSchemaEntity IfcFile::EntityById(int id) {
 		if ( it2 == offsets.end() ) throw IfcException("Entity not found");
 		const unsigned int offset = (*it2).second;
 		EntityPtr e = EntityPtr(new Entity(id,this,offset));
-		IfcUtil::IfcSchemaEntity entity = Ifc2x3::SchemaEntity(e);
+		IfcUtil::IfcSchemaEntity entity = IfcSchema::SchemaEntity(e);
 		byid[id] = entity;
 		return entity;
 	}
 	return it->second;
 }
-Ifc2x3::IfcRoot::ptr IfcFile::EntityByGuid(const std::string& guid) {
+IfcSchema::IfcRoot::ptr IfcFile::EntityByGuid(const std::string& guid) {
 	MapEntityByGuid::const_iterator it = byguid.find(guid);
 	if ( it == byguid.end() ) {
 		throw IfcException("Entity not found");
@@ -871,7 +871,11 @@ std::ostream& operator<< (std::ostream& os, const IfcParse::IfcFile& f) {
 		<< "),'IfcOpenShell " << IFCOPENSHELL_VERSION 
 		<< "','IfcOpenShell " << IFCOPENSHELL_VERSION 
 		<< "','');" << std::endl;
+#ifdef USE_IFC4
+	os << "FILE_SCHEMA(('IFC4'));" << std::endl;
+#else
 	os << "FILE_SCHEMA(('IFC2X3'));" << std::endl;
+#endif
 	os << "ENDSEC;" << std::endl;
 	os << "DATA;" << std::endl;
 

src/ifcparse/IfcParse.h

@@ -20,7 +20,7 @@
 /********************************************************************************
  *                                                                              *
  * This file provides functions for loading an IFC file into memory and access  *
- * its entities either by ID, by an Ifc2x3::Type or by reference                * 
+ * its entities either by ID, by an IfcSchema::Type or by reference             * 
  *                                                                              *
  ********************************************************************************/
 
@@ -40,7 +40,13 @@
 #include "../ifcparse/SharedPointer.h"
 #include "../ifcparse/IfcCharacterDecoder.h"
 #include "../ifcparse/IfcUtil.h"
+
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4.h"
+#else
 #include "../ifcparse/Ifc2x3.h"
+#endif
+
 #include "../ifcparse/IfcFile.h"
 
 namespace IfcParse {
@@ -163,7 +169,7 @@ namespace IfcParse {
 	private:		
 		IfcUtil::IfcArgumentSelect* entity;		
 	public:
-		EntityArgument(Ifc2x3::Type::Enum ty, const Token& t);
+		EntityArgument(IfcSchema::Type::Enum ty, const Token& t);
 		~EntityArgument();
 		operator int() const;
 		operator bool() const;
@@ -188,7 +194,7 @@ namespace IfcParse {
 	private:
 		//IfcFile* file;
 		ArgumentPtr args;
-		Ifc2x3::Type::Enum _type;
+		IfcSchema::Type::Enum _type;
 	public:
 		/// The EXPRESS ENTITY_INSTANCE_NAME
 		unsigned int _id;
@@ -197,24 +203,24 @@ namespace IfcParse {
 		Entity(unsigned int i, IfcFile* t);
 		Entity(unsigned int i, IfcFile* t, unsigned int o);
 		~Entity();
-		IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL);
+		IfcEntities getInverse(IfcSchema::Type::Enum c = IfcSchema::Type::ALL);
-		IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a);
+		IfcEntities getInverse(IfcSchema::Type::Enum c, int i, const std::string& a);
 		void Load(std::vector<unsigned int>& ids, bool seek=false);
 		ArgumentPtr getArgument (unsigned int i);
 		unsigned int getArgumentCount();
 		std::string toString(bool upper=false);
 		std::string datatype();
-		Ifc2x3::Type::Enum type() const;
+		IfcSchema::Type::Enum type() const;
-		bool is(Ifc2x3::Type::Enum v) const;
+		bool is(IfcSchema::Type::Enum v) const;
 		unsigned int id();
 		bool isWritable();
 	};
 
 typedef IfcUtil::IfcSchemaEntity IfcEntity;
 //typedef IfcEntities IfcEntities;
-typedef std::map<Ifc2x3::Type::Enum,IfcEntities> MapEntitiesByType;
+typedef std::map<IfcSchema::Type::Enum,IfcEntities> MapEntitiesByType;
 typedef std::map<unsigned int,IfcEntity> MapEntityById;
-typedef std::map<std::string,Ifc2x3::IfcRoot::ptr> MapEntityByGuid;
+typedef std::map<std::string,IfcSchema::IfcRoot::ptr> MapEntityByGuid;
 typedef std::map<unsigned int,IfcEntities> MapEntitiesByRef;
 typedef std::map<unsigned int,unsigned int> MapOffsetById;
 
@@ -261,7 +267,7 @@ public:
 	/// Returns all entities in the file that match the positional argument.
 	/// NOTE: This also returns subtypes of the requested type, for example:
 	/// IfcWall will also return IfcWallStandardCase entities
-	IfcEntities EntitiesByType(Ifc2x3::Type::Enum t);
+	IfcEntities EntitiesByType(IfcSchema::Type::Enum t);
 	/// Returns all entities in the file that match the positional argument.
 	/// NOTE: This also returns subtypes of the requested type, for example:
 	/// IfcWall will also return IfcWallStandardCase entities
@@ -271,7 +277,7 @@ public:
 	/// Returns the entity with the specified id
 	IfcEntity EntityById(int id);
 	/// Returns the entity with the specified GlobalId
-	Ifc2x3::IfcRoot::ptr EntityByGuid(const std::string& guid);
+	IfcSchema::IfcRoot::ptr EntityByGuid(const std::string& guid);
 	bool Init(const std::string& fn);
 	bool Init(std::istream& fn, int len);
 	bool Init(void* data, int len);
@@ -290,7 +296,7 @@ public:
 	std::string authorOrganisation() const;
 };
 
-double UnitPrefixToValue( Ifc2x3::IfcSIPrefix::IfcSIPrefix v );
+double UnitPrefixToValue( IfcSchema::IfcSIPrefix::IfcSIPrefix v );
 
 }
 

src/ifcparse/IfcUtil.cpp

@@ -34,14 +34,14 @@ IfcEntityList::it IfcEntityList::end() { return ls.end(); }
 IfcUtil::IfcSchemaEntity IfcEntityList::operator[] (int i) {
 	return ls[i];
 }
-IfcEntities IfcEntityList::getInverse(Ifc2x3::Type::Enum c) {
+IfcEntities IfcEntityList::getInverse(IfcSchema::Type::Enum c) {
 	IfcEntities l = IfcEntities(new IfcEntityList());
 	for( it i = begin(); i != end(); ++i  ) {
 		l->push((*i)->entity->getInverse(c));
 	}
 	return l;
 }
-IfcEntities IfcEntityList::getInverse(Ifc2x3::Type::Enum c, int ar, const std::string& a) {
+IfcEntities IfcEntityList::getInverse(IfcSchema::Type::Enum c, int ar, const std::string& a) {
 	IfcEntities l = IfcEntities(new IfcEntityList());
 	for( it i = begin(); i != end(); ++i  ) {
 		l->push((*i)->entity->getInverse(c,ar,a));
@@ -49,16 +49,16 @@ IfcEntities IfcEntityList::getInverse(Ifc2x3::Type::Enum c, int ar, const std::s
 	return l;
 }
  
-bool IfcUtil::IfcEntitySelect::is(Ifc2x3::Type::Enum v) const { return entity->is(v); }
+bool IfcUtil::IfcEntitySelect::is(IfcSchema::Type::Enum v) const { return entity->is(v); }
-Ifc2x3::Type::Enum IfcUtil::IfcEntitySelect::type() const { return entity->type(); }
+IfcSchema::Type::Enum IfcUtil::IfcEntitySelect::type() const { return entity->type(); }
 IfcUtil::IfcEntitySelect::IfcEntitySelect(IfcSchemaEntity b) { entity = b->entity; }
 IfcUtil::IfcEntitySelect::IfcEntitySelect(IfcAbstractEntityPtr e) { entity = e; }
 bool IfcUtil::IfcEntitySelect::isSimpleType() { return false; }
 IfcUtil::IfcEntitySelect::~IfcEntitySelect() { delete entity; }
 
-bool IfcUtil::IfcArgumentSelect::is(Ifc2x3::Type::Enum v) const { return _type == v; }
+bool IfcUtil::IfcArgumentSelect::is(IfcSchema::Type::Enum v) const { return _type == v; }
-Ifc2x3::Type::Enum IfcUtil::IfcArgumentSelect::type() const { return _type; }
+IfcSchema::Type::Enum IfcUtil::IfcArgumentSelect::type() const { return _type; }
-IfcUtil::IfcArgumentSelect::IfcArgumentSelect(Ifc2x3::Type::Enum t, ArgumentPtr a) { _type = t; arg = a; }
+IfcUtil::IfcArgumentSelect::IfcArgumentSelect(IfcSchema::Type::Enum t, ArgumentPtr a) { _type = t; arg = a; }
 ArgumentPtr IfcUtil::IfcArgumentSelect::wrappedValue() { return arg; }
 bool IfcUtil::IfcArgumentSelect::isSimpleType() { return true; }
 IfcUtil::IfcArgumentSelect::~IfcArgumentSelect() { delete arg; }

src/ifcparse/IfcUtil.h

@@ -25,7 +25,12 @@
 #include <sstream>
 
 #include "../ifcparse/SharedPointer.h"
+
+#ifdef USE_IFC4
+#include "../ifcparse/Ifc4enum.h"
+#else
 #include "../ifcparse/Ifc2x3enum.h"
+#endif
 
 class IfcAbstractEntity;
 //typedef SHARED_PTR<IfcAbstractEntity> IfcAbstractEntityPtr;
@@ -48,7 +53,7 @@ inline T* reinterpret_pointer_cast(F* from) {
 
 namespace IfcUtil {
     enum ArgumentType {
-        Argument_INT, Argument_BOOL, Argument_DOUBLE, Argument_STRING, Argument_VECTOR_INT, Argument_VECTOR_DOUBLE, Argument_VECTOR_STRING, Argument_ENTITY, Argument_ENTITY_LIST, Argument_ENUMERATION, Argument_UNKNOWN
+        Argument_INT, Argument_BOOL, Argument_DOUBLE, Argument_STRING, Argument_VECTOR_INT, Argument_VECTOR_DOUBLE, Argument_VECTOR_STRING, Argument_ENTITY, Argument_ENTITY_LIST, Argument_ENTITY_LIST_LIST, Argument_ENUMERATION, Argument_UNKNOWN
     };
 }
 
@@ -57,8 +62,8 @@ namespace IfcUtil {
 class IfcBaseClass {
 public:
     IfcAbstractEntityPtr entity;
-    virtual bool is(Ifc2x3::Type::Enum v) const = 0;
+    virtual bool is(IfcSchema::Type::Enum v) const = 0;
-    virtual Ifc2x3::Type::Enum type() const = 0;
+    virtual IfcSchema::Type::Enum type() const = 0;
 };
 
 class IfcBaseEntity : public IfcBaseClass {
@@ -81,8 +86,8 @@ class IfcEntityList {
 	std::vector<IfcUtil::IfcSchemaEntity> ls;
 public:
 	typedef std::vector<IfcUtil::IfcSchemaEntity>::const_iterator it;
-	IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL);
+	IfcEntities getInverse(IfcSchema::Type::Enum c = IfcSchema::Type::ALL);
-	IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a);
+	IfcEntities getInverse(IfcSchema::Type::Enum c, int i, const std::string& a);
 	void push(IfcUtil::IfcSchemaEntity l);
 	void push(IfcEntities l);
 	it begin();
@@ -134,20 +139,20 @@ namespace IfcUtil {
 		IfcEntitySelect(IfcSchemaEntity b);
 		IfcEntitySelect(IfcAbstractEntityPtr e);
 		~IfcEntitySelect();
-		bool is(Ifc2x3::Type::Enum v) const;
+		bool is(IfcSchema::Type::Enum v) const;
-		Ifc2x3::Type::Enum type() const;
+		IfcSchema::Type::Enum type() const;
 		bool isSimpleType();
 	};
 	class IfcArgumentSelect : public IfcAbstractSelect {
-		Ifc2x3::Type::Enum _type;
+		IfcSchema::Type::Enum _type;
 		ArgumentPtr arg;
 	public:
 		typedef IfcArgumentSelect* ptr;
-		IfcArgumentSelect(Ifc2x3::Type::Enum t, ArgumentPtr a);
+		IfcArgumentSelect(IfcSchema::Type::Enum t, ArgumentPtr a);
 		~IfcArgumentSelect();
 		ArgumentPtr wrappedValue();
-		bool is(Ifc2x3::Type::Enum v) const;
+		bool is(IfcSchema::Type::Enum v) const;
-		Ifc2x3::Type::Enum type() const;
+		IfcSchema::Type::Enum type() const;
 		bool isSimpleType();
 	};
 }
@@ -180,14 +185,14 @@ public:
 class IfcAbstractEntity {
 public:
 	IfcParse::IfcFile* file;
-	virtual IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL) = 0;
+	virtual IfcEntities getInverse(IfcSchema::Type::Enum c = IfcSchema::Type::ALL) = 0;
-	virtual IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a) = 0;
+	virtual IfcEntities getInverse(IfcSchema::Type::Enum c, int i, const std::string& a) = 0;
 	virtual std::string datatype() = 0;
 	virtual ArgumentPtr getArgument (unsigned int i) = 0;
 	virtual unsigned int getArgumentCount() = 0;
 	virtual ~IfcAbstractEntity() {};
-	virtual Ifc2x3::Type::Enum type() const = 0;
+	virtual IfcSchema::Type::Enum type() const = 0;
-	virtual bool is(Ifc2x3::Type::Enum v) const = 0;
+	virtual bool is(IfcSchema::Type::Enum v) const = 0;
 	virtual std::string toString(bool upper=false) = 0;
 	virtual unsigned int id() = 0;
 	virtual bool isWritable() = 0;

src/ifcparse/IfcWritableEntity.h

@@ -40,23 +40,23 @@ namespace IfcWrite {
 	private:
 		std::map<int,bool> writemask;
 		std::map<int,ArgumentPtr> args;
-		Ifc2x3::Type::Enum _type;
+		IfcSchema::Type::Enum _type;
 		int* _id;
 		bool arg_writable(int i);
 		void arg_writable(int i, bool b);
 		template <typename T> void _setArgument(int i, const T&);
 	public:
-		IfcWritableEntity(Ifc2x3::Type::Enum t);
+		IfcWritableEntity(IfcSchema::Type::Enum t);
 		~IfcWritableEntity();
 		int setId(int i=-1);
 		IfcWritableEntity(IfcAbstractEntity* e);
-		IfcEntities getInverse(Ifc2x3::Type::Enum c = Ifc2x3::Type::ALL);
+		IfcEntities getInverse(IfcSchema::Type::Enum c = IfcSchema::Type::ALL);
-		IfcEntities getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a);
+		IfcEntities getInverse(IfcSchema::Type::Enum c, int i, const std::string& a);
 		std::string datatype();
 		ArgumentPtr getArgument (unsigned int i);
 		unsigned int getArgumentCount();
-		Ifc2x3::Type::Enum type() const;
+		IfcSchema::Type::Enum type() const;
-		bool is(Ifc2x3::Type::Enum v) const;
+		bool is(IfcSchema::Type::Enum v) const;
 		std::string toString(bool upper=false);
 		unsigned int id();
 		bool isWritable();

src/ifcparse/IfcWrite.cpp

@@ -24,7 +24,7 @@
 
 using namespace IfcWrite;
 
-IfcWritableEntity::IfcWritableEntity(Ifc2x3::Type::Enum t) {
+IfcWritableEntity::IfcWritableEntity(IfcSchema::Type::Enum t) {
 	_type = t;
 	_id = 0;
 	file = 0;
@@ -49,19 +49,19 @@ IfcWritableEntity::IfcWritableEntity(IfcAbstractEntity* e)
 	}
 }
 // TODO: Reove redundancy with IfcParse::Entity
-IfcEntities IfcWritableEntity::getInverse(Ifc2x3::Type::Enum c) {
+IfcEntities IfcWritableEntity::getInverse(IfcSchema::Type::Enum c) {
 	IfcEntities l = IfcEntities(new IfcEntityList());
 	int id = _id ? *_id : setId();
 	IfcEntities all = file->EntitiesByReference(id);
 	if ( ! all ) return l;
 	for( IfcEntityList::it it = all->begin(); it != all->end();++  it  ) {
-		if ( c == Ifc2x3::Type::ALL || (*it)->is(c) ) {
+		if ( c == IfcSchema::Type::ALL || (*it)->is(c) ) {
 			l->push(*it);
 		}
 	}
 	return l;
 }
-IfcEntities IfcWritableEntity::getInverse(Ifc2x3::Type::Enum c, int i, const std::string& a) {
+IfcEntities IfcWritableEntity::getInverse(IfcSchema::Type::Enum c, int i, const std::string& a) {
 	IfcEntities l = IfcEntities(new IfcEntityList());
 	IfcEntities all = getInverse(c);
 	for( IfcEntityList::it it = all->begin(); it != all->end();++ it  ) {
@@ -73,11 +73,11 @@ IfcEntities IfcWritableEntity::getInverse(Ifc2x3::Type::Enum c, int i, const std
 	return l;
 }
 
-std::string IfcWritableEntity::datatype() { return Ifc2x3::Type::ToString(_type); }
+std::string IfcWritableEntity::datatype() { return IfcSchema::Type::ToString(_type); }
 ArgumentPtr IfcWritableEntity::getArgument (unsigned int i) { if ( i >= getArgumentCount() ) throw IfcParse::IfcException("Argument not set"); return args[i]; }
 unsigned int IfcWritableEntity::getArgumentCount() {return args.size(); }
-Ifc2x3::Type::Enum IfcWritableEntity::type() const { return _type; }
+IfcSchema::Type::Enum IfcWritableEntity::type() const { return _type; }
-bool IfcWritableEntity::is(Ifc2x3::Type::Enum v) const { return _type == v; }
+bool IfcWritableEntity::is(IfcSchema::Type::Enum v) const { return _type == v; }
 std::string IfcWritableEntity::toString(bool upper) {
 	std::stringstream ss;
 	std::string dt = datatype();
@@ -243,7 +243,7 @@ public:
 	}
 	void operator()(const IfcUtil::IfcSchemaEntity& i) { 
 		IfcAbstractEntity* e = i->entity;
-		if ( Ifc2x3::Type::IsSimple(e->type()) ) {
+		if ( IfcSchema::Type::IsSimple(e->type()) ) {
 			data << e->toString(upper);
 		} else {
 			data << "#" << e->id();
@@ -290,16 +290,16 @@ IfcWriteArgument::argument_type IfcWriteArgument::argumentType() const {
 	return static_cast<argument_type>(container.which());
 }
 
-IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum,int,const std::string &) {throw IfcParse::IfcException("Invalid cast");}
+IfcEntities IfcSelectHelperEntity::getInverse(IfcSchema::Type::Enum,int,const std::string &) {throw IfcParse::IfcException("Invalid cast");}
-IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum) {throw IfcParse::IfcException("Invalid cast");}
+IfcEntities IfcSelectHelperEntity::getInverse(IfcSchema::Type::Enum) {throw IfcParse::IfcException("Invalid cast");}
-std::string IfcSelectHelperEntity::datatype() { return Ifc2x3::Type::ToString(_type); }
+std::string IfcSelectHelperEntity::datatype() { return IfcSchema::Type::ToString(_type); }
 ArgumentPtr IfcSelectHelperEntity::getArgument(unsigned int i) {
 	if ( i != 0 ) throw IfcParse::IfcException("Invalid cast");
 	return arg;
 }
 unsigned int IfcSelectHelperEntity::getArgumentCount() { return 1; }
-Ifc2x3::Type::Enum IfcSelectHelperEntity::type() const { return _type; }
+IfcSchema::Type::Enum IfcSelectHelperEntity::type() const { return _type; }
-bool IfcSelectHelperEntity::is(Ifc2x3::Type::Enum t) const { return _type == t; }
+bool IfcSelectHelperEntity::is(IfcSchema::Type::Enum t) const { return _type == t; }
 std::string IfcSelectHelperEntity::toString(bool upper) {
 	std::stringstream ss;
 	std::string dt = datatype();
@@ -312,33 +312,33 @@ std::string IfcSelectHelperEntity::toString(bool upper) {
 unsigned int IfcSelectHelperEntity::id() { throw IfcParse::IfcException("Invalid cast"); }
 bool IfcSelectHelperEntity::isWritable() { throw IfcParse::IfcException("Invalid cast"); }
 
-IfcSelectHelper::IfcSelectHelper(const std::string& v, Ifc2x3::Type::Enum t) {
+IfcSelectHelper::IfcSelectHelper(const std::string& v, IfcSchema::Type::Enum t) {
 	IfcWriteArgument* a = new IfcWriteArgument(0);
 	a->set(v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
-IfcSelectHelper::IfcSelectHelper(const char* const v, Ifc2x3::Type::Enum t) {
+IfcSelectHelper::IfcSelectHelper(const char* const v, IfcSchema::Type::Enum t) {
 	IfcWriteArgument* a = new IfcWriteArgument(0);
 	a->set<std::string>(v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
-IfcSelectHelper::IfcSelectHelper(int v, Ifc2x3::Type::Enum t) {
+IfcSelectHelper::IfcSelectHelper(int v, IfcSchema::Type::Enum t) {
 	IfcWriteArgument* a = new IfcWriteArgument(0);
 	a->set(v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
-IfcSelectHelper::IfcSelectHelper(double v, Ifc2x3::Type::Enum t) {
+IfcSelectHelper::IfcSelectHelper(double v, IfcSchema::Type::Enum t) {
 	IfcWriteArgument* a = new IfcWriteArgument(0);
 	a->set(v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
-IfcSelectHelper::IfcSelectHelper(bool v, Ifc2x3::Type::Enum t) {
+IfcSelectHelper::IfcSelectHelper(bool v, IfcSchema::Type::Enum t) {
 	IfcWriteArgument* a = new IfcWriteArgument(0);
 	a->set(v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
-bool IfcSelectHelper::is(Ifc2x3::Type::Enum t) const { return entity->is(t); }
+bool IfcSelectHelper::is(IfcSchema::Type::Enum t) const { return entity->is(t); }
-Ifc2x3::Type::Enum IfcSelectHelper::type() const { return entity->type(); } 
+IfcSchema::Type::Enum IfcSelectHelper::type() const { return entity->type(); } 
 
 EntityBuffer* EntityBuffer::i = 0;
 EntityBuffer* EntityBuffer::instance() {

src/ifcparse/IfcWrite.h

@@ -136,18 +136,18 @@ namespace IfcWrite {
 	/// Proper memory management is difficult for now, so beware.
 	class IfcSelectHelperEntity : public IfcAbstractEntity {
 	private:
-		Ifc2x3::Type::Enum _type;
+		IfcSchema::Type::Enum _type;
 		IfcWriteArgument* arg;
 	public:
 		// FIXME: Make this a non-pointer argument and implement a copy constructor
-		IfcSelectHelperEntity(Ifc2x3::Type::Enum t, IfcWriteArgument* a) : _type(t), arg(a) {}
+		IfcSelectHelperEntity(IfcSchema::Type::Enum t, IfcWriteArgument* a) : _type(t), arg(a) {}
-		IfcEntities getInverse(Ifc2x3::Type::Enum,int,const std::string &);
+		IfcEntities getInverse(IfcSchema::Type::Enum,int,const std::string &);
-		IfcEntities getInverse(Ifc2x3::Type::Enum);
+		IfcEntities getInverse(IfcSchema::Type::Enum);
 		std::string datatype();
 		ArgumentPtr getArgument(unsigned int i);
 		unsigned int getArgumentCount();
-		Ifc2x3::Type::Enum type() const;
+		IfcSchema::Type::Enum type() const;
-		bool is(Ifc2x3::Type::Enum t) const;
+		bool is(IfcSchema::Type::Enum t) const;
 		std::string toString(bool upper = false);
 		unsigned int id();
 		bool isWritable();
@@ -159,13 +159,13 @@ namespace IfcWrite {
 	/// Proper memory management is difficult for now, so beware.
 	class IfcSelectHelper : public IfcUtil::IfcBaseClass {
 	public:
-		IfcSelectHelper(const std::string& v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcText);
+		IfcSelectHelper(const std::string& v, IfcSchema::Type::Enum t=IfcSchema::Type::IfcText);
-		IfcSelectHelper(const char* const v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcText);
+		IfcSelectHelper(const char* const v, IfcSchema::Type::Enum t=IfcSchema::Type::IfcText);
-		IfcSelectHelper(int v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcInteger);
+		IfcSelectHelper(int v, IfcSchema::Type::Enum t=IfcSchema::Type::IfcInteger);
-		IfcSelectHelper(double v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcReal);
+		IfcSelectHelper(double v, IfcSchema::Type::Enum t=IfcSchema::Type::IfcReal);
-		IfcSelectHelper(bool v, Ifc2x3::Type::Enum t=Ifc2x3::Type::IfcBoolean);
+		IfcSelectHelper(bool v, IfcSchema::Type::Enum t=IfcSchema::Type::IfcBoolean);
-		bool is(Ifc2x3::Type::Enum t) const;
+		bool is(IfcSchema::Type::Enum t) const;
-		Ifc2x3::Type::Enum type() const;
+		IfcSchema::Type::Enum type() const;
 	};
 	
 	/// A helper class for the creation of IFC GlobalIds.

win/IfcParse.vcproj

@@ -161,6 +161,18 @@
 					/>
 				</FileConfiguration>
 			</File>
+            <File
+				RelativePath="..\src\ifcparse\Ifc4.cpp"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						AdditionalOptions="/bigobj"
+					/>
+				</FileConfiguration>
+			</File>
 			<File
 				RelativePath="..\src\ifcparse\IfcCharacterDecoder.cpp"
 				>