- Correctly format REALs according to ISO 10303-21 instead of C++ std::stream double formatting

- Add the IfcHierarchyHelper to assist in the creation of IFC files
- Add the IfcOpenHouse example for writing topological geometry and tessellated Open Cascade shapes to IFC

src/ifcparse/IfcHierarchyHelper.cpp

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

src/ifcparse/IfcHierarchyHelper.h

@@ -0,0 +1,171 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+/********************************************************************************
+ *                                                                              *
+ * This class is a subclass of the regular IfcFile class that implements        *
+ * several convenience functions for creating geometrical representations and   *
+ * spatial containers.                                                          *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef IFCHIERARCHYHELPER_H
+#define IFCHIERARCHYHELPER_H
+
+#include "../ifcparse/Ifc2x3.h"
+#include "../ifcparse/IfcFile.h"
+#include "../ifcparse/IfcWrite.h"
+
+class IfcHierarchyHelper : public IfcParse::IfcFile {
+public:
+	template <class T> 
+	T* addTriplet(double x, double y, double z) {
+		std::vector<double> a; a.push_back(x); a.push_back(y); a.push_back(z);
+		T* t = new T(a);
+		AddEntity(t);
+		return t;
+	}
+
+	template <class T> 
+	T* addDoublet(double x, double y) {
+		std::vector<double> a; a.push_back(x); a.push_back(y);
+		T* t = new T(a);
+		AddEntity(t);
+		return t;
+	}
+
+	template <class T>
+	T* getSingle() {
+		typename T::list ts = EntitiesByType<T>();
+		if (ts->Size() != 1) return 0;
+		return *ts->begin();
+	}
+	
+	Ifc2x3::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,
+		double xx=1.0, double xy=0.0);
+
+	Ifc2x3::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, 
+		Ifc2x3::IfcObjectDefinition* relating_object, Ifc2x3::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();
+				products->push(related_object);
+				rel->setRelatedObjects(products);
+				found = true;
+				break;
+			}
+		}
+		if (! found) {
+			if (! owner_hist) {
+				owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+			}
+			if (! owner_hist) {
+				owner_hist = addOwnerHistory();
+			}
+			Ifc2x3::IfcObjectDefinition::list relating_objects (new IfcTemplatedEntityList<Ifc2x3::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();	
+	Ifc2x3::IfcProject* addProject(Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+	void relatePlacements(Ifc2x3::IfcProduct* parent, Ifc2x3::IfcProduct* product);	
+	Ifc2x3::IfcSite* addSite(Ifc2x3::IfcProject* proj = 0, Ifc2x3::IfcOwnerHistory* owner_hist = 0);	
+	Ifc2x3::IfcBuilding* addBuilding(Ifc2x3::IfcSite* site = 0, Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+
+	Ifc2x3::IfcBuildingStorey* addBuildingStorey(Ifc2x3::IfcBuilding* building = 0, 
+		Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+
+	Ifc2x3::IfcBuildingStorey* addBuildingProduct(Ifc2x3::IfcProduct* product, 
+		Ifc2x3::IfcBuildingStorey* storey = 0, Ifc2x3::IfcOwnerHistory* owner_hist = 0);
+
+	void addExtrudedPolyline(Ifc2x3::IfcShapeRepresentation* rep, const std::vector<std::pair<double, double> >& points, double h, 
+		Ifc2x3::IfcAxis2Placement2D* place=0, Ifc2x3::IfcAxis2Placement3D* place2=0, 
+		Ifc2x3::IfcDirection* dir=0, Ifc2x3::IfcRepresentationContext* context=0);
+
+	Ifc2x3::IfcProductDefinitionShape* addExtrudedPolyline(const std::vector<std::pair<double, double> >& points, double h, 
+		Ifc2x3::IfcAxis2Placement2D* place=0, Ifc2x3::IfcAxis2Placement3D* place2=0, Ifc2x3::IfcDirection* dir=0, 
+		Ifc2x3::IfcRepresentationContext* context=0);
+
+	void addBox(Ifc2x3::IfcShapeRepresentation* rep, double w, double d, double h, 
+		Ifc2x3::IfcAxis2Placement2D* place=0, Ifc2x3::IfcAxis2Placement3D* place2=0, 
+		Ifc2x3::IfcDirection* dir=0, Ifc2x3::IfcRepresentationContext* context=0);
+
+	Ifc2x3::IfcProductDefinitionShape* addBox(double w, double d, double h, Ifc2x3::IfcAxis2Placement2D* place=0, 
+		Ifc2x3::IfcAxis2Placement3D* place2=0, Ifc2x3::IfcDirection* dir=0, Ifc2x3::IfcRepresentationContext* context=0);
+
+	void clipRepresentation(Ifc2x3::IfcProductRepresentation* shape, 
+		Ifc2x3::IfcAxis2Placement3D* place, bool agree);
+
+	Ifc2x3::IfcPresentationStyleAssignment* setSurfaceColour(Ifc2x3::IfcProductRepresentation* shape, 
+		double r, double g, double b, double a=1.0);
+
+	void setSurfaceColour(Ifc2x3::IfcProductRepresentation* shape, 
+		Ifc2x3::IfcPresentationStyleAssignment* style_assignment);
+
+};
+
+template <>
+inline void IfcHierarchyHelper::addRelatedObject <Ifc2x3::IfcRelContainedInSpatialStructure> (Ifc2x3::IfcObjectDefinition* related_object, 
+	Ifc2x3::IfcObjectDefinition* relating_object, Ifc2x3::IfcOwnerHistory* owner_hist)
+{
+	Ifc2x3::IfcRelContainedInSpatialStructure::list li = EntitiesByType<Ifc2x3::IfcRelContainedInSpatialStructure>();
+	bool found = false;
+	for (Ifc2x3::IfcRelContainedInSpatialStructure::it i = li->begin(); i != li->end(); ++i) {
+		Ifc2x3::IfcRelContainedInSpatialStructure* rel = *i;
+		if (rel->RelatingStructure() == relating_object) {
+			Ifc2x3::IfcProduct::list products = rel->RelatedElements();
+			products->push((Ifc2x3::IfcProduct*)related_object);
+			rel->setRelatedElements(products);
+			found = true;
+			break;
+		}
+	}
+	if (! found) {
+		if (! owner_hist) {
+			owner_hist = getSingle<Ifc2x3::IfcOwnerHistory>();
+		}
+		if (! owner_hist) {
+			owner_hist = addOwnerHistory();
+		}
+		Ifc2x3::IfcProduct::list relating_objects (new IfcTemplatedEntityList<Ifc2x3::IfcProduct>());
+		relating_objects->push((Ifc2x3::IfcProduct*)relating_object);
+		Ifc2x3::IfcRelContainedInSpatialStructure* t = new Ifc2x3::IfcRelContainedInSpatialStructure(IfcWrite::IfcGuidHelper(), owner_hist, 
+			boost::none, boost::none, relating_objects, (Ifc2x3::IfcSpatialStructureElement*)related_object);
+
+		AddEntity(t);
+	}
+}
+
+#endif

src/ifcparse/IfcUtil.h

@@ -74,6 +74,9 @@ typedef IfcBaseClass* IfcSchemaEntity;
 
 }
 
+template <class T>
+class IfcTemplatedEntityList;
+
 class IfcEntityList {
 	std::vector<IfcUtil::IfcSchemaEntity> ls;
 public:
@@ -86,6 +89,12 @@ public:
 	it end();
 	IfcUtil::IfcSchemaEntity operator[] (int i);
 	int Size() const;
+	template <class U>
+	typename U::list as() {
+		typename U::list r(new IfcTemplatedEntityList<U>());
+		for ( it i = begin(); i != end(); ++ i ) if ((*i)->is(U::Class())) r->push((U*)*i);
+		return r;
+	}
 };
 
 template <class T>
@@ -104,6 +113,12 @@ public:
 		for ( it i = begin(); i != end(); ++ i ) r->push(*i);
 		return r;
 	}
+	template <class U> 
+	typename U::list as() {
+		typename U::list r(new IfcTemplatedEntityList<U>());
+		for ( it i = begin(); i != end(); ++ i ) if ((*i)->is(U::Class())) r->push(*i);
+		return r;
+	}
 };
 
 namespace IfcUtil {

src/ifcparse/IfcWritableEntity.h

@@ -31,6 +31,8 @@
 #ifndef IFCWRITABLEENTITY_H
 #define IFCWRITABLEENTITY_H
 
+#include <map>
+
 #include "IfcUtil.h"
 
 namespace IfcWrite {
@@ -57,6 +59,7 @@ namespace IfcWrite {
 		unsigned int id();
 		bool isWritable();
         void setArgument(int i);
+		void setArgument(int i,bool v);
 		void setArgument(int i,int v);
 		void setArgument(int i,int v, const char* c);
 		void setArgument(int i,const std::string& v);

src/ifcparse/IfcWrite.cpp

@@ -17,10 +17,10 @@
  *                                                                              *
  ********************************************************************************/
 
