Update ifcgeom

src/ifcgeom/IfcGeom.h

@@ -66,9 +66,9 @@ inline static bool ALMOST_THE_SAME(const T& a, const T& b, double tolerance=ALMO
 
 #else
 
-#define IN_CACHE(T,E,t,e) std::map<int,t>::const_iterator it = cache.T.find(E->entity->id());\
+#define IN_CACHE(T,E,t,e) std::map<int,t>::const_iterator it = cache.T.find(E->data().id());\
 if ( it != cache.T.end() ) { e = it->second; return true; }
-#define CACHE(T,E,e) cache.T[E->entity->id()] = e;
+#define CACHE(T,E,e) cache.T[E->data().id()] = e;
 
 #endif
 
@@ -268,7 +268,7 @@ public:
 #ifdef USE_IFC4
 		IfcEntityList::ptr style_assignments = si->Styles();
 		for (IfcEntityList::it kt = style_assignments->begin(); kt != style_assignments->end(); ++kt) {
-			if (!(*kt)->is(IfcSchema::Type::IfcPresentationStyleAssignment)) {
+			if (!(*kt)->declaration().is(IfcSchema::Type::IfcPresentationStyleAssignment)) {
 				continue;
 			}
 			IfcSchema::IfcPresentationStyleAssignment* style_assignment = (IfcSchema::IfcPresentationStyleAssignment*) *kt;
@@ -280,12 +280,12 @@ public:
 			IfcEntityList::ptr styles = style_assignment->Styles();
 			for (IfcEntityList::it lt = styles->begin(); lt != styles->end(); ++lt) {
 				IfcUtil::IfcBaseClass* style = *lt;
-				if (style->is(IfcSchema::Type::IfcSurfaceStyle)) {
+				if (style->declaration().is(IfcSchema::Type::IfcSurfaceStyle)) {
 					IfcSchema::IfcSurfaceStyle* surface_style = (IfcSchema::IfcSurfaceStyle*) style;
 					if (surface_style->Side() != IfcSchema::IfcSurfaceSide::IfcSurfaceSide_NEGATIVE) {
 						IfcEntityList::ptr styles_elements = surface_style->Styles();
 						for (IfcEntityList::it mt = styles_elements->begin(); mt != styles_elements->end(); ++mt) {
-							if ((*mt)->is(T::Class())) {
+							if ((*mt)->declaration().is(T::Class())) {
 								return std::make_pair(surface_style, (T*) *mt);
 							}
 						}

src/ifcgeom/IfcGeomCurves.cpp

@@ -86,12 +86,12 @@
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircle* l, Handle(Geom_Curve)& curve) {
 	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
 	if ( r < ALMOST_ZERO ) { 
-		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
 		return false;
 	}
 	gp_Trsf trsf;
 	IfcSchema::IfcAxis2Placement* placement = l->Position();
-	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+	if (placement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D)) {
 		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
@@ -106,7 +106,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve)
 	double x = l->SemiAxis1() * getValue(GV_LENGTH_UNIT);
 	double y = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
 	if (x < ALMOST_ZERO || y < ALMOST_ZERO) { 
-		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Radius not greater than zero for:", l);
 		return false;
 	}
 	// Open Cascade does not allow ellipses of which the minor radius
@@ -116,7 +116,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipse* l, Handle(Geom_Curve)
 	const bool rotated = y > x;
 	gp_Trsf trsf;
 	IfcSchema::IfcAxis2Placement* placement = l->Position();
-	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+	if (placement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D)) {
 		convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf2d;
@@ -144,7 +144,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLine* l, Handle(Geom_Curve)& c
 #ifdef USE_IFC4
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcBSplineCurveWithKnots* l, Handle(Geom_Curve)& curve) {
 
-	const bool is_rational = l->is(IfcSchema::Type::IfcRationalBSplineCurveWithKnots);
+	const bool is_rational = l->declaration().is(IfcSchema::Type::IfcRationalBSplineCurveWithKnots);
 
 	const IfcSchema::IfcCartesianPoint::list::ptr cps = l->ControlPointsList();
 	const std::vector<int> mults = l->KnotMultiplicities();

src/ifcgeom/IfcGeomFaces.cpp

@@ -107,7 +107,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 	IfcSchema::IfcFaceBound::list::ptr bounds = l->Bounds();
 
 	Handle(Geom_Surface) face_surface;
-	const bool is_face_surface = l->is(IfcSchema::Type::IfcFaceSurface);
+	const bool is_face_surface = l->declaration().is(IfcSchema::Type::IfcFaceSurface);
 
 	if (is_face_surface) {
 		IfcSchema::IfcFaceSurface* fs = (IfcSchema::IfcFaceSurface*) l;
@@ -129,7 +129,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 
 	for (IfcSchema::IfcFaceBound::list::it it = bounds->begin(); it != bounds->end(); ++it) {
 		IfcSchema::IfcFaceBound* bound = *it;
-		if (bound->is(IfcSchema::Type::IfcFaceOuterBound)) num_outer_bounds ++;
+		if (bound->declaration().is(IfcSchema::Type::IfcFaceOuterBound)) num_outer_bounds ++;
 	}
 
 	// The number of outer bounds should be one according to the schema. Also Open Cascade
@@ -137,7 +137,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 	// the face will still be processed as long as there are no holes. A compound of faces
 	// is returned in that case.
 	if (num_bounds > 1 && num_outer_bounds > 1 && num_bounds != num_outer_bounds) {
-		Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Invalid configuration of boundaries for:", l);
 		return false;
 	}
 
@@ -163,7 +163,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 		
 			bool same_sense = bound->Orientation();
 			const bool is_interior = 
-				!bound->is(IfcSchema::Type::IfcFaceOuterBound) &&
+				!bound->declaration().is(IfcSchema::Type::IfcFaceOuterBound) &&
 				(num_bounds > 1) &&
 				(num_outer_bounds < num_bounds);
 
@@ -172,14 +172,14 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 		
 			TopoDS_Wire wire;
 			if (!convert_wire(loop, wire)) {
-				Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop->entity);
+				Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary loop", loop);
 				delete mf;
 				return false;
 			}
 
 			/*
 			The approach below does not result in a significant speed-up
-			if (loop->is(IfcSchema::Type::IfcPolyLoop) && processed == 0 && face_surface.IsNull()) {
+			if (loop->declaration().is(IfcSchema::Type::IfcPolyLoop) && processed == 0 && face_surface.IsNull()) {
 				IfcSchema::IfcPolyLoop* polyloop = (IfcSchema::IfcPolyLoop*) loop;
 				IfcSchema::IfcCartesianPoint::list::ptr points = polyloop->Polygon();
 
@@ -275,7 +275,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 					const bool sewing_shells = getValue(GV_MAX_FACES_TO_SEW) > -1;
 
 					if (non_planar && sewing_shells && bounds->size() == 1 && face_surface.IsNull()) {
-						Logger::Message(Logger::LOG_ERROR, "Triangulating face boundary", bound->entity);
+						Logger::Message(Logger::LOG_ERROR, "Triangulating face boundary", bound);
 
 						// When creating a solid, flatting the boundary only postpones the issue to
 						// creating a topological manifold out of the individual faces.
@@ -297,10 +297,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFace* l, TopoDS_Shape& face) {
 					}
 
 					if (!non_planar || flattened_wire || !flatten_wire(wire)) {
-						Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary", bound->entity);
+						Logger::Message(Logger::LOG_ERROR, "Failed to process face boundary", bound);
 						return false;
 					} else {
-						Logger::Message(Logger::LOG_ERROR, "Flattening face boundary", bound->entity);
+						Logger::Message(Logger::LOG_ERROR, "Flattening face boundary", bound);
 						flattened_wire = true;
 						goto process_wire;
 					}
@@ -401,7 +401,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleProfileDef* l, TopoDS
 	const double y = l->YDim() / 2.0f * getValue(GV_LENGTH_UNIT);
 
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -424,7 +424,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRoundedRectangleProfileDef* l,
 	const double r = l->RoundingRadius() * getValue(GV_LENGTH_UNIT);
 
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO || r < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -455,7 +455,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangleHollowProfileDef* l,
 	const double r2 = fr2 ? l->InnerFilletRadius() * getValue(GV_LENGTH_UNIT) : 0.;
 	
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -504,7 +504,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrapeziumProfileDef* l, TopoDS
 	const double y = l->YDim() / 2.0f  * getValue(GV_LENGTH_UNIT);
 
 	if ( x1 < ALMOST_ZERO || w < ALMOST_ZERO || y < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -536,7 +536,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIShapeProfileDef* l, TopoDS_Sh
 	bool doFillet2 = doFillet1;
 	double x2 = x1, dy2 = dy1, f2 = f1;
 
-	if (l->is(IfcSchema::Type::IfcAsymmetricIShapeProfileDef)) {
+	if (l->declaration().is(IfcSchema::Type::IfcAsymmetricIShapeProfileDef)) {
 		IfcSchema::IfcAsymmetricIShapeProfileDef* assym = (IfcSchema::IfcAsymmetricIShapeProfileDef*) l;
 		x2 = assym->TopFlangeWidth() / 2. * getValue(GV_LENGTH_UNIT);
 		doFillet2 = assym->hasTopFlangeFilletRadius();
@@ -549,7 +549,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIShapeProfileDef* l, TopoDS_Sh
 	}	
 
 	if ( x1 < ALMOST_ZERO || x2 < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || dy1 < ALMOST_ZERO || dy2 < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -588,7 +588,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcZShapeProfileDef* l, TopoDS_Sh
 	}
 
 	if ( x == 0.0f || y == 0.0f || dx == 0.0f || dy == 0.0f ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -621,7 +621,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCShapeProfileDef* l, TopoDS_Sh
 	}
 
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -660,7 +660,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLShapeProfileDef* l, TopoDS_Sh
 	}
 
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -692,7 +692,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcLShapeProfileDef* l, TopoDS_Sh
 		const double det = a1*b2 - a2*b1;
 
 		if (ALMOST_THE_SAME(det, 0.)) {
-			Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:",l->entity);
+			Logger::Message(Logger::LOG_NOTICE, "Legs do not intersect for:",l);
 			return false;
 		}
 
@@ -744,7 +744,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcUShapeProfileDef* l, TopoDS_Sh
 	}
 
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 
@@ -778,7 +778,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh
 	const double webSlope = hasWebSlope ? (l->WebSlope() * getValue(GV_PLANEANGLE_UNIT)) : 0.;
 
 	if ( x < ALMOST_ZERO || y < ALMOST_ZERO || d1 < ALMOST_ZERO || d2 < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 	
@@ -826,7 +826,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh
 		const double det = a1*b2 - a2*b1;
 
 		if (ALMOST_THE_SAME(det, 0.)) {
-			Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:",l->entity);
+			Logger::Message(Logger::LOG_NOTICE, "Web and flange do not intersect for:",l);
 			return false;
 		}
 
@@ -855,7 +855,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTShapeProfileDef* l, TopoDS_Sh
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleProfileDef* l, TopoDS_Shape& face) {
 	const double r = l->Radius() * getValue(GV_LENGTH_UNIT);
 	if ( r == 0.0f ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 	
@@ -887,7 +887,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCircleHollowProfileDef* l, Top
 	const double t = l->WallThickness() * getValue(GV_LENGTH_UNIT);
 	
 	if ( r == 0.0f || t == 0.0f ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 	
@@ -923,7 +923,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEllipseProfileDef* l, TopoDS_S
 	double ry = l->SemiAxis2() * getValue(GV_LENGTH_UNIT);
 
 	if ( rx < ALMOST_ZERO || ry < ALMOST_ZERO ) {
-		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l->entity);
+		Logger::Message(Logger::LOG_NOTICE,"Skipping zero sized profile:",l);
 		return false;
 	}
 

src/ifcgeom/IfcGeomFilter.h

@@ -155,9 +155,9 @@ namespace IfcGeom
         std::string value(IfcSchema::IfcProduct* prod) const
         {
             for (arg_map_t::const_iterator it = args.begin(); it != args.end(); ++it) {
-                if (prod->is(it->first) && it->second < prod->entity->getArgumentCount() &&
-                    prod->getArgumentType(it->second) == IfcUtil::Argument_STRING) {
-                    Argument *arg = prod->entity->getArgument(it->second);
+                if (prod->declaration().is(it->first) && it->second < prod->data().getArgumentCount() &&
+                    prod->data().getArgumentType(it->second) == IfcUtil::Argument_STRING) {
+                    Argument *arg = prod->data().getArgument(it->second);
                     if (!arg->isNull()) {
                         return *arg;
                     }
@@ -188,7 +188,7 @@ namespace IfcGeom
                 IfcEntityInstanceData dummy(it->first);
                 IfcUtil::IfcBaseClass* base = IfcSchema::SchemaEntity(&dummy);
                 try {
-                    ss << " " << IfcSchema::Type::ToString(it->first) << "." << base->getArgumentName(it->second);
+                    ss << " " << IfcSchema::Type::ToString(it->first) << "." << base->declaration().as_entity()->all_attributes()[it->second]->name();
                 } catch (const std::exception& e) {
 					Logger::Error(e);
 				}
@@ -275,7 +275,7 @@ namespace IfcGeom
         {
             // The set is iterated over to able to filter on subtypes.
             foreach(IfcSchema::Type::Enum type, values) {
-                if (prod->is(type)) {
+                if (prod->declaration().is(type)) {
                     return true;
                 }
             }

src/ifcgeom/IfcGeomFunctions.cpp

@@ -285,7 +285,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 	for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {
 		IfcSchema::IfcRelVoidsElement* v = *it;
 		IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();
-		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
+		if ( fes->declaration().is(IfcSchema::Type::IfcOpeningElement) ) {
 			if (!fes->hasRepresentation()) continue;
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
@@ -324,7 +324,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 		const TopoDS_Shape& entity_shape_unlocated = ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
 		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
 		if ( entity_shape_gtrsf.Form() == gp_Other ) {
-			Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity->entity);
+			Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity);
 		}
 		TopoDS_Shape entity_shape = apply_transformation(entity_shape_unlocated, entity_shape_gtrsf);
 
@@ -334,7 +334,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 			const TopoDS_Shape& opening_shape_unlocated = ensure_fit_for_subtraction(it4->Shape(),opening_shape_solid);
 			const gp_GTrsf& opening_shape_gtrsf = it4->Placement();
 			if ( opening_shape_gtrsf.Form() == gp_Other ) {
-				Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to opening of:",entity->entity);
+				Logger::Message(Logger::LOG_WARNING,"Applying non uniform transformation to opening of:",entity);
 			}
 			TopoDS_Shape opening_shape = apply_transformation(opening_shape_unlocated, opening_shape_gtrsf);
 					
@@ -342,7 +342,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 			if (Logger::LOG_WARNING >= Logger::Verbosity()) {
 				opening_volume = shape_volume(opening_shape);
 				if ( opening_volume <= ALMOST_ZERO )
-					Logger::Message(Logger::LOG_WARNING,"Empty opening for:",entity->entity);
+					Logger::Message(Logger::LOG_WARNING,"Empty opening for:",entity);
 			}
 
 			if (entity_shape.ShapeType() == TopAbs_COMPSOLID) {
@@ -389,7 +389,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 						// Add the original in case subtraction fails
 						builder.Add(compound, exp.Current());
 					} else {
-						Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity);
+						Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity);
 					}
 				}
 
@@ -418,7 +418,7 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 						fix.Perform();
 						brep_cut_result = fix.Shape();
 					} catch (...) {
-						Logger::Message(Logger::LOG_WARNING, "Shape healing failed on opening subtraction result", entity->entity);
+						Logger::Message(Logger::LOG_WARNING, "Shape healing failed on opening subtraction result", entity);
 					}
 					
 					BRepCheck_Analyzer analyser(brep_cut_result);
@@ -429,13 +429,13 @@ bool IfcGeom::Kernel::convert_openings(const IfcSchema::IfcProduct* entity, cons
 							const double volume_after_subtraction = shape_volume(entity_shape);
 							double original_shape_volume = shape_volume(entity_shape);
 							if ( ALMOST_THE_SAME(original_shape_volume,volume_after_subtraction) )
-								Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",entity->entity);
+								Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",entity);
 						}
 					} else {
-						Logger::Message(Logger::LOG_ERROR,"Invalid result from subtraction:",entity->entity);
+						Logger::Message(Logger::LOG_ERROR,"Invalid result from subtraction:",entity);
 					}
 				} else {
-					Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity->entity);
+					Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",entity);
 				}
 			}
 
@@ -458,7 +458,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 	for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {
 		IfcSchema::IfcRelVoidsElement* v = *it;
 		IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();
-		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
+		if ( fes->declaration().is(IfcSchema::Type::IfcOpeningElement) ) {
 			if (!fes->hasRepresentation()) continue;
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
@@ -501,7 +501,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 		const TopoDS_Shape& entity_shape_unlocated = ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
 		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
 		if (entity_shape_gtrsf.Form() == gp_Other) {
-			Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity->entity);
+			Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity);
 		}
 		TopoDS_Shape entity_shape = apply_transformation(entity_shape_unlocated, entity_shape_gtrsf);
 
@@ -521,7 +521,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 			// Apparently processing the boolean operation failed or resulted in an invalid result
 			// in which case the original shape without the subtractions is returned instead
 			// we try convert the openings in the original way, one by one.
-			Logger::Message(Logger::LOG_WARNING,"Subtracting combined openings compound failed:",entity->entity);
+			Logger::Message(Logger::LOG_WARNING,"Subtracting combined openings compound failed:",entity);
 			return false;
 		}
 		
@@ -537,7 +537,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 	for ( IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++ it ) {
 		IfcSchema::IfcRelVoidsElement* v = *it;
 		IfcSchema::IfcFeatureElementSubtraction* fes = v->RelatedOpeningElement();
-		if ( fes->is(IfcSchema::Type::IfcOpeningElement) ) {
+		if ( fes->declaration().is(IfcSchema::Type::IfcOpeningElement) ) {
 			if (!fes->hasRepresentation()) continue;
 
 			// Convert the IfcRepresentation of the IfcOpeningElement
@@ -580,7 +580,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 		const TopoDS_Shape& entity_shape_unlocated = ensure_fit_for_subtraction(it3->Shape(),entity_shape_solid);
 		const gp_GTrsf& entity_shape_gtrsf = it3->Placement();
 		if (entity_shape_gtrsf.Form() == gp_Other) {
-			Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity->entity);
+			Logger::Message(Logger::LOG_WARNING, "Applying non uniform transformation to:", entity);
 		}
 		TopoDS_Shape entity_shape = apply_transformation(entity_shape_unlocated, entity_shape_gtrsf);
 
@@ -588,7 +588,7 @@ bool IfcGeom::Kernel::convert_openings_fast(const IfcSchema::IfcProduct* entity,
 		if (boolean_operation(entity_shape, opening_shapelist, BOPAlgo_CUT, result)) {
 			cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(result, &it3->Style()));
 		} else {
-			Logger::Message(Logger::LOG_ERROR, "Opening subtraction failed:", entity->entity);
+			Logger::Message(Logger::LOG_ERROR, "Opening subtraction failed:", entity);
 			cut_shapes.push_back(IfcGeom::IfcRepresentationShapeItem(entity_shape, &it3->Style()));
 		}
 	}
@@ -1098,7 +1098,7 @@ void IfcGeom::Kernel::sequence_of_point_to_wire(const TColgp_SequenceOfPnt& p, T
 IfcSchema::IfcRelVoidsElement::list::ptr IfcGeom::Kernel::find_openings(IfcSchema::IfcProduct* product) {
 	
 	IfcSchema::IfcRelVoidsElement::list::ptr openings(new IfcSchema::IfcRelVoidsElement::list);
-	if ( product->is(IfcSchema::Type::IfcElement) && !product->is(IfcSchema::Type::IfcOpeningElement) ) {
+	if ( product->declaration().is(IfcSchema::Type::IfcElement) && !product->declaration().is(IfcSchema::Type::IfcOpeningElement) ) {
 		IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product;
 		openings = element->HasOpenings();
 	}
@@ -1113,7 +1113,7 @@ IfcSchema::IfcRelVoidsElement::list::ptr IfcGeom::Kernel::find_openings(IfcSchem
 #endif
 		if (decomposes->size() != 1) break;
 		IfcSchema::IfcObjectDefinition* rel_obdef = (*decomposes->begin())->RelatingObject();
-		if ( rel_obdef->is(IfcSchema::Type::IfcElement) && !rel_obdef->is(IfcSchema::Type::IfcOpeningElement) ) {
+		if ( rel_obdef->declaration().is(IfcSchema::Type::IfcElement) && !rel_obdef->declaration().is(IfcSchema::Type::IfcOpeningElement) ) {
 			IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)rel_obdef;
 			openings->push(element->HasOpenings());
 		}
@@ -1150,7 +1150,7 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 {
 	std::stringstream representation_id_builder;
 
-	representation_id_builder << representation->entity->id();
+	representation_id_builder << representation->data().id();
 
 	IfcGeom::Representation::BRep* shape;
 	IfcGeom::IfcRepresentationShapeItems shapes, shapes2;
@@ -1173,7 +1173,7 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 					for (IfcSchema::IfcRelAssociates::list::it it = associations->begin(); it != associations->end(); ++it) {
 						IfcSchema::IfcRelAssociatesMaterial* associates_material = (**it).as<IfcSchema::IfcRelAssociatesMaterial>();
 						if (associates_material) {
-							unsigned layerset_id = associates_material->RelatingMaterial()->entity->id();
+							unsigned layerset_id = associates_material->RelatingMaterial()->data().id();
 							representation_id_builder << "-layerset-" << layerset_id;
 							break;
 						}
@@ -1207,14 +1207,14 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 	}
 
 	if (material_style_applied) {
-		representation_id_builder << "-material-" << single_material->entity->id();
+		representation_id_builder << "-material-" << single_material->data().id();
 	}
 
 	int parent_id = -1;
 	try {
 		IfcSchema::IfcObjectDefinition* parent_object = get_decomposing_entity(product);
 		if (parent_object) {
-			parent_id = parent_object->entity->id();
+			parent_id = parent_object->data().id();
 		}
 	} catch (const std::exception& e) {
 		Logger::Error(e);
@@ -1236,13 +1236,13 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 	// Note that openings for IfcOpeningElements are not processed
 	IfcSchema::IfcRelVoidsElement::list::ptr openings = find_openings(product);
 
-	const std::string product_type = IfcSchema::Type::ToString(product->type());
+	const std::string product_type = IfcSchema::Type::ToString(product->declaration().type());
 	ElementSettings element_settings(settings, getValue(GV_LENGTH_UNIT), product_type);
 
     if (!settings.get(IfcGeom::IteratorSettings::DISABLE_OPENING_SUBTRACTIONS) && openings && openings->size()) {
 		representation_id_builder << "-openings";
 		for (IfcSchema::IfcRelVoidsElement::list::it it = openings->begin(); it != openings->end(); ++it) {
-			representation_id_builder << "-" << (*it)->entity->id();
+			representation_id_builder << "-" << (*it)->data().id();
 		}
 
 		IfcGeom::IfcRepresentationShapeItems opened_shapes;
@@ -1266,7 +1266,7 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 				convert_openings(product,openings,shapes,trsf,opened_shapes);
 			}
 		} catch(...) { 
-			Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",product->entity); 
+			Logger::Message(Logger::LOG_ERROR,"Error processing openings for:",product); 
 		}
         if (settings.get(IteratorSettings::USE_WORLD_COORDS)) {
 			for ( IfcGeom::IfcRepresentationShapeItems::iterator it = opened_shapes.begin(); it != opened_shapes.end(); ++ it ) {
@@ -1295,7 +1295,7 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_representation_and_pro
 	}
 
 	return new BRepElement<P>(
-		product->entity->id(),
+		product->data().id(),
 		parent_id,
 		name, 
 		product_type,
@@ -1312,7 +1312,7 @@ IfcSchema::IfcRepresentation* IfcGeom::Kernel::representation_mapped_to(const If
 	IfcSchema::IfcRepresentationItem::list::ptr items = representation->Items();
 	if (items->size() == 1) {
 		IfcSchema::IfcRepresentationItem* item = *items->begin();
-		if (item->is(IfcSchema::Type::IfcMappedItem)) {
+		if (item->declaration().is(IfcSchema::Type::IfcMappedItem)) {
 			if (item->StyledByItem()->size() == 0) {
 				IfcSchema::IfcMappedItem* mapped_item = item->as<IfcSchema::IfcMappedItem>();
 				if (is_identity_transform(mapped_item->MappingTarget())) {
@@ -1339,7 +1339,7 @@ IfcSchema::IfcProduct::list::ptr IfcGeom::Kernel::products_represented_by(const
 
 		// IfcProductRepresentation also lacks the INVERSE relation to IfcProduct
 		// Let's find the IfcProducts that reference the IfcProductRepresentation anyway
-		products->push((*it)->entity->getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>());
+		products->push((*it)->data().getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>());
 	}
 	
 	IfcSchema::IfcRepresentationMap::list::ptr maps = representation->RepresentationMap();
@@ -1355,13 +1355,13 @@ IfcSchema::IfcProduct::list::ptr IfcGeom::Kernel::products_represented_by(const
 					continue;
 				}
 
-				IfcSchema::IfcRepresentation::list::ptr reps = item->entity->getInverse(IfcSchema::Type::IfcRepresentation, -1)->as<IfcSchema::IfcRepresentation>();
+				IfcSchema::IfcRepresentation::list::ptr reps = item->data().getInverse(IfcSchema::Type::IfcRepresentation, -1)->as<IfcSchema::IfcRepresentation>();
 				for (IfcSchema::IfcRepresentation::list::it jt = reps->begin(); jt != reps->end(); ++jt) {
 					IfcSchema::IfcRepresentation* rep = *jt;
 					if (rep->Items()->size() != 1) continue;
 					IfcSchema::IfcProductRepresentation::list::ptr prodreps_mapped = rep->OfProductRepresentation();
 					for (IfcSchema::IfcProductRepresentation::list::it kt = prodreps_mapped->begin(); kt != prodreps_mapped->end(); ++kt) {
-						IfcSchema::IfcProduct::list::ptr ps = (*kt)->entity->getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>();
+						IfcSchema::IfcProduct::list::ptr ps = (*kt)->data().getInverse(IfcSchema::Type::IfcProduct, -1)->as<IfcSchema::IfcProduct>();
 						products->push(ps);
 					}
 				}
@@ -1381,7 +1381,7 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_processed_representati
 	try {
 		IfcSchema::IfcObjectDefinition* parent_object = get_decomposing_entity(product);
 		if (parent_object) {
-			parent_id = parent_object->entity->id();
+			parent_id = parent_object->data().id();
 		}
 	} catch (const std::exception& e) {
 		Logger::Error(e);
@@ -1406,10 +1406,10 @@ IfcGeom::BRepElement<P>* IfcGeom::Kernel::create_brep_for_processed_representati
 		context_string = representation->ContextOfItems()->ContextType();
 	}
 
-	const std::string product_type = IfcSchema::Type::ToString(product->type());
+	const std::string product_type = IfcSchema::Type::ToString(product->declaration().type());
 
 	return new BRepElement<P>(
-		product->entity->id(),
+		product->data().id(),
 		parent_id,
 		name, 
 		product_type,
@@ -1425,14 +1425,14 @@ IfcSchema::IfcObjectDefinition* IfcGeom::Kernel::get_decomposing_entity(IfcSchem
 	IfcSchema::IfcObjectDefinition* parent = 0;
 
 	// In case of an opening element, parent to the RelatingBuildingElement
-	if ( product->is(IfcSchema::Type::IfcOpeningElement ) ) {
+	if ( product->declaration().is(IfcSchema::Type::IfcOpeningElement ) ) {
 		IfcSchema::IfcOpeningElement* opening = (IfcSchema::IfcOpeningElement*)product;
 		IfcSchema::IfcRelVoidsElement::list::ptr voids = opening->VoidsElements();
 		if ( voids->size() ) {
 			IfcSchema::IfcRelVoidsElement* ifc_void = *voids->begin();
 			parent = ifc_void->RelatingBuildingElement();
 		}
-	} else if ( product->is(IfcSchema::Type::IfcElement ) ) {
+	} else if ( product->declaration().is(IfcSchema::Type::IfcElement ) ) {
 		IfcSchema::IfcElement* element = (IfcSchema::IfcElement*)product;
 		IfcSchema::IfcRelFillsElement::list::ptr fills = element->FillsVoids();
 		// In case of a RelatedBuildingElement parent to the opening element
@@ -1455,13 +1455,13 @@ IfcSchema::IfcObjectDefinition* IfcGeom::Kernel::get_decomposing_entity(IfcSchem
 	}
 	// Parent decompositions to the RelatingObject
 	if (!parent) {
-		IfcEntityList::ptr parents = product->entity->getInverse(IfcSchema::Type::IfcRelAggregates, -1);
-		parents->push(product->entity->getInverse(IfcSchema::Type::IfcRelNests, -1));
+		IfcEntityList::ptr parents = product->data().getInverse(IfcSchema::Type::IfcRelAggregates, -1);
+		parents->push(product->data().getInverse(IfcSchema::Type::IfcRelNests, -1));
 		for ( IfcEntityList::it it = parents->begin(); it != parents->end(); ++ it ) {
 			IfcSchema::IfcRelDecomposes* decompose = (IfcSchema::IfcRelDecomposes*)*it;
 			IfcSchema::IfcObjectDefinition* ifc_objectdef;
 #ifdef USE_IFC4
-			if (decompose->is(IfcSchema::Type::IfcRelAggregates)) {
+			if (decompose->declaration().is(IfcSchema::Type::IfcRelAggregates)) {
 				ifc_objectdef = ((IfcSchema::IfcRelAggregates*)decompose)->RelatingObject();
 			} else {
 				continue;
@@ -1481,7 +1481,7 @@ std::map<std::string, IfcSchema::IfcPresentationLayerAssignment*> IfcGeom::Kerne
     using namespace IfcSchema;
     std::map<std::string, IfcPresentationLayerAssignment*> layers;
     if (prod->hasRepresentation()) {
-        IfcEntityList::ptr r = prod->entity->file->traverse(prod->Representation());
+        IfcEntityList::ptr r = IfcParse::traverse(prod->Representation());
         IfcRepresentation::list::ptr representations = r->as<IfcRepresentation>();
         for (IfcRepresentation::list::it it = representations->begin(); it != representations->end(); ++it) {
             IfcPresentationLayerAssignment::list::ptr a = (*it)->LayerAssignments();
@@ -1532,7 +1532,7 @@ std::pair<std::string, double> IfcGeom::Kernel::initializeUnits(IfcSchema::IfcUn
 		} else {
 			for (IfcEntityList::it it = units->begin(); it != units->end(); ++it) {
 				IfcUtil::IfcBaseClass* base = *it;
-				if (base->is(IfcSchema::Type::IfcNamedUnit)) {
+				if (base->declaration().is(IfcSchema::Type::IfcNamedUnit)) {
 					IfcSchema::IfcNamedUnit* named_unit = base->as<IfcSchema::IfcNamedUnit>();
 					if (named_unit->UnitType() == IfcSchema::IfcUnitEnum::IfcUnit_LENGTHUNIT ||
 						named_unit->UnitType() == IfcSchema::IfcUnitEnum::IfcUnit_PLANEANGLEUNIT)
@@ -1540,10 +1540,10 @@ std::pair<std::string, double> IfcGeom::Kernel::initializeUnits(IfcSchema::IfcUn
 						std::string current_unit_name;
 						const double current_unit_magnitude = IfcParse::get_SI_equivalent(named_unit);
 						if (current_unit_magnitude != 0.) {
-							if (named_unit->is(IfcSchema::Type::IfcConversionBasedUnit)) {
+							if (named_unit->declaration().is(IfcSchema::Type::IfcConversionBasedUnit)) {
 								IfcSchema::IfcConversionBasedUnit* u = (IfcSchema::IfcConversionBasedUnit*)base;
 								current_unit_name = u->Name();
-							} else if (named_unit->is(IfcSchema::Type::IfcSIUnit)) {
+							} else if (named_unit->declaration().is(IfcSchema::Type::IfcSIUnit)) {
 								IfcSchema::IfcSIUnit* si_unit = named_unit->as<IfcSchema::IfcSIUnit>();
 								if (si_unit->hasPrefix()) {
 									current_unit_name = IfcSchema::IfcSIPrefix::ToString(si_unit->Prefix()) + unit_name;
@@ -1591,9 +1591,9 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 	IfcSchema::IfcRepresentation* body_representation = find_representation(product, "Body");
 	IfcSchema::IfcRepresentation* axis_representation = find_representation(product, "Axis");
 
-	if (product->is(IfcSchema::Type::IfcWall)) {
+	if (product->declaration().is(IfcSchema::Type::IfcWall)) {
 		if (!axis_representation) {
-			Logger::Message(Logger::LOG_WARNING, "No axis representation for:", product->entity);
+			Logger::Message(Logger::LOG_WARNING, "No axis representation for:", product);
 			return false;
 		}
 
@@ -1615,7 +1615,7 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 			axis_edge = TopoDS::Edge(exp.Current());
 			++ edge_count;
 		} else {
-			Logger::Message(Logger::LOG_WARNING, "No edge found in axis representation:", product->entity);
+			Logger::Message(Logger::LOG_WARNING, "No edge found in axis representation:", product);
 			return false;
 		}
 
@@ -1630,7 +1630,7 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 				Handle_Geom_Circle axis_line = Handle_Geom_Circle::DownCast(axis_curve);
 				reference_surface = new Geom_CylindricalSurface(axis_line->Position(), axis_line->Radius());
 			} else {
-				Logger::Message(Logger::LOG_ERROR, "Unsupported underlying curve of Axis representation:", product->entity);
+				Logger::Message(Logger::LOG_ERROR, "Unsupported underlying curve of Axis representation:", product);
 				return false;
 			}
 		} else {
@@ -1640,10 +1640,10 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 		}
 		
 	} else {
-		IfcSchema::IfcExtrudedAreaSolid::list::ptr extrusions = body_representation->entity->file->traverse(body_representation)->as<IfcSchema::IfcExtrudedAreaSolid>();
+		IfcSchema::IfcExtrudedAreaSolid::list::ptr extrusions = IfcParse::traverse(body_representation)->as<IfcSchema::IfcExtrudedAreaSolid>();
 		
 		if (extrusions->size() != 1) {
-			Logger::Message(Logger::LOG_WARNING, "No single extrusion found in body representation for:", product->entity);
+			Logger::Message(Logger::LOG_WARNING, "No single extrusion found in body representation for:", product);
 			return false;
 		}
 
@@ -1657,14 +1657,14 @@ bool IfcGeom::Kernel::convert_layerset(const IfcSchema::IfcProduct* product, std
 #endif
 		if (has_position) {
 			if (!convert(extrusion->Position(), extrusion_position)) {
-				Logger::Message(Logger::LOG_ERROR, "Failed to convert placement for extrusion of:", product->entity);
+				Logger::Message(Logger::LOG_ERROR, "Failed to convert placement for extrusion of:", product);
 				return false;
 			}
 		}
 
 		gp_Dir extrusion_direction;
 		if (!convert(extrusion->ExtrudedDirection(), extrusion_direction)) {
-			Logger::Message(Logger::LOG_ERROR, "Failed to convert direction for extrusion of:", product->entity);
+			Logger::Message(Logger::LOG_ERROR, "Failed to convert direction for extrusion of:", product);
 			return false;
 		}
 
@@ -2513,7 +2513,7 @@ const IfcSchema::IfcRepresentationItem* IfcGeom::Kernel::find_item_carrying_styl
 		return item;
 	}
 
-	while (item->is(IfcSchema::Type::IfcBooleanClippingResult)) {
+	while (item->declaration().is(IfcSchema::Type::IfcBooleanClippingResult)) {
 		// All instantiations of IfcBooleanOperand (type of FirstOperand) are subtypes of
 		// IfcGeometricRepresentationItem
 		item = (IfcSchema::IfcGeometricRepresentationItem*) ((IfcSchema::IfcBooleanClippingResult*) item)->FirstOperand();

src/ifcgeom/IfcGeomHelpers.cpp

@@ -363,15 +363,15 @@ void IfcGeom::Kernel::set_conversion_placement_rel_to(IfcSchema::Type::Enum type
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& trsf) {
 	IN_CACHE(IfcObjectPlacement,l,gp_Trsf,trsf)
-	if ( ! l->is(IfcSchema::Type::IfcLocalPlacement) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l->entity);
+	if ( ! l->declaration().is(IfcSchema::Type::IfcLocalPlacement) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported IfcObjectPlacement:", l);
 		return false; 		
 	}
 	IfcSchema::IfcLocalPlacement* current = (IfcSchema::IfcLocalPlacement*)l;
 	for (;;) {
 		gp_Trsf trsf2;
 		IfcSchema::IfcAxis2Placement* relplacement = current->RelativePlacement();
-		if ( relplacement->is(IfcSchema::Type::IfcAxis2Placement3D) ) {
+		if ( relplacement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D) ) {
 			IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)relplacement,trsf2);
 			trsf.PreMultiply(trsf2);
 		}
@@ -381,11 +381,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcObjectPlacement* l, gp_Trsf& t
 			bool parentPlacesType = false;
 			for ( IfcSchema::IfcProduct::list::it iter = parentPlaces->begin();
 				  iter != parentPlaces->end(); ++iter) {
-				if ( (*iter)->is(placement_rel_to) ) parentPlacesType = true;
+				if ( (*iter)->declaration().is(placement_rel_to) ) parentPlacesType = true;
 			}
 
 			if ( parentPlacesType ) break;
-			else if ( parent->is(IfcSchema::Type::IfcLocalPlacement) )
+			else if ( parent->declaration().is(IfcSchema::Type::IfcLocalPlacement) )
 				current = (IfcSchema::IfcLocalPlacement*)current->PlacementRelTo();
 			else break;
 		} else break;

src/ifcgeom/IfcGeomIterator.h

@@ -197,7 +197,7 @@ namespace IfcGeom {
 
  			for (it = contexts->begin(); it != contexts->end(); ++it) {
 				IfcSchema::IfcGeometricRepresentationContext* context = *it;
-				if (context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) {
+				if (context->declaration().is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) {
 					// Continue, as the list of subcontexts will be considered
 					// by the parent's context inverse attributes.
 					continue;
@@ -208,7 +208,7 @@ namespace IfcGeom {
 						boost::to_lower(context_type);
 
 						if (allowed_context_types.find(context_type) == allowed_context_types.end()) {
-							Logger::Message(Logger::LOG_ERROR, std::string("ContextType '") + context->ContextType() + "' not allowed:", context->entity);
+							Logger::Message(Logger::LOG_ERROR, std::string("ContextType '") + context->ContextType() + "' not allowed:", context);
 						}
 						if (context_types.find(context_type) != context_types.end()) {
 							filtered_contexts->push(context);
@@ -224,7 +224,7 @@ namespace IfcGeom {
 			if (filtered_contexts->size() == 0) {
 				for (it = contexts->begin(); it != contexts->end(); ++it) {
 					IfcSchema::IfcGeometricRepresentationContext* context = *it;
-					if (!context->is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) {
+					if (!context->declaration().is(IfcSchema::Type::IfcGeometricRepresentationSubContext)) {
 						filtered_contexts->push(context);
 					}
 				}
@@ -374,7 +374,7 @@ namespace IfcGeom {
 					for (IfcSchema::IfcRelAssociates::list::it jt = associations->begin(); jt != associations->end(); ++jt) {
 						IfcSchema::IfcRelAssociatesMaterial* assoc = (*jt)->as<IfcSchema::IfcRelAssociatesMaterial>();
 						if (assoc) {
-							if (assoc->RelatingMaterial()->is(IfcSchema::Type::IfcMaterialLayerSetUsage)) {
+							if (assoc->RelatingMaterial()->declaration().is(IfcSchema::Type::IfcMaterialLayerSetUsage)) {
 								// TODO: Check whether single layer? 
 								return false;
 							}
@@ -578,19 +578,19 @@ namespace IfcGeom {
 				IfcUtil::IfcBaseClass* ifc_entity = ifc_file->entityById(id);
 				instance_type = IfcSchema::Type::ToString(ifc_entity->type());
 
-				if (ifc_entity->is(IfcSchema::Type::IfcRoot)) {
+				if (ifc_entity->declaration().is(IfcSchema::Type::IfcRoot)) {
 					IfcSchema::IfcRoot* ifc_root = ifc_entity->as<IfcSchema::IfcRoot>();
 					product_guid = ifc_root->GlobalId();
 					product_name = ifc_root->hasName() ? ifc_root->Name() : "";
 				}
 
-				if (ifc_entity->is(IfcSchema::Type::IfcProduct)) {
+				if (ifc_entity->declaration().is(IfcSchema::Type::IfcProduct)) {
 					ifc_product = ifc_entity->as<IfcSchema::IfcProduct>();
 					parent_id = -1;
 					try {
 						IfcSchema::IfcObjectDefinition* parent_object = kernel.get_decomposing_entity(ifc_product);
 						if (parent_object) {
-							parent_id = parent_object->entity->id();
+							parent_id = parent_object->data().id();
 						}
 					} catch (const std::exception& e) {
 						Logger::Error(e);

src/ifcgeom/IfcGeomRenderStyles.cpp

@@ -41,9 +41,9 @@ bool process_colour(IfcSchema::IfcNormalisedRatioMeasure* factor, double* rgb) {
 bool process_colour(IfcSchema::IfcColourOrFactor* colour_or_factor, double* rgb) {
 	if (colour_or_factor == 0) {
 		return false;
-	} else if (colour_or_factor->is(IfcSchema::Type::IfcColourRgb)) {
+	} else if (colour_or_factor->declaration().is(IfcSchema::Type::IfcColourRgb)) {
 		return process_colour(static_cast<IfcSchema::IfcColourRgb*>(colour_or_factor), rgb);
-	} else if (colour_or_factor->is(IfcSchema::Type::IfcNormalisedRatioMeasure)) {
+	} else if (colour_or_factor->declaration().is(IfcSchema::Type::IfcNormalisedRatioMeasure)) {
 		return process_colour(static_cast<IfcSchema::IfcNormalisedRatioMeasure*>(colour_or_factor), rgb);
 	} else {
 		return false;
@@ -54,7 +54,7 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::internalize_surface_style(const st
 	if (shading_styles.second == 0) {
 		return 0;
 	}
-	int surface_style_id = shading_styles.first->entity->id();
+	int surface_style_id = shading_styles.first->data().id();
 	std::map<int,SurfaceStyle>::const_iterator it = style_cache.find(surface_style_id);
 	if (it != style_cache.end()) {
 		return &(it->second);
@@ -69,7 +69,7 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::internalize_surface_style(const st
 	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(IfcSchema::Type::IfcSurfaceStyleRendering)) {
+	if (shading_styles.second->declaration().is(IfcSchema::Type::IfcSurfaceStyleRendering)) {
 		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));
@@ -86,12 +86,12 @@ const IfcGeom::SurfaceStyle* IfcGeom::Kernel::internalize_surface_style(const st
 		}
 		if (rendering_style->hasSpecularHighlight()) {
 			IfcSchema::IfcSpecularHighlightSelect* highlight = rendering_style->SpecularHighlight();
-			if (highlight->is(IfcSchema::Type::IfcSpecularRoughness)) {
+			if (highlight->declaration().is(IfcSchema::Type::IfcSpecularRoughness)) {
 				double roughness = *((IfcSchema::IfcSpecularRoughness*)highlight);
 				if (roughness >= 1e-9) {
 					surface_style.Specularity().reset(1.0 / roughness);
 				}
-			} else if (highlight->is(IfcSchema::Type::IfcSpecularExponent)) {
+			} else if (highlight->declaration().is(IfcSchema::Type::IfcSpecularExponent)) {
 				surface_style.Specularity().reset(*((IfcSchema::IfcSpecularExponent*)highlight));
 			}
 		}

src/ifcgeom/IfcGeomRepresentation.h

@@ -160,10 +160,7 @@ namespace IfcGeom {
 					try {
 						BRepMesh_IncrementalMesh(s, settings().deflection_tolerance());
 					} catch(...) {
-
-						// TODO: Catch outside
-						// Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape:",ifc_file->entityById(_id)->entity);
-						Logger::Message(Logger::LOG_ERROR,"Failed to triangulate shape");
+						Logger::Message(Logger::LOG_ERROR, "Failed to triangulate shape");
 						continue;
 					}
 

src/ifcgeom/IfcGeomShapes.cpp

@@ -106,7 +106,7 @@
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_Shape& shape) {
 	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
 	if (height < getValue(GV_PRECISION)) {
-		Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
 		return false;
 	}
 
@@ -166,7 +166,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolid* l, TopoDS_S
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, TopoDS_Shape& shape) {
 	const double height = l->Depth() * getValue(GV_LENGTH_UNIT);
 	if (height < getValue(GV_PRECISION)) {
-		Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Non-positive extrusion height encountered for:", l);
 		return false;
 	}
 
@@ -229,8 +229,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, T
 
 		if (shell.IsNull()) {
 			shell = result;
-		} else if (l->SweptArea()->is(IfcSchema::Type::IfcCircleHollowProfileDef) ||
-			l->SweptArea()->is(IfcSchema::Type::IfcRectangleHollowProfileDef))
+		} else if (l->SweptArea()->declaration().is(IfcSchema::Type::IfcCircleHollowProfileDef) ||
+			l->SweptArea()->declaration().is(IfcSchema::Type::IfcRectangleHollowProfileDef))
 		{
 			/// @todo a bit of of a hack, should be sufficient
 			shell = BRepAlgoAPI_Cut(shell, result).Shape();
@@ -251,7 +251,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcExtrudedAreaSolidTapered* l, T
 	shape = shell;
 
 	if (exp1.More() != exp2.More()) {
-		Logger::Message(Logger::LOG_ERROR, "Inconsistent profiles encountered for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Inconsistent profiles encountered for:", l);
 	}
 
 	if (has_position && !shape.IsNull()) {
@@ -369,11 +369,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcManifoldSolidBrep* l, IfcRepre
 		const SurfaceStyle* indiv_style = get_style(l->Outer());
 
 		IfcSchema::IfcClosedShell::list::ptr voids(new IfcSchema::IfcClosedShell::list);
-		if (l->is(IfcSchema::Type::IfcFacetedBrepWithVoids)) {
+		if (l->declaration().is(IfcSchema::Type::IfcFacetedBrepWithVoids)) {
 			voids = l->as<IfcSchema::IfcFacetedBrepWithVoids>()->Voids();
 		}
 #ifdef USE_IFC4
-		if (l->is(IfcSchema::Type::IfcAdvancedBrepWithVoids)) {
+		if (l->declaration().is(IfcSchema::Type::IfcAdvancedBrepWithVoids)) {
 			voids = l->as<IfcSchema::IfcAdvancedBrepWithVoids>()->Voids();
 		}
 #endif
@@ -410,8 +410,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcFaceBasedSurfaceModel* l, IfcR
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcHalfSpaceSolid* l, TopoDS_Shape& shape) {
 	IfcSchema::IfcSurface* surface = l->BaseSurface();
-	if ( ! surface->is(IfcSchema::Type::IfcPlane) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface->entity);
+	if ( ! surface->declaration().is(IfcSchema::Type::IfcPlane) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BaseSurface:", surface);
 		return false;
 	}
 	gp_Pln pln;
@@ -439,7 +439,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolygonalBoundedHalfSpace* l,
 		remove_duplicate_points_from_loop(points, wire.Closed() != 0, t); // Note: wire always closed, as per if statement above
 		remove_collinear_points_from_loop(points, wire.Closed() != 0, t);
 		if (points.Length() < 3) {
-			Logger::Message(Logger::LOG_ERROR, "Not enough points retained from:", l->PolygonalBoundary()->entity);
+			Logger::Message(Logger::LOG_ERROR, "Not enough points retained from:", l->PolygonalBoundary());
 			return false;
 		}
 		sequence_of_point_to_wire(points, wire, wire.Closed() != 0);
@@ -461,7 +461,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcShellBasedSurfaceModel* l, Ifc
 	for( IfcEntityList::it it = shells->begin(); it != shells->end(); ++ it ) {
 		TopoDS_Shape s;
 		const SurfaceStyle* shell_style = 0;
-		if ((*it)->is(IfcSchema::Type::IfcRepresentationItem)) {
+		if ((*it)->declaration().is(IfcSchema::Type::IfcRepresentationItem)) {
 			shell_style = get_style((IfcSchema::IfcRepresentationItem*)*it);
 		}
 		if (convert_shape(*it,s)) {
@@ -478,7 +478,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 	TopoDS_Wire boundary_wire;
 	IfcSchema::IfcBooleanOperand* operand1 = l->FirstOperand();
 	IfcSchema::IfcBooleanOperand* operand2 = l->SecondOperand();
-	bool is_halfspace = operand2->is(IfcSchema::Type::IfcHalfSpaceSolid);
+	bool is_halfspace = operand2->declaration().is(IfcSchema::Type::IfcHalfSpaceSolid);
 
 	if ( shape_type(operand1) == ST_SHAPELIST ) {
 		if (!(convert_shapes(operand1, items1) && flatten_shape_list(items1, s1, true))) {
@@ -491,13 +491,13 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 		{ TopoDS_Solid temp_solid;
 		s1 = ensure_fit_for_subtraction(s1, temp_solid); }
 	} else {
-		Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand1->entity);
+		Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand1);
 		return false;
 	}
 
 	const double first_operand_volume = shape_volume(s1);
 	if ( first_operand_volume <= ALMOST_ZERO )
-		Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand()->entity);
+		Logger::Message(Logger::LOG_WARNING,"Empty solid for:",l->FirstOperand());
 
 	bool shape2_processed = false;
 	if ( shape_type(operand2) == ST_SHAPELIST ) {
@@ -509,19 +509,19 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 			s2 = ensure_fit_for_subtraction(s2, temp_solid);
 		}
 	} else {
-		Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand2->entity);
+		Logger::Message(Logger::LOG_ERROR, "Invalid representation item for boolean operation", operand2);
 	}
 
 	if (!shape2_processed) {
 		shape = s1;
-		Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l->entity);
+		Logger::Message(Logger::LOG_ERROR,"Failed to convert SecondOperand of:",l);
 		return true;
 	}
 
 	if (!is_halfspace) {
 		const double second_operand_volume = shape_volume(s2);
 		if ( second_operand_volume <= ALMOST_ZERO )
-			Logger::Message(Logger::LOG_WARNING,"Empty solid for:",operand2->entity);
+			Logger::Message(Logger::LOG_WARNING,"Empty solid for:",operand2);
 	}
 
 	const IfcSchema::IfcBooleanOperator::IfcBooleanOperator op = l->Operator();
@@ -556,9 +556,9 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcBooleanResult* l, TopoDS_Shape
 		if (valid_result) {
 			const double volume_after_subtraction = shape_volume(shape);
 			if ( ALMOST_THE_SAME(first_operand_volume,volume_after_subtraction) )
-				Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",l->entity);
+				Logger::Message(Logger::LOG_WARNING,"Subtraction yields unchanged volume:",l);
 		} else {
-			Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",l->entity);
+			Logger::Message(Logger::LOG_ERROR,"Failed to process subtraction:",l);
 			shape = s1;
 		}
 		// NB: After issuing error the first operand is returned!
@@ -592,7 +592,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 		}
 
 		if (!success) {
-			Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", (*it)->entity);
+			Logger::Message(Logger::LOG_WARNING, "Failed to convert face:", (*it));
 			continue;
 		}
 
@@ -605,7 +605,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 					if (face_area(triangle) > getValue(GV_MINIMAL_FACE_AREA)) {
 						face_list.Append(triangle);
 					} else {
-						Logger::Message(Logger::LOG_WARNING, "Invalid face:", (*it)->entity);
+						Logger::Message(Logger::LOG_WARNING, "Invalid face:", (*it));
 					}
 				}
 			}
@@ -613,7 +613,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 			if (face_area(face) > getValue(GV_MINIMAL_FACE_AREA)) {
 				face_list.Append(face);
 			} else {
-				Logger::Message(Logger::LOG_WARNING, "Invalid face:", (*it)->entity);
+				Logger::Message(Logger::LOG_WARNING, "Invalid face:", (*it));
 			}
 		}
 	}
@@ -640,16 +640,16 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcConnectedFaceSet* l, TopoDS_Sh
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentationShapeItems& shapes) {
 	gp_GTrsf gtrsf;
 	IfcSchema::IfcCartesianTransformationOperator* transform = l->MappingTarget();
-	if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
+	if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator3DnonUniform) ) {
 		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3DnonUniform*)transform,gtrsf);
-	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform->entity);
+	} else if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator2DnonUniform) ) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported MappingTarget:", transform);
 		return false;
-	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
+	} else if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator3D) ) {
 		gp_Trsf trsf;
 		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator3D*)transform,trsf);
 		gtrsf = trsf;
-	} else if ( transform->is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
+	} else if ( transform->declaration().is(IfcSchema::Type::IfcCartesianTransformationOperator2D) ) {
 		gp_Trsf2d trsf_2d;
 		IfcGeom::Kernel::convert((IfcSchema::IfcCartesianTransformationOperator2D*)transform,trsf_2d);
 		gtrsf = (gp_Trsf) trsf_2d;
@@ -657,7 +657,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcMappedItem* l, IfcRepresentati
 	IfcSchema::IfcRepresentationMap* map = l->MappingSource();
 	IfcSchema::IfcAxis2Placement* placement = map->MappingOrigin();
 	gp_Trsf trsf;
-	if (placement->is(IfcSchema::Type::IfcAxis2Placement3D)) {
+	if (placement->declaration().is(IfcSchema::Type::IfcAxis2Placement3D)) {
 		IfcGeom::Kernel::convert((IfcSchema::IfcAxis2Placement3D*)placement,trsf);
 	} else {
 		gp_Trsf2d trsf_2d;
@@ -715,11 +715,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcGeometricSet* l, IfcRepresenta
 		if (convert_shape(element, s)) {
 			part_succes = true;
 			const IfcGeom::SurfaceStyle* style = 0;
-			if (element->is(IfcSchema::Type::IfcPoint)) {
+			if (element->declaration().is(IfcSchema::Type::IfcPoint)) {
 				style = get_style((IfcSchema::IfcPoint*) element);
-			} else if (element->is(IfcSchema::Type::IfcCurve)) {
+			} else if (element->declaration().is(IfcSchema::Type::IfcCurve)) {
 				style = get_style((IfcSchema::IfcCurve*) element);
-			} else if (element->is(IfcSchema::Type::IfcSurface)) {
+			} else if (element->declaration().is(IfcSchema::Type::IfcSurface)) {
 				style = get_style((IfcSchema::IfcSurface*) element);
 			}
 			shapes.push_back(IfcRepresentationShapeItem(s, style ? style : parent_style));
@@ -842,8 +842,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCurveBoundedPlane* l, TopoDS_S
 }
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcRectangularTrimmedSurface* l, TopoDS_Shape& face) {
-	if (!l->BasisSurface()->is(IfcSchema::Type::IfcPlane)) {
-		Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface()->entity);
+	if (!l->BasisSurface()->declaration().is(IfcSchema::Type::IfcPlane)) {
+		Logger::Message(Logger::LOG_ERROR, "Unsupported BasisSurface:", l->BasisSurface());
 		return false;
 	}
 	gp_Pln pln;
@@ -861,8 +861,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l,
 	TopoDS_Shape face;
 	TopoDS_Wire wire, section;
 
-	if (!l->ReferenceSurface()->is(IfcSchema::Type::IfcPlane)) {
-		Logger::Message(Logger::LOG_WARNING, "Reference surface not supported", l->ReferenceSurface()->entity);
+	if (!l->ReferenceSurface()->declaration().is(IfcSchema::Type::IfcPlane)) {
+		Logger::Message(Logger::LOG_WARNING, "Reference surface not supported", l->ReferenceSurface());
 		return false;
 	}
 	
@@ -895,7 +895,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSurfaceCurveSweptAreaSolid* l,
 		for (TopExp_Explorer exp(wire, TopAbs_VERTEX); exp.More(); exp.Next()) {
 			if (pln.Distance(BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()))) > ALMOST_ZERO) {
 				directrix_on_plane = false;
-				Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l->entity);
+				Logger::Message(Logger::LOG_WARNING, "The Directrix does not lie on the ReferenceSurface", l);
 				break;
 			}
 		}
@@ -1015,7 +1015,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcSweptDiskSolid* l, TopoDS_Shap
 		}
 
 		if (!is_valid) {
-			Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l->entity);
+			Logger::Message(Logger::LOG_WARNING, "Failed to subtract inner radius void for:", l);
 		}
 	}
 
@@ -1049,7 +1049,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS
 	for (std::vector< std::vector<double> >::const_iterator it = coordinates.begin(); it != coordinates.end(); ++it) {
 		const std::vector<double>& coords = *it;
 		if (coords.size() != 3) {
-			Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l->entity);
+			Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on Coordinates", l);
 			return false;
 		}
 		points.push_back(gp_Pnt(coords[0] * getValue(GV_LENGTH_UNIT),
@@ -1065,7 +1065,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS
 	for(std::vector< std::vector<int> >::const_iterator it = indices.begin(); it != indices.end(); ++ it) {
 		const std::vector<int>& tri = *it;
 		if (tri.size() != 3) {
-			Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l->entity);
+			Logger::Message(Logger::LOG_ERROR, "Invalid dimensions encountered on CoordIndex", l);
 			return false;
 		}
 
@@ -1073,7 +1073,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS
 		const int max_index = *std::max_element(tri.begin(), tri.end());
 
 		if (min_index < 1 || max_index > (int) points.size()) {
-			Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l->entity);
+			Logger::Message(Logger::LOG_ERROR, "Contents of CoordIndex out of bounds", l);
 			return false;
 		}
 
@@ -1129,7 +1129,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTriangulatedFaceSet* l, TopoDS
 				}
 			} catch(...) {}
 		} else {
-			Logger::Message(Logger::LOG_WARNING, "Failed to sew faceset:", l->entity);
+			Logger::Message(Logger::LOG_WARNING, "Failed to sew faceset:", l);
 		}
 	}
 

src/ifcgeom/IfcGeomWires.cpp

@@ -90,7 +90,7 @@
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire& wire) {
 	if ( getValue(GV_PLANEANGLE_UNIT)<0 ) {
-		Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l->entity);
+		Logger::Message(Logger::LOG_WARNING,"Creating a composite curve without unit information:",l);
 
 		// Temporarily pretend we do have unit information
 		setValue(GV_PLANEANGLE_UNIT,1.0);
@@ -177,7 +177,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 		TopoDS_Wire segment;
 		
 		if (!convert_wire(curve, segment)) {
-			Logger::Message(Logger::LOG_ERROR, "Failed to convert curve:", curve->entity);
+			Logger::Message(Logger::LOG_ERROR, "Failed to convert curve:", curve);
 			continue;
 		}
 		
@@ -200,7 +200,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 			if (distance > precision_sq_2) {
 				w.Add(BRepBuilderAPI_MakeEdge(wire_last_vertex, edge_first_vertex));
 
-				Logger::Message(Logger::LOG_ERROR, "Closed gap on:", l->entity);
+				Logger::Message(Logger::LOG_ERROR, "Closed gap on:", l);
 			}
 		}
 
@@ -209,11 +209,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 		if ( w.Error() != BRepBuilderAPI_WireDone ) {
 			if (w.Error() == BRepBuilderAPI_NonManifoldWire) {
 
-				Logger::Message(Logger::LOG_ERROR, "Non-manifold curve segments:", l->entity);
+				Logger::Message(Logger::LOG_ERROR, "Non-manifold curve segments:", l);
 
 			} else if (w.Error() == BRepBuilderAPI_DisconnectedWire) {
 
-				Logger::Message(Logger::LOG_ERROR, "Failed to join curve segments:", l->entity);
+				Logger::Message(Logger::LOG_ERROR, "Failed to join curve segments:", l);
 
 				gp_Pnt p1, p2;
 				int precision = 4;
@@ -243,7 +243,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 						ss << ", distance " << d << " > precision " << std::fixed << getValue(GV_PRECISION) / 10.;
 					}
 					ss << " for:";
-					Logger::Message(Logger::LOG_NOTICE, ss.str(), (*it)->entity);
+					Logger::Message(Logger::LOG_NOTICE, ss.str(), (*it));
 				}
 			}
 			
@@ -260,7 +260,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 	if (distance > precision_sq_2) {
 		w.Add(BRepBuilderAPI_MakeEdge(edge_last_vertex, wire_first_vertex));
 
-		Logger::Message(Logger::LOG_ERROR, "Closed gap on:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Closed gap on:", l);
 	}
 
 	wire = w.Wire();
@@ -270,7 +270,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcCompositeCurve* l, TopoDS_Wire
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire& wire) {
 	IfcSchema::IfcCurve* basis_curve = l->BasisCurve();
-	bool isConic = basis_curve->is(IfcSchema::Type::IfcConic);
+	bool isConic = basis_curve->declaration().is(IfcSchema::Type::IfcConic);
 	double parameterFactor = isConic ? getValue(GV_PLANEANGLE_UNIT) : getValue(GV_LENGTH_UNIT);
 	
 	Handle(Geom_Curve) curve;
@@ -289,10 +289,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire&
 	BRepBuilderAPI_MakeWire w;
 	for ( IfcEntityList::it it = trims1->begin(); it != trims1->end(); it ++ ) {
 		IfcUtil::IfcBaseClass* i = *it;
-		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+		if ( i->declaration().is(IfcSchema::Type::IfcCartesianPoint) ) {
 			IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[sense_agreement] );
 			has_pnts[sense_agreement] = true;
-		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+		} else if ( i->declaration().is(IfcSchema::Type::IfcParameterValue) ) {
 			const double value = *((IfcSchema::IfcParameterValue*)i);
 			flts[sense_agreement] = value * parameterFactor;
 			has_flts[sense_agreement] = true;
@@ -301,10 +301,10 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire&
 
 	for ( IfcEntityList::it it = trims2->begin(); it != trims2->end(); it ++ ) {
 		IfcUtil::IfcBaseClass* i = *it;
-		if ( i->is(IfcSchema::Type::IfcCartesianPoint) ) {
+		if ( i->declaration().is(IfcSchema::Type::IfcCartesianPoint) ) {
 			IfcGeom::Kernel::convert((IfcSchema::IfcCartesianPoint*)i, pnts[1-sense_agreement] );
 			has_pnts[1-sense_agreement] = true;
-		} else if ( i->is(IfcSchema::Type::IfcParameterValue) ) {
+		} else if ( i->declaration().is(IfcSchema::Type::IfcParameterValue) ) {
 			const double value = *((IfcSchema::IfcParameterValue*)i);
 			flts[1-sense_agreement] = value * parameterFactor;
 			has_flts[1-sense_agreement] = true;
@@ -315,7 +315,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire&
 	bool trim_cartesian_failed = !trim_cartesian;
 	if ( trim_cartesian ) {
 		if ( pnts[0].Distance(pnts[1]) < 2 * getValue(GV_PRECISION) ) {
-			Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l->entity);
+			Logger::Message(Logger::LOG_WARNING,"Skipping segment with length below tolerance level:",l);
 			return false;
 		}
 		ShapeFix_ShapeTolerance FTol;
@@ -327,7 +327,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_Wire&
 		if ( ! e.IsDone() ) {
 			BRepBuilderAPI_EdgeError err = e.Error();
 			if ( err == BRepBuilderAPI_PointProjectionFailed ) {
-				Logger::Message(Logger::LOG_WARNING,"Point projection failed for:",l->entity);
+				Logger::Message(Logger::LOG_WARNING,"Point projection failed for:",l);
 				trim_cartesian_failed = true;
 			}
 		} else {
@@ -340,12 +340,12 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcTrimmedCurve* l, TopoDS_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(IfcSchema::Type::IfcLine) ) {
+		if ( basis_curve->declaration().is(IfcSchema::Type::IfcLine) ) {
 			IfcSchema::IfcLine* line = static_cast<IfcSchema::IfcLine*>(basis_curve);
 			const double magnitude = line->Dir()->Magnitude();
 			flts[0] *= magnitude; flts[1] *= magnitude;
 		}
-		if ( basis_curve->is(IfcSchema::Type::IfcEllipse) ) {
+		if ( basis_curve->declaration().is(IfcSchema::Type::IfcEllipse) ) {
 			IfcSchema::IfcEllipse* ellipse = static_cast<IfcSchema::IfcEllipse*>(basis_curve);
 			double x = ellipse->SemiAxis1() * getValue(GV_LENGTH_UNIT);
 			double y = ellipse->SemiAxis2() * getValue(GV_LENGTH_UNIT);
@@ -419,7 +419,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& resu
 	// A loop should consist of at least three vertices
 	int original_count = polygon.Length();
 	if (original_count < 3) {
-		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
 		return false;
 	}
 
@@ -429,11 +429,11 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcPolyLoop* l, TopoDS_Wire& resu
 	int count = polygon.Length();
 	if (original_count - count != 0) {
 		std::stringstream ss; ss << (original_count - count) << " edges removed for:"; 
-		Logger::Message(Logger::LOG_WARNING, ss.str(), l->entity);
+		Logger::Message(Logger::LOG_WARNING, ss.str(), l);
 	}
 
 	if (count < 3) {
-		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l->entity);
+		Logger::Message(Logger::LOG_ERROR, "Not enough edges for:", l);
 		return false;
 	}
 
@@ -454,8 +454,8 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcArbitraryOpenProfileDef* l, To
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeCurve* l, TopoDS_Wire& result) {
 	IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry();
 	IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry();
-	if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) {
-		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity);
+	if (!pnt1->declaration().is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->declaration().is(IfcSchema::Type::IfcCartesianPoint)) {
+		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l);
 		return false;
 	}
 	
@@ -474,7 +474,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeCurve* l, TopoDS_Wire& res
 	// assumed that a topological wire can be crafted from it. After which an
 	// attempt is made to reconstruct it from the individual curves and the vertices
 	// of the IfcEdgeCurve.
-	const bool is_bounded = l->EdgeGeometry()->is(IfcSchema::Type::IfcBoundedCurve);
+	const bool is_bounded = l->EdgeGeometry()->declaration().is(IfcSchema::Type::IfcBoundedCurve);
 
 	if (!is_bounded && convert_curve(l->EdgeGeometry(), crv)) {
 		mw.Add(BRepBuilderAPI_MakeEdge(crv, p1, p2));
@@ -543,15 +543,15 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdgeLoop* l, TopoDS_Wire& resu
 }
 
 bool IfcGeom::Kernel::convert(const IfcSchema::IfcEdge* l, TopoDS_Wire& result) {
-	if (!l->EdgeStart()->is(IfcSchema::Type::IfcVertexPoint) || !l->EdgeEnd()->is(IfcSchema::Type::IfcVertexPoint)) {
-		Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l->entity);
+	if (!l->EdgeStart()->declaration().is(IfcSchema::Type::IfcVertexPoint) || !l->EdgeEnd()->declaration().is(IfcSchema::Type::IfcVertexPoint)) {
+		Logger::Message(Logger::LOG_ERROR, "Only IfcVertexPoints are supported for EdgeStart and -End", l);
 		return false;
 	}
 
 	IfcSchema::IfcPoint* pnt1 = ((IfcSchema::IfcVertexPoint*) l->EdgeStart())->VertexGeometry();
 	IfcSchema::IfcPoint* pnt2 = ((IfcSchema::IfcVertexPoint*) l->EdgeEnd())->VertexGeometry();
-	if (!pnt1->is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->is(IfcSchema::Type::IfcCartesianPoint)) {
-		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l->entity);
+	if (!pnt1->declaration().is(IfcSchema::Type::IfcCartesianPoint) || !pnt2->declaration().is(IfcSchema::Type::IfcCartesianPoint)) {
+		Logger::Message(Logger::LOG_ERROR, "Only IfcCartesianPoints are supported for VertexGeometry", l);
 		return false;
 	}
 	
@@ -629,7 +629,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIndexedPolyCurve* l, TopoDS_Wi
 	IfcEntityList::ptr segments = l->Segments();
 	for (IfcEntityList::it it = segments->begin(); it != segments->end(); ++it) {
 		IfcUtil::IfcBaseClass* segment = *it;
-		if (segment->is(IfcSchema::Type::IfcLineIndex)) {
+		if (segment->declaration().is(IfcSchema::Type::IfcLineIndex)) {
 			IfcSchema::IfcLineIndex* line = (IfcSchema::IfcLineIndex*) segment;
 			std::vector<int> indices = *line;
 			gp_Pnt previous;
@@ -643,7 +643,7 @@ bool IfcGeom::Kernel::convert(const IfcSchema::IfcIndexedPolyCurve* l, TopoDS_Wi
 				}
 				previous = current;
 			}
-		} else if (segment->is(IfcSchema::Type::IfcArcIndex)) {
+		} else if (segment->declaration().is(IfcSchema::Type::IfcArcIndex)) {
 			IfcSchema::IfcArcIndex* arc = (IfcSchema::IfcArcIndex*) segment;
 			std::vector<int> indices = *arc;
 			if (indices.size() != 3) {

src/ifcgeom/IfcRegister.cpp

@@ -34,7 +34,7 @@ bool IfcGeom::Kernel::convert_shapes(const IfcBaseClass* l, IfcRepresentationSha
 	}
 
 #include "IfcRegisterConvertShapes.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }
 
@@ -44,7 +44,7 @@ IfcGeom::ShapeType IfcGeom::Kernel::shape_type(const IfcBaseClass* l) {
 }
 
 bool IfcGeom::Kernel::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
-	const unsigned int id = l->entity->id();
+	const unsigned int id = l->data().id();
 	bool success = false;
 	bool processed = false;
 	bool ignored = false;
@@ -94,7 +94,7 @@ bool IfcGeom::Kernel::convert_shape(const IfcBaseClass* l, TopoDS_Shape& r) {
 		const char* const msg = processed
 			? "Failed to convert:"
 			: "No operation defined for:";
-		Logger::Message(Logger::LOG_ERROR, msg, l->entity);
+		Logger::Message(Logger::LOG_ERROR, msg, l);
 	}
 	return success;
 }
@@ -105,18 +105,18 @@ bool IfcGeom::Kernel::convert_wire(const IfcBaseClass* l, TopoDS_Wire& r) {
 	if (IfcGeom::Kernel::convert_curve(l, curve)) {
 		return IfcGeom::Kernel::convert_curve_to_wire(curve, r);
 	}
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }
 
 bool IfcGeom::Kernel::convert_face(const IfcBaseClass* l, TopoDS_Shape& r) {
 #include "IfcRegisterConvertFace.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }
 
 bool IfcGeom::Kernel::convert_curve(const IfcBaseClass* l, Handle(Geom_Curve)& r) {
 #include "IfcRegisterConvertCurve.h"
-	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l->entity);
+	Logger::Message(Logger::LOG_ERROR,"No operation defined for:",l);
 	return false;
 }

src/ifcgeom/IfcRegisterConvertCurve.h

@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define CURVE(T) \
-	if ( l->is(T::Class()) ) return convert((T*)l,r);
+	if ( l->declaration().is(T::Class()) ) return convert((T*)l,r);
 #include "IfcRegisterDef.h"
 
 #include "IfcRegister.h"

src/ifcgeom/IfcRegisterConvertFace.h

@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define FACE(T) \
-	if ( l->is(T::Class()) ) return convert((T*)l,r);
+	if ( l->declaration().is(T::Class()) ) return convert((T*)l,r);
 #include "IfcRegisterDef.h"
 
 #include "IfcRegister.h"

src/ifcgeom/IfcRegisterConvertShape.h

@@ -1,23 +1,23 @@
 #include "IfcRegisterUndef.h"
 #define SHAPE(T) \
-	if ( !processed && l->is(T::Class()) ) { \
+	if ( !processed && l->declaration().is(T::Class()) ) { \
 		processed = true; \
 		try { \
 			if ( convert((T*)l,r) ) { \
 				success = true; \
 			} \
 		} catch (const std::exception& e) { \
-			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l->entity); \
+			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
 			return false; \
 		} catch (const Standard_Failure& f) { \
 			if (f.GetMessageString() && strlen(f.GetMessageString())) \
-				Logger::Message(Logger::LOG_ERROR, std::string("Error in: ") + f.GetMessageString() + "\nFailed to convert:", l->entity); \
+				Logger::Message(Logger::LOG_ERROR, std::string("Error in: ") + f.GetMessageString() + "\nFailed to convert:", l); \
 			else \
-				Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l->entity); \
+				Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l); \
 			return false; \
 		} \
 		if (!success) { \
-			Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l->entity); \
+			Logger::Message(Logger::LOG_ERROR,"Failed to convert:",l); \
 			return false; \
 		} \
 	}

src/ifcgeom/IfcRegisterConvertShapes.h

@@ -1,15 +1,15 @@
 #include "IfcRegisterUndef.h"
 #define SHAPES(T) \
-	if ( l->is(T::Class()) ) { \
+	if ( l->declaration().is(T::Class()) ) { \
 		try { \
 			return convert((T*)l,r); \
 		} catch (const std::exception& e) { \
-			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l->entity); \
+			Logger::Message(Logger::LOG_ERROR, std::string(e.what()) + "\nFailed to convert:", l); \
 		} catch (const Standard_Failure& f) { \
 			if (f.GetMessageString()) \
-				Logger::Message(Logger::LOG_ERROR, std::string("Error in: ") + f.GetMessageString() + "\nFailed to convert:", l->entity); \
+				Logger::Message(Logger::LOG_ERROR, std::string("Error in: ") + f.GetMessageString() + "\nFailed to convert:", l); \
 			else \
-				Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l->entity); \
+				Logger::Message(Logger::LOG_ERROR, "Failed to convert:", l); \
 		} \
 		return false; \
 	}

src/ifcgeom/IfcRegisterConvertWire.h

@@ -1,6 +1,6 @@
 #include "IfcRegisterUndef.h"
 #define WIRE(T) \
-	if ( l->is(T::Class()) ) return convert((T*)l,r);
+	if ( l->declaration().is(T::Class()) ) return convert((T*)l,r);
 #include "IfcRegisterDef.h"
 
 #include "IfcRegister.h"

src/ifcgeom/IfcRegisterShapeType.h

@@ -1,14 +1,14 @@
 #include "IfcRegisterUndef.h"
 #define SHAPES(T) \
-	if ( l->is(T::Class()) ) return ST_SHAPELIST;
+	if ( l->declaration().is(T::Class()) ) return ST_SHAPELIST;
 #define SHAPE(T) \
-	if ( l->is(T::Class()) ) return ST_SHAPE;
+	if ( l->declaration().is(T::Class()) ) return ST_SHAPE;
 #define WIRE(T) \
-	if ( l->is(T::Class()) ) return ST_WIRE;
+	if ( l->declaration().is(T::Class()) ) return ST_WIRE;
 #define FACE(T) \
-	if ( l->is(T::Class()) ) return ST_FACE;
+	if ( l->declaration().is(T::Class()) ) return ST_FACE;
 #define CURVE(T) \
-	if ( l->is(T::Class()) ) return ST_CURVE;
+	if ( l->declaration().is(T::Class()) ) return ST_CURVE;
 #include "IfcRegisterDef.h"
 
 #include "IfcRegister.h"

src/ifcparse/IfcEntityList.h

@@ -74,7 +74,7 @@ public:
 	typename U::list::ptr as() {
 		typename U::list::ptr r(new typename U::list);
 		const bool all = U::Class() == IfcSchema::Type::UNDEFINED;
-		for (it i = begin(); i != end(); ++i) if (all || (*i)->is(U::Class())) r->push((U*)*i);
+		for (it i = begin(); i != end(); ++i) if (all || (*i)->declaration().is(U::Class())) r->push((U*)*i);
 		return r;
 	}
 	void remove(T* t) {

src/ifcparse/IfcLogger.cpp

@@ -38,7 +38,7 @@ void Logger::SetOutput(std::ostream* l1, std::ostream* l2) {
 	}
 }
 
-void Logger::Message(Logger::Severity type, const std::string& message, IfcUtil::IfcBaseClass* instance) {
+void Logger::Message(Logger::Severity type, const std::string& message, const IfcUtil::IfcBaseClass* instance) {
 	if ( log2 && type >= verbosity ) {
 		(*log2) << "[" << severity_strings[type] << "] ";
 		if ( current_product ) {
@@ -51,7 +51,7 @@ void Logger::Message(Logger::Severity type, const std::string& message, IfcUtil:
 	}
 }
 
-void Logger::Message(Logger::Severity type, const std::exception& exception, IfcUtil::IfcBaseClass* instance) {
+void Logger::Message(Logger::Severity type, const std::exception& exception, const IfcUtil::IfcBaseClass* instance) {
 	Message(type, exception.what(), instance);
 }
 

src/ifcparse/IfcLogger.h

@@ -56,16 +56,16 @@ public:
 	static Severity Verbosity();
 	
 	/// Log a message to the output stream
-	static void Message(Severity type, const std::string& message, IfcUtil::IfcBaseClass* instance = 0);
-	static void Message(Severity type, const std::exception& message, IfcUtil::IfcBaseClass* instance = 0);
+	static void Message(Severity type, const std::string& message, const IfcUtil::IfcBaseClass* instance = 0);
+	static void Message(Severity type, const std::exception& message, const IfcUtil::IfcBaseClass* instance = 0);
 	
-	static void Notice(const std::string& message, IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_NOTICE, message, instance); }
-    static void Warning(const std::string& message, IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_WARNING, message, instance); }
-    static void Error(const std::string& message, IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_ERROR, message, instance); }
+	static void Notice(const std::string& message, const IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_NOTICE, message, instance); }
+    static void Warning(const std::string& message, const IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_WARNING, message, instance); }
+    static void Error(const std::string& message, const IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_ERROR, message, instance); }
 	
-	static void Notice(const std::exception& exception, IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_NOTICE, exception, instance); }
-	static void Warning(const std::exception& exception, IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_WARNING, exception, instance); }
-	static void Error(const std::exception& exception, IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_ERROR, exception, instance); }
+	static void Notice(const std::exception& exception, const IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_NOTICE, exception, instance); }
+	static void Warning(const std::exception& exception, const IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_WARNING, exception, instance); }
+	static void Error(const std::exception& exception, const IfcUtil::IfcBaseClass* instance = 0) { Message(LOG_ERROR, exception, instance); }
 
 	static void Status(const std::string& message, bool new_line=true);