-#include "IfcParse.h" 
-#include "IfcWrite.h"
-#include "IfcWritableEntity.h"
-#include "IfcCharacterDecoder.h"
+#include "../ifcparse/IfcParse.h" 
+#include "../ifcparse/IfcWrite.h"
+#include "../ifcparse/IfcWritableEntity.h"
+#include "../ifcparse/IfcCharacterDecoder.h"
 
 using namespace IfcWrite;
 
@@ -70,7 +70,7 @@ IfcEntities IfcWritableEntity::getInverse(Ifc2x3::Type::Enum c, int i, const std
 }
 
 std::string IfcWritableEntity::datatype() { return Ifc2x3::Type::ToString(_type); }
-ArgumentPtr IfcWritableEntity::getArgument (unsigned int i) { if ( i >= getArgumentCount() ) throw; return args[i]; }
+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; }
 bool IfcWritableEntity::is(Ifc2x3::Type::Enum v) const { return _type == v; }
@@ -102,84 +102,89 @@ void IfcWritableEntity::arg_writable(int i, bool b) {
 }
 void IfcWritableEntity::setArgument(int i) {
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteNullArgument();
+	args[i] = new IfcWriteNullArgument(this);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,int v) {
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteIntegralArgument(v);
+	args[i] = new IfcWriteIntegralArgument(this,v);
+	arg_writable(i,true);
+}
+void IfcWritableEntity::setArgument(int i,bool v) {
+	if ( arg_writable(i) ) delete args[i];
+	args[i] = new IfcWriteIntegralArgument(this,v);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,int v, const char* c){
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteEnumerationArgument(v,c);
+	args[i] = new IfcWriteEnumerationArgument(this,v,c);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,const std::string& v){
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteIntegralArgument(v);
+	args[i] = new IfcWriteIntegralArgument(this,v);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,double v){
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteIntegralArgument(v);
+	args[i] = new IfcWriteIntegralArgument(this,v);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,IfcUtil::IfcSchemaEntity v){
 	if ( arg_writable(i) ) delete args[i];
-	if ( v ) args[i] = new IfcWriteIntegralArgument(v);
-	else args[i] = new IfcWriteNullArgument();
+	if ( v ) args[i] = new IfcWriteIntegralArgument(this,v);
+	else args[i] = new IfcWriteNullArgument(this);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,IfcEntities v){
 	if ( arg_writable(i) ) delete args[i];
-	if ( v.get() ) args[i] = new IfcWriteEntityListArgument(v);
-	else args[i] = new IfcWriteNullArgument();
+	if ( v.get() ) args[i] = new IfcWriteEntityListArgument(this,v);
+	else args[i] = new IfcWriteNullArgument(this);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,const std::vector<double>& v){
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteIntegralArgument(v);
+	args[i] = new IfcWriteIntegralArgument(this,v);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,const std::vector<std::string>& v){
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteIntegralArgument(v);
+	args[i] = new IfcWriteIntegralArgument(this,v);
 	arg_writable(i,true);
 }
 void IfcWritableEntity::setArgument(int i,const std::vector<int>& v){
 	if ( arg_writable(i) ) delete args[i];
-	args[i] = new IfcWriteIntegralArgument(v);
+	args[i] = new IfcWriteIntegralArgument(this,v);
 	arg_writable(i,true);
 }
 
-IfcWriteNullArgument::operator int() const { throw; }
-IfcWriteNullArgument::operator bool() const { throw; }
-IfcWriteNullArgument::operator double() const { throw; }
-IfcWriteNullArgument::operator std::string() const { throw; }
-IfcWriteNullArgument::operator std::vector<double>() const { throw; }
-IfcWriteNullArgument::operator std::vector<int>() const { throw; }
-IfcWriteNullArgument::operator std::vector<std::string>() const { throw; }
-IfcWriteNullArgument::operator IfcUtil::IfcSchemaEntity() const { throw; }
-IfcWriteNullArgument::operator IfcEntities() const { throw; }
+IfcWriteNullArgument::operator int() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator bool() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator double() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator std::string() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator std::vector<double>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator std::vector<int>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator std::vector<std::string>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator IfcUtil::IfcSchemaEntity() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteNullArgument::operator IfcEntities() const { throw IfcParse::IfcException("Invalid cast"); }
 bool IfcWriteNullArgument::isNull() const { return true; }
-ArgumentPtr IfcWriteNullArgument::operator [] (unsigned int i) const { throw; }
+ArgumentPtr IfcWriteNullArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
 std::string IfcWriteNullArgument::toString(bool upper) const { return "$"; }
-unsigned int IfcWriteNullArgument::Size() const { throw; }
+unsigned int IfcWriteNullArgument::Size() const { throw IfcParse::IfcException("Invalid cast"); }
 
-IfcWriteEntityListArgument::IfcWriteEntityListArgument(const IfcEntities& v) { value = v; }
-IfcWriteEntityListArgument::operator int() const { throw; }
-IfcWriteEntityListArgument::operator bool() const { throw; }
-IfcWriteEntityListArgument::operator double() const { throw; }
-IfcWriteEntityListArgument::operator std::string() const { throw; }
-IfcWriteEntityListArgument::operator std::vector<double>() const { throw; }
-IfcWriteEntityListArgument::operator std::vector<int>() const { throw; }
-IfcWriteEntityListArgument::operator std::vector<std::string>() const { throw; }
-IfcWriteEntityListArgument::operator IfcUtil::IfcSchemaEntity() const { throw; }
+IfcWriteEntityListArgument::IfcWriteEntityListArgument(IfcAbstractEntity* e, const IfcEntities& v) : IfcWriteArgument(e) { value = v; }
+IfcWriteEntityListArgument::operator int() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator bool() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator double() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator std::string() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator std::vector<double>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator std::vector<int>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator std::vector<std::string>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEntityListArgument::operator IfcUtil::IfcSchemaEntity() const { throw IfcParse::IfcException("Invalid cast"); }
 IfcWriteEntityListArgument::operator IfcEntities() const { return value; }
 bool IfcWriteEntityListArgument::isNull() const { return false; }
 unsigned int IfcWriteEntityListArgument::Size() const { return value->Size(); }
-ArgumentPtr IfcWriteEntityListArgument::operator [] (unsigned int i) const { throw; }
+ArgumentPtr IfcWriteEntityListArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
 std::string IfcWriteEntityListArgument::toString(bool upper)  const {
 	std::ostringstream ss;
 	ss << "(";
@@ -189,6 +194,7 @@ std::string IfcWriteEntityListArgument::toString(bool upper)  const {
 		if ( Ifc2x3::Type::IsSimple(e->type()) ) {
 			ss << e->toString(upper);
 		} else {
+			if (!e->file) e->file = entity->file;
 			ss << "#" << e->id();
 		}
 	}
@@ -196,29 +202,29 @@ std::string IfcWriteEntityListArgument::toString(bool upper)  const {
 	return ss.str();
 }
 
-IfcWriteEnumerationArgument::IfcWriteEnumerationArgument(int v, const char* c) {data=v; enumeration_value = c;}
-IfcWriteEnumerationArgument::operator int() const { throw; }
-IfcWriteEnumerationArgument::operator bool() const { throw; }
-IfcWriteEnumerationArgument::operator double() const { throw; }
+IfcWriteEnumerationArgument::IfcWriteEnumerationArgument(IfcAbstractEntity* e, int v, const char* c) : IfcWriteArgument(e) {data=v; enumeration_value = c;}
+IfcWriteEnumerationArgument::operator int() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEnumerationArgument::operator bool() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEnumerationArgument::operator double() const { throw IfcParse::IfcException("Invalid cast"); }
 IfcWriteEnumerationArgument::operator std::string() const { return std::string(enumeration_value); }
-IfcWriteEnumerationArgument::operator std::vector<double>() const { throw; }
-IfcWriteEnumerationArgument::operator std::vector<int>() const { throw; }
-IfcWriteEnumerationArgument::operator std::vector<std::string>() const { throw; }
-IfcWriteEnumerationArgument::operator IfcUtil::IfcSchemaEntity() const { throw; }
-IfcWriteEnumerationArgument::operator IfcEntities() const { throw; }
+IfcWriteEnumerationArgument::operator std::vector<double>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEnumerationArgument::operator std::vector<int>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEnumerationArgument::operator std::vector<std::string>() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEnumerationArgument::operator IfcUtil::IfcSchemaEntity() const { throw IfcParse::IfcException("Invalid cast"); }
+IfcWriteEnumerationArgument::operator IfcEntities() const { throw IfcParse::IfcException("Invalid cast"); }
 bool IfcWriteEnumerationArgument::isNull() const { return false; }
-ArgumentPtr IfcWriteEnumerationArgument::operator [] (unsigned int i) const { throw; }
+ArgumentPtr IfcWriteEnumerationArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
 std::string IfcWriteEnumerationArgument::toString(bool upper) const { return std::string(".") + enumeration_value + '.';}
-unsigned int IfcWriteEnumerationArgument::Size() const { throw; }
+unsigned int IfcWriteEnumerationArgument::Size() const { throw IfcParse::IfcException("Invalid cast"); }
 
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(int v) {data=new int(v); type = Argument_INT;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(bool v) {data=new bool(v); type = Argument_BOOL;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(double v) {data=new double(v); type = Argument_DOUBLE;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(const std::string& v) {data=new std::string(v); type = Argument_STRING;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(const std::vector<int> v) {data=new std::vector<int>(v); type = Argument_VECTOR_INT;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(const std::vector<double> v) {data=new std::vector<double>(v); type = Argument_VECTOR_DOUBLE;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(const std::vector<std::string> v) {data=new std::vector<std::string>(v); type = Argument_VECTOR_STRING;}
-IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcUtil::IfcSchemaEntity v) {data=v; type = Argument_ENTITY;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, int v) : IfcWriteArgument(e) {data=new int(v); type = Argument_INT;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, bool v) : IfcWriteArgument(e) {data=new bool(v); type = Argument_BOOL;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, double v) : IfcWriteArgument(e) {data=new double(v); type = Argument_DOUBLE;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::string& v) : IfcWriteArgument(e) {data=new std::string(v); type = Argument_STRING;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::vector<int> v) : IfcWriteArgument(e) {data=new std::vector<int>(v); type = Argument_VECTOR_INT;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::vector<double> v) : IfcWriteArgument(e) {data=new std::vector<double>(v); type = Argument_VECTOR_DOUBLE;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::vector<std::string> v) : IfcWriteArgument(e) {data=new std::vector<std::string>(v); type = Argument_VECTOR_STRING;}
+IfcWriteIntegralArgument::IfcWriteIntegralArgument(IfcAbstractEntity* e, IfcUtil::IfcSchemaEntity v) : IfcWriteArgument(e) {data=v; type = Argument_ENTITY;}
 IfcWriteIntegralArgument::~IfcWriteIntegralArgument() {
 	switch ( type ) {
 	case Argument_INT:
@@ -246,15 +252,15 @@ IfcWriteIntegralArgument::~IfcWriteIntegralArgument() {
 		break;
 	}
 }
-IfcWriteIntegralArgument::operator int() const { if ( type != Argument_INT ) throw; return *(int*)data; }
-IfcWriteIntegralArgument::operator bool() const { if ( type != Argument_BOOL ) throw; return *(bool*)data; }
-IfcWriteIntegralArgument::operator double() const { if ( type != Argument_DOUBLE ) throw; return *(double*)data; }
-IfcWriteIntegralArgument::operator std::string() const { if ( type != Argument_STRING ) throw; return *(std::string*)data; }
-IfcWriteIntegralArgument::operator std::vector<double>() const { if ( type != Argument_VECTOR_DOUBLE ) throw; return *(std::vector<double>*)data; }
-IfcWriteIntegralArgument::operator std::vector<int>() const { if ( type != Argument_VECTOR_INT ) throw; return *(std::vector<int>*)data; }
-IfcWriteIntegralArgument::operator std::vector<std::string>() const { if ( type != Argument_VECTOR_STRING ) throw; return *(std::vector<std::string>*)data; }
-IfcWriteIntegralArgument::operator IfcUtil::IfcSchemaEntity() const { if ( type != Argument_ENTITY ) throw; return (IfcUtil::IfcSchemaEntity)data; }
-IfcWriteIntegralArgument::operator IfcEntities() const { throw; }
+IfcWriteIntegralArgument::operator int() const { if ( type != Argument_INT ) throw IfcParse::IfcException("Invalid cast"); return *(int*)data; }
+IfcWriteIntegralArgument::operator bool() const { if ( type != Argument_BOOL ) throw IfcParse::IfcException("Invalid cast"); return *(bool*)data; }
+IfcWriteIntegralArgument::operator double() const { if ( type != Argument_DOUBLE ) throw IfcParse::IfcException("Invalid cast"); return *(double*)data; }
+IfcWriteIntegralArgument::operator std::string() const { if ( type != Argument_STRING ) throw IfcParse::IfcException("Invalid cast"); return *(std::string*)data; }
+IfcWriteIntegralArgument::operator std::vector<double>() const { if ( type != Argument_VECTOR_DOUBLE ) throw IfcParse::IfcException("Invalid cast"); return *(std::vector<double>*)data; }
+IfcWriteIntegralArgument::operator std::vector<int>() const { if ( type != Argument_VECTOR_INT ) throw IfcParse::IfcException("Invalid cast"); return *(std::vector<int>*)data; }
+IfcWriteIntegralArgument::operator std::vector<std::string>() const { if ( type != Argument_VECTOR_STRING ) throw IfcParse::IfcException("Invalid cast"); return *(std::vector<std::string>*)data; }
+IfcWriteIntegralArgument::operator IfcUtil::IfcSchemaEntity() const { if ( type != Argument_ENTITY ) throw IfcParse::IfcException("Invalid cast"); return (IfcUtil::IfcSchemaEntity)data; }
+IfcWriteIntegralArgument::operator IfcEntities() const { throw IfcParse::IfcException("Invalid cast"); }
 bool IfcWriteIntegralArgument::isNull() const { return false; }
 unsigned int IfcWriteIntegralArgument::Size() const { 
 	switch ( type ) {
@@ -268,11 +274,36 @@ unsigned int IfcWriteIntegralArgument::Size() const {
 		return ((std::vector<std::string>*) data)->size();
 		break;
 	default:
-		throw;
+		throw IfcParse::IfcException("Invalid cast");
 		break;
 	}
 }
-ArgumentPtr IfcWriteIntegralArgument::operator [] (unsigned int i) const { throw; }
+
+// The REAL token definition from the IFC SPF standard does not necessarily match
+// the output of the C++ ostream formatting operation.
+// REAL = [ SIGN ] DIGIT { DIGIT } "." { DIGIT } [ "E" [ SIGN ] DIGIT { DIGIT } ] .
+std::string format_double(const double& d) {
+	std::ostringstream oss;
+	oss << d;
+	const std::string str = oss.str();
+	oss.str("");
+	std::string::size_type e = str.find('e');
+	if (e == std::string::npos) {
+		e = str.find('E');
+	}
+	const std::string mantissa = str.substr(0,e);
+	oss << mantissa;
+	if (mantissa.find('.') == std::string::npos) {
+		oss << ".";
+	}
+	if (e != std::string::npos) {
+		oss << "E";
+		oss << str.substr(e+1);
+	}
+	return oss.str();
+}
+
+ArgumentPtr IfcWriteIntegralArgument::operator [] (unsigned int i) const { throw IfcParse::IfcException("Invalid cast"); }
 std::string IfcWriteIntegralArgument::toString(bool upper) const {
 	std::ostringstream ss;
 	switch ( type ) {
@@ -283,7 +314,7 @@ std::string IfcWriteIntegralArgument::toString(bool upper) const {
 		ss << ((*(bool*) data) ? ".T." : ".F.");
 		break;
 	case Argument_DOUBLE:
-		ss << *(double*) data;
+		ss << format_double(*(double*) data);		
 		break;
 	case Argument_STRING: {
 		std::string d = *(std::string*) data;
@@ -304,7 +335,7 @@ std::string IfcWriteIntegralArgument::toString(bool upper) const {
 		{const std::vector<double>& v = *(std::vector<double>*) data;
 		for ( std::vector<double>::const_iterator it = v.begin(); it != v.end(); ++ it ) {
 			if ( it != v.begin() ) ss << ",";
-			ss << *it;
+			ss << format_double(*it);
 		}}
 		ss << ")";
 		break;
@@ -322,19 +353,20 @@ std::string IfcWriteIntegralArgument::toString(bool upper) const {
 		if ( Ifc2x3::Type::IsSimple(e->type()) ) {
 			ss << e->toString(upper);
 		} else {
+			if (!e->file) e->file = entity->file;
 			ss << "#" << e->id();
 		}}
 		break;
-	default: throw;
+	default: throw IfcParse::IfcException("Invalid cast");
 	}
 	return ss.str();
 }
 
-IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum,int,const std::string &) {throw;}
-IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum) {throw;}
+IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum,int,const std::string &) {throw IfcParse::IfcException("Invalid cast");}
+IfcEntities IfcSelectHelperEntity::getInverse(Ifc2x3::Type::Enum) {throw IfcParse::IfcException("Invalid cast");}
 std::string IfcSelectHelperEntity::datatype() { return Ifc2x3::Type::ToString(_type); }
 ArgumentPtr IfcSelectHelperEntity::getArgument(unsigned int i) {
-	if ( i != 0 ) throw;
+	if ( i != 0 ) throw IfcParse::IfcException("Invalid cast");
 	return arg;
 }
 unsigned int IfcSelectHelperEntity::getArgumentCount() { return 1; }
@@ -349,27 +381,27 @@ std::string IfcSelectHelperEntity::toString(bool upper) {
 	ss << dt << "(" << arg->toString(upper) << ")";
 	return ss.str();
 }
-unsigned int IfcSelectHelperEntity::id() { throw; }
-bool IfcSelectHelperEntity::isWritable() { throw; }
+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) {
-	IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
+	IfcWriteArgument* a = new IfcWriteIntegralArgument(0,v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
 IfcSelectHelper::IfcSelectHelper(const char* const v, Ifc2x3::Type::Enum t) {
-	IfcWriteArgument* a = new IfcWriteIntegralArgument(std::string(v));
+	IfcWriteArgument* a = new IfcWriteIntegralArgument(0,std::string(v));
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
 IfcSelectHelper::IfcSelectHelper(int v, Ifc2x3::Type::Enum t) {
-	IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
+	IfcWriteArgument* a = new IfcWriteIntegralArgument(0,v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
 IfcSelectHelper::IfcSelectHelper(double v, Ifc2x3::Type::Enum t) {
-	IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
+	IfcWriteArgument* a = new IfcWriteIntegralArgument(0,v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
 IfcSelectHelper::IfcSelectHelper(bool v, Ifc2x3::Type::Enum t) {
-	IfcWriteArgument* a = new IfcWriteIntegralArgument(v);
+	IfcWriteArgument* a = new IfcWriteIntegralArgument(0,v);
 	this->entity = new IfcSelectHelperEntity(t,a);
 }
 bool IfcSelectHelper::is(Ifc2x3::Type::Enum t) const { return entity->is(t); }

src/ifcparse/IfcWrite.h

@@ -28,19 +28,22 @@
 #ifndef IFCWRITE_H
 #define IFCWRITE_H
 
-#include "IfcUtil.h"
-#include "IfcParse.h"
+#include "../ifcparse/IfcUtil.h"
+#include "../ifcparse/IfcParse.h"
 
 namespace IfcWrite {
 
 	/// A placeholder class for grouping functionality geared towards writing IFC files
 	class IfcWriteArgument : public Argument {
-
+	protected:
+		IfcAbstractEntity* entity;
+		IfcWriteArgument(IfcAbstractEntity* e) : entity(e) {}
 	};
 
 	/// A null argument. It will always serialize to $
 	class IfcWriteNullArgument : public IfcWriteArgument {
 	public:
+		IfcWriteNullArgument(IfcAbstractEntity* e) : IfcWriteArgument(e) {};
 		operator int() const;
 		operator bool() const;
 		operator double() const;
@@ -63,7 +66,7 @@ namespace IfcWrite {
 	private:
 		IfcEntities value;
 	public:
-		IfcWriteEntityListArgument(const IfcEntities& v);
+		IfcWriteEntityListArgument(IfcAbstractEntity* e, const IfcEntities& v);
 		operator int() const;
 		operator bool() const;
 		operator double() const;
@@ -90,7 +93,7 @@ namespace IfcWrite {
 		int data;
 		const char* enumeration_value;
 	public:
-		IfcWriteEnumerationArgument(int v, const char* c);
+		IfcWriteEnumerationArgument(IfcAbstractEntity* e, int v, const char* c);
 		operator int() const;
 		operator bool() const;
 		operator double() const;
@@ -114,14 +117,14 @@ namespace IfcWrite {
 		void* data;
 		IfcUtil::ArgumentType type;
 	public:
-		IfcWriteIntegralArgument(int v);
-		IfcWriteIntegralArgument(bool v);
-		IfcWriteIntegralArgument(double v);
-		IfcWriteIntegralArgument(const std::string& v);
-		IfcWriteIntegralArgument(const std::vector<int> v);
-		IfcWriteIntegralArgument(const std::vector<double> v);
-		IfcWriteIntegralArgument(const std::vector<std::string> v);
-		IfcWriteIntegralArgument(IfcUtil::IfcSchemaEntity v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, int v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, bool v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, double v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::string& v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::vector<int> v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::vector<double> v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, const std::vector<std::string> v);
+		IfcWriteIntegralArgument(IfcAbstractEntity* e, IfcUtil::IfcSchemaEntity v);
 		~IfcWriteIntegralArgument();
 		operator int() const;
 		operator bool() const;