delete src/mesh/assimp-master

15 files changed, 0 insertions, 27964 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCBoolean.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCBoolean.cpp
deleted file mode 100644
index 36912a7..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCBoolean.cpp
+++ /dev/null
@@ -1,765 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCBoolean.cpp
- *  @brief Implements a subset of Ifc boolean operations
- */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "AssetLib/IFC/IFCUtil.h"
-#include "Common/PolyTools.h"
-#include "PostProcessing/ProcessHelper.h"
-
-
-#include <iterator>
-#include <tuple>
-
-namespace Assimp {
-namespace IFC {
-
-// ------------------------------------------------------------------------------------------------
-// Calculates intersection between line segment and plane. To catch corner cases, specify which side you prefer.
-// The function then generates a hit only if the end is beyond a certain margin in that direction, filtering out
-// "very close to plane" ghost hits as long as start and end stay directly on or within the given plane side.
-bool IntersectSegmentPlane(const IfcVector3 &p, const IfcVector3 &n, const IfcVector3 &e0,
-        const IfcVector3 &e1, bool assumeStartOnWhiteSide, IfcVector3 &out) {
-    const IfcVector3 pdelta = e0 - p, seg = e1 - e0;
-    const IfcFloat dotOne = n * seg, dotTwo = -(n * pdelta);
-
-    // if segment ends on plane, do not report a hit. We stay on that side until a following segment starting at this
-    // point leaves the plane through the other side
-    if (std::abs(dotOne + dotTwo) < ai_epsilon)
-        return false;
-
-    // if segment starts on the plane, report a hit only if the end lies on the *other* side
-    if (std::abs(dotTwo) < ai_epsilon) {
-        if ((assumeStartOnWhiteSide && dotOne + dotTwo < ai_epsilon) || (!assumeStartOnWhiteSide && dotOne + dotTwo > -ai_epsilon)) {
-            out = e0;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    // ignore if segment is parallel to plane and far away from it on either side
-    // Warning: if there's a few thousand of such segments which slowly accumulate beyond the epsilon, no hit would be registered
-    if (std::abs(dotOne) < ai_epsilon)
-        return false;
-
-    // t must be in [0..1] if the intersection point is within the given segment
-    const IfcFloat t = dotTwo / dotOne;
-    if (t > 1.0 || t < 0.0)
-        return false;
-
-    out = e0 + t * seg;
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-void FilterPolygon(std::vector<IfcVector3> &resultpoly) {
-    if (resultpoly.size() < 3) {
-        resultpoly.clear();
-        return;
-    }
-
-    IfcVector3 vmin, vmax;
-    ArrayBounds(resultpoly.data(), static_cast<unsigned int>(resultpoly.size()), vmin, vmax);
-
-    // filter our IfcFloat points - those may happen if a point lies
-    // directly on the intersection line or directly on the clipping plane
-    const IfcFloat epsilon = (vmax - vmin).SquareLength() / 1e6f;
-    FuzzyVectorCompare fz(epsilon);
-    std::vector<IfcVector3>::iterator e = std::unique(resultpoly.begin(), resultpoly.end(), fz);
-
-    if (e != resultpoly.end())
-        resultpoly.erase(e, resultpoly.end());
-
-    if (!resultpoly.empty() && fz(resultpoly.front(), resultpoly.back()))
-        resultpoly.pop_back();
-}
-
-// ------------------------------------------------------------------------------------------------
-void WritePolygon(std::vector<IfcVector3> &resultpoly, TempMesh &result) {
-    FilterPolygon(resultpoly);
-
-    if (resultpoly.size() > 2) {
-        result.mVerts.insert(result.mVerts.end(), resultpoly.begin(), resultpoly.end());
-        result.mVertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid *hs, TempMesh &result,
-        const TempMesh &first_operand,
-        ConversionData & /*conv*/) {
-    ai_assert(hs != nullptr);
-
-    const Schema_2x3::IfcPlane *const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
-    if (!plane) {
-        IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
-        return;
-    }
-
-    // extract plane base position vector and normal vector
-    IfcVector3 p, n(0.f, 0.f, 1.f);
-    if (plane->Position->Axis) {
-        ConvertDirection(n, plane->Position->Axis.Get());
-    }
-    ConvertCartesianPoint(p, plane->Position->Location);
-
-    if (!IsTrue(hs->AgreementFlag)) {
-        n *= -1.f;
-    }
-
-    // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3> &in = first_operand.mVerts;
-    std::vector<IfcVector3> &outvert = result.mVerts;
-
-    std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin(),
-                                              end = first_operand.mVertcnt.end(), iit;
-
-    outvert.reserve(in.size());
-    result.mVertcnt.reserve(first_operand.mVertcnt.size());
-
-    unsigned int vidx = 0;
-    for (iit = begin; iit != end; vidx += *iit++) {
-
-        unsigned int newcount = 0;
-        bool isAtWhiteSide = (in[vidx] - p) * n > -ai_epsilon;
-        for (unsigned int i = 0; i < *iit; ++i) {
-            const IfcVector3 &e0 = in[vidx + i], e1 = in[vidx + (i + 1) % *iit];
-
-            // does the next segment intersect the plane?
-            IfcVector3 isectpos;
-            if (IntersectSegmentPlane(p, n, e0, e1, isAtWhiteSide, isectpos)) {
-                if (isAtWhiteSide) {
-                    // e0 is on the right side, so keep it
-                    outvert.push_back(e0);
-                    outvert.push_back(isectpos);
-                    newcount += 2;
-                } else {
-                    // e0 is on the wrong side, so drop it and keep e1 instead
-                    outvert.push_back(isectpos);
-                    ++newcount;
-                }
-                isAtWhiteSide = !isAtWhiteSide;
-            } else {
-                if (isAtWhiteSide) {
-                    outvert.push_back(e0);
-                    ++newcount;
-                }
-            }
-        }
-
-        if (!newcount) {
-            continue;
-        }
-
-        IfcVector3 vmin, vmax;
-        ArrayBounds(&*(outvert.end() - newcount), newcount, vmin, vmax);
-
-        // filter our IfcFloat points - those may happen if a point lies
-        // directly on the intersection line. However, due to IfcFloat
-        // precision a bitwise comparison is not feasible to detect
-        // this case.
-        const IfcFloat epsilon = (vmax - vmin).SquareLength() / 1e6f;
-        FuzzyVectorCompare fz(epsilon);
-
-        std::vector<IfcVector3>::iterator e = std::unique(outvert.end() - newcount, outvert.end(), fz);
-
-        if (e != outvert.end()) {
-            newcount -= static_cast<unsigned int>(std::distance(e, outvert.end()));
-            outvert.erase(e, outvert.end());
-        }
-        if (fz(*(outvert.end() - newcount), outvert.back())) {
-            outvert.pop_back();
-            --newcount;
-        }
-        if (newcount > 2) {
-            result.mVertcnt.push_back(newcount);
-        } else
-            while (newcount-- > 0) {
-                result.mVerts.pop_back();
-            }
-    }
-    IFCImporter::LogVerboseDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Check if e0-e1 intersects a sub-segment of the given boundary line.
-// note: this functions works on 3D vectors, but performs its intersection checks solely in xy.
-// New version takes the supposed inside/outside state as a parameter and treats corner cases as if
-// the line stays on that side. This should make corner cases more stable.
-// Two million assumptions! Boundary should have all z at 0.0, will be treated as closed, should not have
-// segments with length <1e-6, self-intersecting might break the corner case handling... just don't go there, ok?
-bool IntersectsBoundaryProfile(const IfcVector3 &e0, const IfcVector3 &e1, const std::vector<IfcVector3> &boundary,
-        const bool isStartAssumedInside, std::vector<std::pair<size_t, IfcVector3>> &intersect_results,
-        const bool halfOpen = false) {
-    ai_assert(intersect_results.empty());
-
-    // determine winding order - necessary to detect segments going "inwards" or "outwards" from a point directly on the border
-    // positive sum of angles means clockwise order when looking down the -Z axis
-    IfcFloat windingOrder = 0.0;
-    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
-        IfcVector3 b01 = boundary[(i + 1) % bcount] - boundary[i];
-        IfcVector3 b12 = boundary[(i + 2) % bcount] - boundary[(i + 1) % bcount];
-        IfcVector3 b1_side = IfcVector3(b01.y, -b01.x, 0.0); // rotated 90° clockwise in Z plane
-        // Warning: rough estimate only. A concave poly with lots of small segments each featuring a small counter rotation
-        // could fool the accumulation. Correct implementation would be sum( acos( b01 * b2) * sign( b12 * b1_side))
-        windingOrder += (b1_side.x * b12.x + b1_side.y * b12.y);
-    }
-    windingOrder = windingOrder > 0.0 ? 1.0 : -1.0;
-
-    const IfcVector3 e = e1 - e0;
-
-    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
-        // boundary segment i: b0-b1
-        const IfcVector3 &b0 = boundary[i];
-        const IfcVector3 &b1 = boundary[(i + 1) % bcount];
-        IfcVector3 b = b1 - b0;
-
-        // segment-segment intersection
-        // solve b0 + b*s = e0 + e*t for (s,t)
-        const IfcFloat det = (-b.x * e.y + e.x * b.y);
-        if (std::abs(det) < ai_epsilon) {
-            // no solutions (parallel lines)
-            continue;
-        }
-        IfcFloat b_sqlen_inv = 1.0 / b.SquareLength();
-
-        const IfcFloat x = b0.x - e0.x;
-        const IfcFloat y = b0.y - e0.y;
-        const IfcFloat s = (x * e.y - e.x * y) / det; // scale along boundary edge
-        const IfcFloat t = (x * b.y - b.x * y) / det; // scale along given segment
-        const IfcVector3 p = e0 + e * t;
-#ifdef ASSIMP_BUILD_DEBUG
-        const IfcVector3 check = b0 + b * s - p;
-        ai_assert((IfcVector2(check.x, check.y)).SquareLength() < 1e-5);
-#endif
-
-        // also calculate the distance of e0 and e1 to the segment. We need to detect the "starts directly on segment"
-        // and "ends directly at segment" cases
-        bool startsAtSegment, endsAtSegment;
-        {
-            // calculate closest point to each end on the segment, clamp that point to the segment's length, then check
-            // distance to that point. This approach is like testing if e0 is inside a capped cylinder.
-            IfcFloat et0 = (b.x * (e0.x - b0.x) + b.y * (e0.y - b0.y)) * b_sqlen_inv;
-            IfcVector3 closestPosToE0OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et0)) * b;
-            startsAtSegment = (closestPosToE0OnBoundary - IfcVector3(e0.x, e0.y, 0.0)).SquareLength() < 1e-12;
-            IfcFloat et1 = (b.x * (e1.x - b0.x) + b.y * (e1.y - b0.y)) * b_sqlen_inv;
-            IfcVector3 closestPosToE1OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et1)) * b;
-            endsAtSegment = (closestPosToE1OnBoundary - IfcVector3(e1.x, e1.y, 0.0)).SquareLength() < 1e-12;
-        }
-
-        // Line segment ends at boundary -> ignore any hit, it will be handled by possibly following segments
-        if (endsAtSegment && !halfOpen)
-            continue;
-
-        // Line segment starts at boundary -> generate a hit only if following that line would change the INSIDE/OUTSIDE
-        // state. This should catch the case where a connected set of segments has a point directly on the boundary,
-        // one segment not hitting it because it ends there and the next segment not hitting it because it starts there
-        // Should NOT generate a hit if the segment only touches the boundary but turns around and stays inside.
-        if (startsAtSegment) {
-            IfcVector3 inside_dir = IfcVector3(b.y, -b.x, 0.0) * windingOrder;
-            bool isGoingInside = (inside_dir * e) > 0.0;
-            if (isGoingInside == isStartAssumedInside)
-                continue;
-
-            // only insert the point into the list if it is sufficiently far away from the previous intersection point.
-            // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
-            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
-                const IfcVector3 diff = intersect_results.back().second - e0;
-                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
-                    continue;
-            }
-            intersect_results.push_back(std::make_pair(i, e0));
-            continue;
-        }
-
-        // for a valid intersection, s and t should be in range [0,1]. Including a bit of epsilon on s, potential double
-        // hits on two consecutive boundary segments are filtered
-        if (s >= -ai_epsilon * b_sqlen_inv && s <= 1.0 + ai_epsilon * b_sqlen_inv && t >= 0.0 && (t <= 1.0 || halfOpen)) {
-            // only insert the point into the list if it is sufficiently far away from the previous intersection point.
-            // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
-            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
-                const IfcVector3 diff = intersect_results.back().second - p;
-                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
-                    continue;
-            }
-            intersect_results.push_back(std::make_pair(i, p));
-        }
-    }
-
-    return !intersect_results.empty();
-}
-
-// ------------------------------------------------------------------------------------------------
-// note: this functions works on 3D vectors, but performs its intersection checks solely in xy.
-bool PointInPoly(const IfcVector3 &p, const std::vector<IfcVector3> &boundary) {
-    // even-odd algorithm: take a random vector that extends from p to infinite
-    // and counts how many times it intersects edges of the boundary.
-    // because checking for segment intersections is prone to numeric inaccuracies
-    // or double detections (i.e. when hitting multiple adjacent segments at their
-    // shared vertices) we do it thrice with different rays and vote on it.
-
-    // the even-odd algorithm doesn't work for points which lie directly on
-    // the border of the polygon. If any of our attempts produces this result,
-    // we return false immediately.
-
-    std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
-    size_t votes = 0;
-
-    IntersectsBoundaryProfile(p, p + IfcVector3(1.0, 0, 0), boundary, true, intersected_boundary, true);
-    votes += intersected_boundary.size() % 2;
-
-    intersected_boundary.clear();
-    IntersectsBoundaryProfile(p, p + IfcVector3(0, 1.0, 0), boundary, true, intersected_boundary, true);
-    votes += intersected_boundary.size() % 2;
-
-    intersected_boundary.clear();
-    IntersectsBoundaryProfile(p, p + IfcVector3(0.6, -0.6, 0.0), boundary, true, intersected_boundary, true);
-    votes += intersected_boundary.size() % 2;
-
-    return votes > 1;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace *hs, TempMesh &result,
-        const TempMesh &first_operand,
-        ConversionData &conv) {
-    ai_assert(hs != nullptr);
-
-    const Schema_2x3::IfcPlane *const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
-    if (!plane) {
-        IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
-        return;
-    }
-
-    // extract plane base position vector and normal vector
-    IfcVector3 p, n(0.f, 0.f, 1.f);
-    if (plane->Position->Axis) {
-        ConvertDirection(n, plane->Position->Axis.Get());
-    }
-    ConvertCartesianPoint(p, plane->Position->Location);
-
-    if (!IsTrue(hs->AgreementFlag)) {
-        n *= -1.f;
-    }
-
-    n.Normalize();
-
-    // obtain the polygonal bounding volume
-    std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
-    if (!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
-        IFCImporter::LogError("expected valid polyline for boundary of boolean halfspace");
-        return;
-    }
-
-    // determine winding order by calculating the normal.
-    IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(profile->mVerts.data(), profile->mVerts.size());
-
-    IfcMatrix4 proj_inv;
-    ConvertAxisPlacement(proj_inv, hs->Position);
-
-    // and map everything into a plane coordinate space so all intersection
-    // tests can be done in 2D space.
-    IfcMatrix4 proj = proj_inv;
-    proj.Inverse();
-
-    // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3> &in = first_operand.mVerts;
-    std::vector<IfcVector3> &outvert = result.mVerts;
-    std::vector<unsigned int> &outvertcnt = result.mVertcnt;
-
-    outvert.reserve(in.size());
-    outvertcnt.reserve(first_operand.mVertcnt.size());
-
-    unsigned int vidx = 0;
-    std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin();
-    std::vector<unsigned int>::const_iterator end = first_operand.mVertcnt.end();
-    std::vector<unsigned int>::const_iterator iit;
-    for (iit = begin; iit != end; vidx += *iit++) {
-        // Our new approach: we cut the poly along the plane, then we intersect the part on the black side of the plane
-        // against the bounding polygon. All the white parts, and the black part outside the boundary polygon, are kept.
-        std::vector<IfcVector3> whiteside, blackside;
-
-        {
-            const IfcVector3 *srcVertices = &in[vidx];
-            const size_t srcVtxCount = *iit;
-            if (srcVtxCount == 0)
-                continue;
-
-            IfcVector3 polyNormal = TempMesh::ComputePolygonNormal(srcVertices, srcVtxCount, true);
-
-            // if the poly is parallel to the plane, put it completely on the black or white side
-            if (std::abs(polyNormal * n) > 0.9999) {
-                bool isOnWhiteSide = (srcVertices[0] - p) * n > -ai_epsilon;
-                std::vector<IfcVector3> &targetSide = isOnWhiteSide ? whiteside : blackside;
-                targetSide.insert(targetSide.end(), srcVertices, srcVertices + srcVtxCount);
-            } else {
-                // otherwise start building one polygon for each side. Whenever the current line segment intersects the plane
-                // we put a point there as an end of the current segment. Then we switch to the other side, put a point there, too,
-                // as a beginning of the current segment, and simply continue accumulating vertices.
-                bool isCurrentlyOnWhiteSide = ((srcVertices[0]) - p) * n > -ai_epsilon;
-                for (size_t a = 0; a < srcVtxCount; ++a) {
-                    IfcVector3 e0 = srcVertices[a];
-                    IfcVector3 e1 = srcVertices[(a + 1) % srcVtxCount];
-                    IfcVector3 ei;
-
-                    // put starting point to the current mesh
-                    std::vector<IfcVector3> &trgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
-                    trgt.push_back(srcVertices[a]);
-
-                    // if there's an intersection, put an end vertex there, switch to the other side's mesh,
-                    // and add a starting vertex there, too
-                    bool isPlaneHit = IntersectSegmentPlane(p, n, e0, e1, isCurrentlyOnWhiteSide, ei);
-                    if (isPlaneHit) {
-                        if (trgt.empty() || (trgt.back() - ei).SquareLength() > 1e-12)
-                            trgt.push_back(ei);
-                        isCurrentlyOnWhiteSide = !isCurrentlyOnWhiteSide;
-                        std::vector<IfcVector3> &newtrgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
-                        newtrgt.push_back(ei);
-                    }
-                }
-            }
-        }
-
-        // the part on the white side can be written into the target mesh right away
-        WritePolygon(whiteside, result);
-
-        // The black part is the piece we need to get rid of, but only the part of it within the boundary polygon.
-        // So we now need to construct all the polygons that result from BlackSidePoly minus BoundaryPoly.
-        FilterPolygon(blackside);
-
-        // Complicated, II. We run along the polygon. a) When we're inside the boundary, we run on until we hit an
-        // intersection, which means we're leaving it. We then start a new out poly there. b) When we're outside the
-        // boundary, we start collecting vertices until we hit an intersection, then we run along the boundary until we hit
-        // an intersection, then we switch back to the poly and run on on this one again, and so on until we got a closed
-        // loop. Then we continue with the path we left to catch potential additional polys on the other side of the
-        // boundary as described in a)
-        if (!blackside.empty()) {
-            // poly edge index, intersection point, edge index in boundary poly
-            std::vector<std::tuple<size_t, IfcVector3, size_t>> intersections;
-            bool startedInside = PointInPoly(proj * blackside.front(), profile->mVerts);
-            bool isCurrentlyInside = startedInside;
-
-            std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
-
-            for (size_t a = 0; a < blackside.size(); ++a) {
-                const IfcVector3 e0 = proj * blackside[a];
-                const IfcVector3 e1 = proj * blackside[(a + 1) % blackside.size()];
-
-                intersected_boundary.clear();
-                IntersectsBoundaryProfile(e0, e1, profile->mVerts, isCurrentlyInside, intersected_boundary);
-                // sort the hits by distance from e0 to get the correct in/out/in sequence. Manually :-( I miss you, C++11.
-                if (intersected_boundary.size() > 1) {
-                    bool keepSorting = true;
-                    while (keepSorting) {
-                        keepSorting = false;
-                        for (size_t b = 0; b < intersected_boundary.size() - 1; ++b) {
-                            if ((intersected_boundary[b + 1].second - e0).SquareLength() < (intersected_boundary[b].second - e0).SquareLength()) {
-                                keepSorting = true;
-                                std::swap(intersected_boundary[b + 1], intersected_boundary[b]);
-                            }
-                        }
-                    }
-                }
-                // now add them to the list of intersections
-                for (size_t b = 0; b < intersected_boundary.size(); ++b)
-                    intersections.push_back(std::make_tuple(a, proj_inv * intersected_boundary[b].second, intersected_boundary[b].first));
-
-                // and calculate our new inside/outside state
-                if (intersected_boundary.size() & 1)
-                    isCurrentlyInside = !isCurrentlyInside;
-            }
-
-            // we got a list of in-out-combinations of intersections. That should be an even number of intersections, or
-            // we are facing a non-recoverable error.
-            if ((intersections.size() & 1) != 0) {
-                IFCImporter::LogWarn("Odd number of intersections, can't work with that. Omitting half space boundary check.");
-                continue;
-            }
-
-            if (intersections.size() > 1) {
-                // If we started outside, the first intersection is a out->in intersection. Cycle them so that it
-                // starts with an intersection leaving the boundary
-                if (!startedInside)
-                    for (size_t b = 0; b < intersections.size() - 1; ++b)
-                        std::swap(intersections[b], intersections[(b + intersections.size() - 1) % intersections.size()]);
-
-                // Filter pairs of out->in->out that lie too close to each other.
-                for (size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/) {
-                    if ((std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10)
-                        intersections.erase(intersections.begin() + a, intersections.begin() + a + 2);
-                    else
-                        a++;
-                }
-                if (intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10) {
-                    intersections.pop_back();
-                    intersections.erase(intersections.begin());
-                }
-            }
-
-            // no intersections at all: either completely inside the boundary, so everything gets discarded, or completely outside.
-            // in the latter case we're implementional lost. I'm simply going to ignore this, so a large poly will not get any
-            // holes if the boundary is smaller and does not touch it anywhere.
-            if (intersections.empty()) {
-                // starting point was outside -> everything is outside the boundary -> nothing is clipped -> add black side
-                // to result mesh unchanged
-                if (!startedInside) {
-                    outvertcnt.push_back(static_cast<unsigned int>(blackside.size()));
-                    outvert.insert(outvert.end(), blackside.begin(), blackside.end());
-                    continue;
-                } else {
-                    // starting point was inside the boundary -> everything is inside the boundary -> nothing is spared from the
-                    // clipping -> nothing left to add to the result mesh
-                    continue;
-                }
-            }
-
-            // determine the direction in which we're marching along the boundary polygon. If the src poly is faced upwards
-            // and the boundary is also winded this way, we need to march *backwards* on the boundary.
-            const IfcVector3 polyNormal = IfcMatrix3(proj) * TempMesh::ComputePolygonNormal(blackside.data(), blackside.size());
-            bool marchBackwardsOnBoundary = (profileNormal * polyNormal) >= 0.0;
-
-            // Build closed loops from these intersections. Starting from an intersection leaving the boundary we
-            // walk along the polygon to the next intersection (which should be an IS entering the boundary poly).
-            // From there we walk along the boundary until we hit another intersection leaving the boundary,
-            // walk along the poly to the next IS and so on until we're back at the starting point.
-            // We remove every intersection we "used up", so any remaining intersection is the start of a new loop.
-            while (!intersections.empty()) {
-                std::vector<IfcVector3> resultpoly;
-                size_t currentIntersecIdx = 0;
-
-                while (true) {
-                    ai_assert(intersections.size() > currentIntersecIdx + 1);
-                    std::tuple<size_t, IfcVector3, size_t> currintsec = intersections[currentIntersecIdx + 0];
-                    std::tuple<size_t, IfcVector3, size_t> nextintsec = intersections[currentIntersecIdx + 1];
-                    intersections.erase(intersections.begin() + currentIntersecIdx, intersections.begin() + currentIntersecIdx + 2);
-
-                    // we start with an in->out intersection
-                    resultpoly.push_back(std::get<1>(currintsec));
-                    // climb along the polygon to the next intersection, which should be an out->in
-                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0) + std::get<0>(nextintsec) - std::get<0>(currintsec);
-                    for (size_t a = 1; a <= numPolyPoints; ++a)
-                        resultpoly.push_back(blackside[(std::get<0>(currintsec) + a) % blackside.size()]);
-                    // put the out->in intersection
-                    resultpoly.push_back(std::get<1>(nextintsec));
-
-                    // generate segments along the boundary polygon that lie in the poly's plane until we hit another intersection
-                    IfcVector3 startingPoint = proj * std::get<1>(nextintsec);
-                    size_t currentBoundaryEdgeIdx = (std::get<2>(nextintsec) + (marchBackwardsOnBoundary ? 1 : 0)) % profile->mVerts.size();
-                    size_t nextIntsecIdx = SIZE_MAX;
-                    while (nextIntsecIdx == SIZE_MAX) {
-                        IfcFloat t = 1e10;
-
-                        size_t nextBoundaryEdgeIdx = marchBackwardsOnBoundary ? (currentBoundaryEdgeIdx + profile->mVerts.size() - 1) : currentBoundaryEdgeIdx + 1;
-                        nextBoundaryEdgeIdx %= profile->mVerts.size();
-                        // vertices of the current boundary segments
-                        IfcVector3 currBoundaryPoint = profile->mVerts[currentBoundaryEdgeIdx];
-                        IfcVector3 nextBoundaryPoint = profile->mVerts[nextBoundaryEdgeIdx];
-                        // project the two onto the polygon
-                        if (std::abs(polyNormal.z) > 1e-5) {
-                            currBoundaryPoint.z = startingPoint.z + (currBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (currBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
-                            nextBoundaryPoint.z = startingPoint.z + (nextBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (nextBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
-                        }
-
-                        // build a direction that goes along the boundary border but lies in the poly plane
-                        IfcVector3 boundaryPlaneNormal = ((nextBoundaryPoint - currBoundaryPoint) ^ profileNormal).Normalize();
-                        IfcVector3 dirAtPolyPlane = (boundaryPlaneNormal ^ polyNormal).Normalize() * (marchBackwardsOnBoundary ? -1.0 : 1.0);
-                        // if we can project the direction to the plane, we can calculate a maximum marching distance along that dir
-                        // until we finish that boundary segment and continue on the next
-                        if (std::abs(polyNormal.z) > 1e-5) {
-                            t = std::min(t, (nextBoundaryPoint - startingPoint).Length());
-                        }
-
-                        // check if the direction hits the loop start - if yes, we got a poly to output
-                        IfcVector3 dirToThatPoint = proj * resultpoly.front() - startingPoint;
-                        IfcFloat tpt = dirToThatPoint * dirAtPolyPlane;
-                        if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
-                            nextIntsecIdx = intersections.size(); // dirty hack to end marching along the boundary and signal the end of the loop
-                            t = tpt;
-                        }
-
-                        // also check if the direction hits any in->out intersections earlier. If we hit one, we can switch back
-                        // to marching along the poly border from that intersection point
-                        for (size_t a = 0; a < intersections.size(); a += 2) {
-                            dirToThatPoint = proj * std::get<1>(intersections[a]) - startingPoint;
-                            tpt = dirToThatPoint * dirAtPolyPlane;
-                            if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
-                                nextIntsecIdx = a; // switch back to poly and march on from this in->out intersection
-                                t = tpt;
-                            }
-                        }
-
-                        // if we keep marching on the boundary, put the segment end point to the result poly and well... keep marching
-                        if (nextIntsecIdx == SIZE_MAX) {
-                            resultpoly.push_back(proj_inv * nextBoundaryPoint);
-                            currentBoundaryEdgeIdx = nextBoundaryEdgeIdx;
-                            startingPoint = nextBoundaryPoint;
-                        }
-
-                        // quick endless loop check
-                        if (resultpoly.size() > blackside.size() + profile->mVerts.size()) {
-                            IFCImporter::LogError("Encountered endless loop while clipping polygon against poly-bounded half space.");
-                            break;
-                        }
-                    }
-
-                    // we're back on the poly - if this is the intersection we started from, we got a closed loop.
-                    if (nextIntsecIdx >= intersections.size()) {
-                        break;
-                    }
-
-                    // otherwise it's another intersection. Continue marching from there.
-                    currentIntersecIdx = nextIntsecIdx;
-                }
-
-                WritePolygon(resultpoly, result);
-            }
-        }
-    }
-    IFCImporter::LogVerboseDebug("generating CSG geometry by plane clipping with polygonal bounding (IfcBooleanClippingResult)");
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid *as, TempMesh &result,
-        const TempMesh &first_operand,
-        ConversionData &conv) {
-    ai_assert(as != nullptr);
-
-    // This case is handled by reduction to an instance of the quadrify() algorithm.
-    // Obviously, this won't work for arbitrarily complex cases. In fact, the first
-    // operand should be near-planar. Luckily, this is usually the case in Ifc
-    // buildings.
-
-    std::shared_ptr<TempMesh> meshtmp = std::shared_ptr<TempMesh>(new TempMesh());
-    ProcessExtrudedAreaSolid(*as, *meshtmp, conv, false);
-
-    std::vector<TempOpening> openings(1, TempOpening(as, IfcVector3(0, 0, 0), meshtmp, std::shared_ptr<TempMesh>()));
-
-    result = first_operand;
-
-    TempMesh temp;
-
-    std::vector<IfcVector3>::const_iterator vit = first_operand.mVerts.begin();
-    for (unsigned int pcount : first_operand.mVertcnt) {
-        temp.Clear();
-
-        temp.mVerts.insert(temp.mVerts.end(), vit, vit + pcount);
-        temp.mVertcnt.push_back(pcount);
-
-        // The algorithms used to generate mesh geometry sometimes
-        // spit out lines or other degenerates which must be
-        // filtered to avoid running into assertions later on.
-
-        // ComputePolygonNormal returns the Newell normal, so the
-        // length of the normal is the area of the polygon.
-        const IfcVector3 &normal = temp.ComputeLastPolygonNormal(false);
-        if (normal.SquareLength() < static_cast<IfcFloat>(1e-5)) {
-            IFCImporter::LogWarn("skipping degenerate polygon (ProcessBooleanExtrudedAreaSolidDifference)");
-            continue;
-        }
-
-        GenerateOpenings(openings, temp, false, true);
-        result.Append(temp);
-
-        vit += pcount;
-    }
-
-    IFCImporter::LogVerboseDebug("generating CSG geometry by geometric difference to a solid (IfcExtrudedAreaSolid)");
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessBoolean(const Schema_2x3::IfcBooleanResult &boolean, TempMesh &result, ConversionData &conv) {
-    // supported CSG operations:
-    //   DIFFERENCE
-    if (const Schema_2x3::IfcBooleanResult *const clip = boolean.ToPtr<Schema_2x3::IfcBooleanResult>()) {
-        if (clip->Operator != "DIFFERENCE") {
-            IFCImporter::LogWarn("encountered unsupported boolean operator: ", (std::string)clip->Operator);
-            return;
-        }
-
-        // supported cases (1st operand):
-        //  IfcBooleanResult -- call ProcessBoolean recursively
-        //  IfcSweptAreaSolid -- obtain polygonal geometry first
-
-        // supported cases (2nd operand):
-        //  IfcHalfSpaceSolid -- easy, clip against plane
-        //  IfcExtrudedAreaSolid -- reduce to an instance of the quadrify() algorithm
-
-        const Schema_2x3::IfcHalfSpaceSolid *const hs = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcHalfSpaceSolid>(conv.db);
-        const Schema_2x3::IfcExtrudedAreaSolid *const as = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcExtrudedAreaSolid>(conv.db);
-        if (!hs && !as) {
-            IFCImporter::LogError("expected IfcHalfSpaceSolid or IfcExtrudedAreaSolid as second clipping operand");
-            return;
-        }
-
-        TempMesh first_operand;
-        if (const Schema_2x3::IfcBooleanResult *const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
-            ProcessBoolean(*op0, first_operand, conv);
-        } else if (const Schema_2x3::IfcSweptAreaSolid *const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
-            ProcessSweptAreaSolid(*swept, first_operand, conv);
-        } else {
-            IFCImporter::LogError("expected IfcSweptAreaSolid or IfcBooleanResult as first clipping operand");
-            return;
-        }
-
-        if (hs) {
-
-            const Schema_2x3::IfcPolygonalBoundedHalfSpace *const hs_bounded = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcPolygonalBoundedHalfSpace>(conv.db);
-            if (hs_bounded) {
-                ProcessPolygonalBoundedBooleanHalfSpaceDifference(hs_bounded, result, first_operand, conv);
-            } else {
-                ProcessBooleanHalfSpaceDifference(hs, result, first_operand, conv);
-            }
-        } else {
-            ProcessBooleanExtrudedAreaSolidDifference(as, result, first_operand, conv);
-        }
-    } else {
-        IFCImporter::LogWarn("skipping unknown IfcBooleanResult entity, type is ", boolean.GetClassName());
-    }
-}
-
-} // namespace IFC
-} // namespace Assimp
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCCurve.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCCurve.cpp
deleted file mode 100644
index 19732ef..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCCurve.cpp
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCProfile.cpp
- *  @brief Read profile and curves entities from IFC files
- */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "IFCUtil.h"
-
-namespace Assimp {
-namespace IFC {
-namespace {
-
-
-// --------------------------------------------------------------------------------
-// Conic is the base class for Circle and Ellipse
-// --------------------------------------------------------------------------------
-class Conic : public Curve {
-public:
-    // --------------------------------------------------
-    Conic(const Schema_2x3::IfcConic& entity, ConversionData& conv)
-    : Curve(entity,conv) {
-        IfcMatrix4 trafo;
-        ConvertAxisPlacement(trafo,*entity.Position,conv);
-
-        // for convenience, extract the matrix rows
-        location = IfcVector3(trafo.a4,trafo.b4,trafo.c4);
-        p[0] = IfcVector3(trafo.a1,trafo.b1,trafo.c1);
-        p[1] = IfcVector3(trafo.a2,trafo.b2,trafo.c2);
-        p[2] = IfcVector3(trafo.a3,trafo.b3,trafo.c3);
-    }
-
-    // --------------------------------------------------
-    bool IsClosed() const {
-        return true;
-    }
-
-    // --------------------------------------------------
-    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-        ai_assert( InRange( a ) );
-        ai_assert( InRange( b ) );
-
-        a *= conv.angle_scale;
-        b *= conv.angle_scale;
-
-        a = std::fmod(a,static_cast<IfcFloat>( AI_MATH_TWO_PI ));
-        b = std::fmod(b,static_cast<IfcFloat>( AI_MATH_TWO_PI ));
-        const IfcFloat setting = static_cast<IfcFloat>( AI_MATH_PI * conv.settings.conicSamplingAngle / 180.0 );
-        return static_cast<size_t>( std::ceil(std::abs( b-a)) / setting);
-    }
-
-    // --------------------------------------------------
-    ParamRange GetParametricRange() const {
-        return std::make_pair(static_cast<IfcFloat>( 0. ), static_cast<IfcFloat>( AI_MATH_TWO_PI / conv.angle_scale ));
-    }
-
-protected:
-    IfcVector3 location, p[3];
-};
-
-// --------------------------------------------------------------------------------
-// Circle
-// --------------------------------------------------------------------------------
-class Circle : public Conic {
-public:
-    // --------------------------------------------------
-    Circle(const Schema_2x3::IfcCircle& entity, ConversionData& conv)
-        : Conic(entity,conv)
-        , entity(entity)
-    {
-    }
-
-    // --------------------------------------------------
-    IfcVector3 Eval(IfcFloat u) const {
-        u = -conv.angle_scale * u;
-        return location + static_cast<IfcFloat>(entity.Radius)*(static_cast<IfcFloat>(std::cos(u))*p[0] +
-            static_cast<IfcFloat>(std::sin(u))*p[1]);
-    }
-
-private:
-    const Schema_2x3::IfcCircle& entity;
-};
-
-// --------------------------------------------------------------------------------
-// Ellipse
-// --------------------------------------------------------------------------------
-class Ellipse : public Conic {
-public:
-    // --------------------------------------------------
-    Ellipse(const Schema_2x3::IfcEllipse& entity, ConversionData& conv)
-    : Conic(entity,conv)
-    , entity(entity) {
-        // empty
-    }
-
-    // --------------------------------------------------
-    IfcVector3 Eval(IfcFloat u) const {
-        u = -conv.angle_scale * u;
-        return location + static_cast<IfcFloat>(entity.SemiAxis1)*static_cast<IfcFloat>(std::cos(u))*p[0] +
-            static_cast<IfcFloat>(entity.SemiAxis2)*static_cast<IfcFloat>(std::sin(u))*p[1];
-    }
-
-private:
-    const Schema_2x3::IfcEllipse& entity;
-};
-
-// --------------------------------------------------------------------------------
-// Line
-// --------------------------------------------------------------------------------
-class Line : public Curve {
-public:
-    // --------------------------------------------------
-    Line(const Schema_2x3::IfcLine& entity, ConversionData& conv)
-    : Curve(entity,conv) {
-        ConvertCartesianPoint(p,entity.Pnt);
-        ConvertVector(v,entity.Dir);
-    }
-
-    // --------------------------------------------------
-    bool IsClosed() const {
-        return false;
-    }
-
-    // --------------------------------------------------
-    IfcVector3 Eval(IfcFloat u) const {
-        return p + u*v;
-    }
-
-    // --------------------------------------------------
-    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-        ai_assert( InRange( a ) );
-        ai_assert( InRange( b ) );
-        // two points are always sufficient for a line segment
-        return a==b ? 1 : 2;
-    }
-
-
-    // --------------------------------------------------
-    void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
-        ai_assert( InRange( a ) );
-        ai_assert( InRange( b ) );
-
-        if (a == b) {
-            out.mVerts.push_back(Eval(a));
-            return;
-        }
-        out.mVerts.reserve(out.mVerts.size()+2);
-        out.mVerts.push_back(Eval(a));
-        out.mVerts.push_back(Eval(b));
-    }
-
-    // --------------------------------------------------
-    ParamRange GetParametricRange() const {
-        const IfcFloat inf = std::numeric_limits<IfcFloat>::infinity();
-
-        return std::make_pair(-inf,+inf);
-    }
-
-private:
-    IfcVector3 p,v;
-};
-
-// --------------------------------------------------------------------------------
-// CompositeCurve joins multiple smaller, bounded curves
-// --------------------------------------------------------------------------------
-class CompositeCurve : public BoundedCurve {
-    typedef std::pair< std::shared_ptr< BoundedCurve >, bool > CurveEntry;
-
-public:
-    // --------------------------------------------------
-    CompositeCurve(const Schema_2x3::IfcCompositeCurve& entity, ConversionData& conv)
-    : BoundedCurve(entity,conv)
-    , total() {
-        curves.reserve(entity.Segments.size());
-        for(const Schema_2x3::IfcCompositeCurveSegment& curveSegment :entity.Segments) {
-            // according to the specification, this must be a bounded curve
-            std::shared_ptr< Curve > cv(Curve::Convert(curveSegment.ParentCurve,conv));
-            std::shared_ptr< BoundedCurve > bc = std::dynamic_pointer_cast<BoundedCurve>(cv);
-
-            if (!bc) {
-                IFCImporter::LogError("expected segment of composite curve to be a bounded curve");
-                continue;
-            }
-
-            if ( (std::string)curveSegment.Transition != "CONTINUOUS" ) {
-                IFCImporter::LogVerboseDebug("ignoring transition code on composite curve segment, only continuous transitions are supported");
-            }
-
-            curves.push_back( CurveEntry(bc,IsTrue(curveSegment.SameSense)) );
-            total += bc->GetParametricRangeDelta();
-        }
-
-        if (curves.empty()) {
-            throw CurveError("empty composite curve");
-        }
-    }
-
-    // --------------------------------------------------
-    IfcVector3 Eval(IfcFloat u) const {
-        if (curves.empty()) {
-            return IfcVector3();
-        }
-
-        IfcFloat acc = 0;
-        for(const CurveEntry& entry : curves) {
-            const ParamRange& range = entry.first->GetParametricRange();
-            const IfcFloat delta = std::abs(range.second-range.first);
-            if (u < acc+delta) {
-                return entry.first->Eval( entry.second ? (u-acc) + range.first : range.second-(u-acc));
-            }
-
-            acc += delta;
-        }
-        // clamp to end
-        return curves.back().first->Eval(curves.back().first->GetParametricRange().second);
-    }
-
-    // --------------------------------------------------
-    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-        ai_assert( InRange( a ) );
-        ai_assert( InRange( b ) );
-        size_t cnt = 0;
-
-        IfcFloat acc = 0;
-        for(const CurveEntry& entry : curves) {
-            const ParamRange& range = entry.first->GetParametricRange();
-            const IfcFloat delta = std::abs(range.second-range.first);
-            if (a <= acc+delta && b >= acc) {
-                const IfcFloat at =  std::max(static_cast<IfcFloat>( 0. ),a-acc), bt = std::min(delta,b-acc);
-                cnt += entry.first->EstimateSampleCount( entry.second ? at + range.first : range.second - bt, entry.second ? bt + range.first : range.second - at );
-            }
-
-            acc += delta;
-        }
-
-        return cnt;
-    }
-
-    // --------------------------------------------------
-    void SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
-        ai_assert( InRange( a ) );
-        ai_assert( InRange( b ) );
-
-        const size_t cnt = EstimateSampleCount(a,b);
-        out.mVerts.reserve(out.mVerts.size() + cnt);
-
-        for(const CurveEntry& entry : curves) {
-            const size_t curCnt = out.mVerts.size();
-            entry.first->SampleDiscrete(out);
-
-            if (!entry.second && curCnt != out.mVerts.size()) {
-                std::reverse(out.mVerts.begin() + curCnt, out.mVerts.end());
-            }
-        }
-    }
-
-    // --------------------------------------------------
-    ParamRange GetParametricRange() const {
-        return std::make_pair(static_cast<IfcFloat>( 0. ),total);
-    }
-
-private:
-    std::vector< CurveEntry > curves;
-    IfcFloat total;
-};
-
-// --------------------------------------------------------------------------------
-// TrimmedCurve can be used to trim an unbounded curve to a bounded range
-// --------------------------------------------------------------------------------
-class TrimmedCurve : public BoundedCurve {
-public:
-    // --------------------------------------------------
-    TrimmedCurve(const Schema_2x3::IfcTrimmedCurve& entity, ConversionData& conv)
-        : BoundedCurve(entity,conv),
-          base(std::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv)))
-    {
-        typedef std::shared_ptr<const STEP::EXPRESS::DataType> Entry;
-
-        // for some reason, trimmed curves can either specify a parametric value
-        // or a point on the curve, or both. And they can even specify which of the
-        // two representations they prefer, even though an information invariant
-        // claims that they must be identical if both are present.
-        // oh well.
-        bool have_param = false, have_point = false;
-        IfcVector3 point;
-        for(const Entry& sel :entity.Trim1) {
-            if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                range.first = *r;
-                have_param = true;
-                break;
-            }
-            else if (const Schema_2x3::IfcCartesianPoint* const curR = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
-                ConvertCartesianPoint(point, *curR);
-                have_point = true;
-            }
-        }
-        if (!have_param) {
-            if (!have_point || !base->ReverseEval(point,range.first)) {
-                throw CurveError("IfcTrimmedCurve: failed to read first trim parameter, ignoring curve");
-            }
-        }
-        have_param = false, have_point = false;
-        for(const Entry& sel :entity.Trim2) {
-            if (const ::Assimp::STEP::EXPRESS::REAL* const r = sel->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                range.second = *r;
-                have_param = true;
-                break;
-            }
-            else if (const Schema_2x3::IfcCartesianPoint* const curR = sel->ResolveSelectPtr<Schema_2x3::IfcCartesianPoint>(conv.db)) {
-                ConvertCartesianPoint(point, *curR);
-                have_point = true;
-            }
-        }
-        if (!have_param) {
-            if (!have_point || !base->ReverseEval(point,range.second)) {
-                throw CurveError("IfcTrimmedCurve: failed to read second trim parameter, ignoring curve");
-            }
-        }
-
-        agree_sense = IsTrue(entity.SenseAgreement);
-        if( !agree_sense ) {
-            std::swap(range.first,range.second);
-        }
-
-        // "NOTE In case of a closed curve, it may be necessary to increment t1 or t2
-        // by the parametric length for consistency with the sense flag."
-        if (base->IsClosed()) {
-            if( range.first > range.second ) {
-                range.second += base->GetParametricRangeDelta();
-            }
-        }
-
-        maxval = range.second-range.first;
-        ai_assert(maxval >= 0);
-    }
-
-    // --------------------------------------------------
-    IfcVector3 Eval(IfcFloat p) const {
-        ai_assert(InRange(p));
-        return base->Eval( TrimParam(p) );
-    }
-
-    // --------------------------------------------------
-    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-        ai_assert( InRange( a ) );
-        ai_assert( InRange( b ) );
-        return base->EstimateSampleCount(TrimParam(a),TrimParam(b));
-    }
-
-    // --------------------------------------------------
-    void SampleDiscrete(TempMesh& out,IfcFloat a,IfcFloat b) const {
-        ai_assert(InRange(a));
-        ai_assert(InRange(b));
-        return base->SampleDiscrete(out,TrimParam(a),TrimParam(b));
-    }
-
-    // --------------------------------------------------
-    ParamRange GetParametricRange() const {
-        return std::make_pair(static_cast<IfcFloat>( 0. ),maxval);
-    }
-
-private:
-    // --------------------------------------------------
-    IfcFloat TrimParam(IfcFloat f) const {
-        return agree_sense ? f + range.first :  range.second - f;
-    }
-
-private:
-    ParamRange range;
-    IfcFloat maxval;
-    bool agree_sense;
-
-    std::shared_ptr<const Curve> base;
-};
-
-
-// --------------------------------------------------------------------------------
-// PolyLine is a 'curve' defined by linear interpolation over a set of discrete points
-// --------------------------------------------------------------------------------
-class PolyLine : public BoundedCurve {
-public:
-    // --------------------------------------------------
-    PolyLine(const Schema_2x3::IfcPolyline& entity, ConversionData& conv)
-        : BoundedCurve(entity,conv)
-    {
-        points.reserve(entity.Points.size());
-
-        IfcVector3 t;
-        for(const Schema_2x3::IfcCartesianPoint& cp : entity.Points) {
-            ConvertCartesianPoint(t,cp);
-            points.push_back(t);
-        }
-    }
-
-    // --------------------------------------------------
-    IfcVector3 Eval(IfcFloat p) const {
-        ai_assert(InRange(p));
-
-        const size_t b = static_cast<size_t>(std::floor(p));
-        if (b == points.size()-1) {
-            return points.back();
-        }
-
-        const IfcFloat d = p-static_cast<IfcFloat>(b);
-        return points[b+1] * d + points[b] * (static_cast<IfcFloat>( 1. )-d);
-    }
-
-    // --------------------------------------------------
-    size_t EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-        ai_assert(InRange(a));
-        ai_assert(InRange(b));
-        return static_cast<size_t>( std::ceil(b) - std::floor(a) );
-    }
-
-    // --------------------------------------------------
-    ParamRange GetParametricRange() const {
-        return std::make_pair(static_cast<IfcFloat>( 0. ),static_cast<IfcFloat>(points.size()-1));
-    }
-
-private:
-    std::vector<IfcVector3> points;
-};
-
-} // anon
-
-// ------------------------------------------------------------------------------------------------
-Curve* Curve::Convert(const IFC::Schema_2x3::IfcCurve& curve,ConversionData& conv) {
-    if(curve.ToPtr<Schema_2x3::IfcBoundedCurve>()) {
-        if(const Schema_2x3::IfcPolyline* c = curve.ToPtr<Schema_2x3::IfcPolyline>()) {
-            return new PolyLine(*c,conv);
-        }
-        if(const Schema_2x3::IfcTrimmedCurve* c = curve.ToPtr<Schema_2x3::IfcTrimmedCurve>()) {
-            return new TrimmedCurve(*c,conv);
-        }
-        if(const Schema_2x3::IfcCompositeCurve* c = curve.ToPtr<Schema_2x3::IfcCompositeCurve>()) {
-            return new CompositeCurve(*c,conv);
-        }
-    }
-
-    if(curve.ToPtr<Schema_2x3::IfcConic>()) {
-        if(const Schema_2x3::IfcCircle* c = curve.ToPtr<Schema_2x3::IfcCircle>()) {
-            return new Circle(*c,conv);
-        }
-        if(const Schema_2x3::IfcEllipse* c = curve.ToPtr<Schema_2x3::IfcEllipse>()) {
-            return new Ellipse(*c,conv);
-        }
-    }
-
-    if(const Schema_2x3::IfcLine* c = curve.ToPtr<Schema_2x3::IfcLine>()) {
-        return new Line(*c,conv);
-    }
-
-    // XXX OffsetCurve2D, OffsetCurve3D not currently supported
-    return nullptr;
-}
-
-#ifdef ASSIMP_BUILD_DEBUG
-// ------------------------------------------------------------------------------------------------
-bool Curve::InRange(IfcFloat u) const {
-    const ParamRange range = GetParametricRange();
-    if (IsClosed()) {
-        return true;
-    }
-    const IfcFloat epsilon = Math::getEpsilon<float>();
-    return u - range.first > -epsilon && range.second - u > -epsilon;
-}
-#endif
-
-// ------------------------------------------------------------------------------------------------
-IfcFloat Curve::GetParametricRangeDelta() const {
-    const ParamRange& range = GetParametricRange();
-    return std::abs(range.second - range.first);
-}
-
-// ------------------------------------------------------------------------------------------------
-size_t Curve::EstimateSampleCount(IfcFloat a, IfcFloat b) const {
-    (void)(a); (void)(b);
-    ai_assert( InRange( a ) );
-    ai_assert( InRange( b ) );
-
-    // arbitrary default value, deriving classes should supply better suited values
-    return 16;
-}
-
-// ------------------------------------------------------------------------------------------------
-IfcFloat RecursiveSearch(const Curve* cv, const IfcVector3& val, IfcFloat a, IfcFloat b,
-        unsigned int samples, IfcFloat threshold, unsigned int recurse = 0, unsigned int max_recurse = 15) {
-    ai_assert(samples>1);
-
-    const IfcFloat delta = (b-a)/samples, inf = std::numeric_limits<IfcFloat>::infinity();
-    IfcFloat min_point[2] = {a,b}, min_diff[2] = {inf,inf};
-    IfcFloat runner = a;
-
-    for (unsigned int i = 0; i < samples; ++i, runner += delta) {
-        const IfcFloat diff = (cv->Eval(runner)-val).SquareLength();
-        if (diff < min_diff[0]) {
-            min_diff[1] = min_diff[0];
-            min_point[1] = min_point[0];
-
-            min_diff[0] = diff;
-            min_point[0] = runner;
-        }
-        else if (diff < min_diff[1]) {
-            min_diff[1] = diff;
-            min_point[1] = runner;
-        }
-    }
-
-    ai_assert( min_diff[ 0 ] != inf );
-    ai_assert( min_diff[ 1 ] != inf );
-    if ( std::fabs(a-min_point[0]) < threshold || recurse >= max_recurse) {
-        return min_point[0];
-    }
-
-    // fix for closed curves to take their wrap-over into account
-    if (cv->IsClosed() && std::fabs(min_point[0]-min_point[1]) > cv->GetParametricRangeDelta()*0.5  ) {
-        const Curve::ParamRange& range = cv->GetParametricRange();
-        const IfcFloat wrapdiff = (cv->Eval(range.first)-val).SquareLength();
-
-        if (wrapdiff < min_diff[0]) {
-            const IfcFloat t = min_point[0];
-            min_point[0] = min_point[1] > min_point[0] ? range.first : range.second;
-             min_point[1] = t;
-        }
-    }
-
-    return RecursiveSearch(cv,val,min_point[0],min_point[1],samples,threshold,recurse+1,max_recurse);
-}
-
-// ------------------------------------------------------------------------------------------------
-bool Curve::ReverseEval(const IfcVector3& val, IfcFloat& paramOut) const
-{
-    // note: the following algorithm is not guaranteed to find the 'right' parameter value
-    // in all possible cases, but it will always return at least some value so this function
-    // will never fail in the default implementation.
-
-    // XXX derive threshold from curve topology
-    static const IfcFloat threshold = 1e-4f;
-    static const unsigned int samples = 16;
-
-    const ParamRange& range = GetParametricRange();
-    paramOut = RecursiveSearch(this,val,range.first,range.second,samples,threshold);
-
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-void Curve::SampleDiscrete(TempMesh& out,IfcFloat a, IfcFloat b) const {
-    ai_assert( InRange( a ) );
-    ai_assert( InRange( b ) );
-
-    const size_t cnt = std::max(static_cast<size_t>(0),EstimateSampleCount(a,b));
-    out.mVerts.reserve( out.mVerts.size() + cnt + 1);
-
-    IfcFloat p = a, delta = (b-a)/cnt;
-    for(size_t i = 0; i <= cnt; ++i, p += delta) {
-        out.mVerts.push_back(Eval(p));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-bool BoundedCurve::IsClosed() const {
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void BoundedCurve::SampleDiscrete(TempMesh& out) const {
-    const ParamRange& range = GetParametricRange();
-    ai_assert( range.first != std::numeric_limits<IfcFloat>::infinity() );
-    ai_assert( range.second != std::numeric_limits<IfcFloat>::infinity() );
-
-    return SampleDiscrete(out,range.first,range.second);
-}
-
-} // IFC
-} // Assimp
-
-#endif // ASSIMP_BUILD_NO_IFC_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCGeometry.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCGeometry.cpp
deleted file mode 100644
index ef59542..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCGeometry.cpp
+++ /dev/null
@@ -1,932 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCGeometry.cpp
- *  @brief Geometry conversion and synthesis for IFC
- */
-
-
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "IFCUtil.h"
-#include "Common/PolyTools.h"
-#include "PostProcessing/ProcessHelper.h"
-
-#ifdef ASSIMP_USE_HUNTER
-#  include <poly2tri/poly2tri.h>
-#  include <polyclipping/clipper.hpp>
-#else
-#  include "../contrib/poly2tri/poly2tri/poly2tri.h"
-#  include "../contrib/clipper/clipper.hpp"
-#endif
-
-#include <memory>
-#include <iterator>
-
-namespace Assimp {
-namespace IFC {
-
-// ------------------------------------------------------------------------------------------------
-bool ProcessPolyloop(const Schema_2x3::IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/)
-{
-    size_t cnt = 0;
-    for(const Schema_2x3::IfcCartesianPoint& c : loop.Polygon) {
-        IfcVector3 tmp;
-        ConvertCartesianPoint(tmp,c);
-
-        meshout.mVerts.push_back(tmp);
-        ++cnt;
-    }
-
-    meshout.mVertcnt.push_back(static_cast<unsigned int>(cnt));
-
-    // zero- or one- vertex polyloops simply ignored
-    if (meshout.mVertcnt.back() > 1) {
-        return true;
-    }
-
-    if (meshout.mVertcnt.back()==1) {
-        meshout.mVertcnt.pop_back();
-        meshout.mVerts.pop_back();
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t master_bounds = (size_t)-1)
-{
-    // handle all trivial cases
-    if(inmesh.mVertcnt.empty()) {
-        return;
-    }
-    if(inmesh.mVertcnt.size() == 1) {
-        result.Append(inmesh);
-        return;
-    }
-
-    ai_assert(std::count(inmesh.mVertcnt.begin(), inmesh.mVertcnt.end(), 0u) == 0);
-
-    typedef std::vector<unsigned int>::const_iterator face_iter;
-
-    face_iter begin = inmesh.mVertcnt.begin(), end = inmesh.mVertcnt.end(), iit;
-    std::vector<unsigned int>::const_iterator outer_polygon_it = end;
-
-    // major task here: given a list of nested polygon boundaries (one of which
-    // is the outer contour), reduce the triangulation task arising here to
-    // one that can be solved using the "quadrulation" algorithm which we use
-    // for pouring windows out of walls. The algorithm does not handle all
-    // cases but at least it is numerically stable and gives "nice" triangles.
-
-    // first compute normals for all polygons using Newell's algorithm
-    // do not normalize 'normals', we need the original length for computing the polygon area
-    std::vector<IfcVector3> normals;
-    inmesh.ComputePolygonNormals(normals,false);
-
-    // One of the polygons might be a IfcFaceOuterBound (in which case `master_bounds`
-    // is its index). Sadly we can't rely on it, the docs say 'At most one of the bounds
-    // shall be of the type IfcFaceOuterBound'
-    IfcFloat area_outer_polygon = 1e-10f;
-    if (master_bounds != (size_t)-1) {
-        ai_assert(master_bounds < inmesh.mVertcnt.size());
-        outer_polygon_it = begin + master_bounds;
-    }
-    else {
-        for(iit = begin; iit != end; ++iit) {
-            // find the polygon with the largest area and take it as the outer bound.
-            IfcVector3& n = normals[std::distance(begin,iit)];
-            const IfcFloat area = n.SquareLength();
-            if (area > area_outer_polygon) {
-                area_outer_polygon = area;
-                outer_polygon_it = iit;
-            }
-        }
-    }
-	if (outer_polygon_it == end) {
-		return;
-	}
-
-    const size_t outer_polygon_size = *outer_polygon_it;
-    const IfcVector3& master_normal = normals[std::distance(begin, outer_polygon_it)];
-
-    // Generate fake openings to meet the interface for the quadrulate
-    // algorithm. It boils down to generating small boxes given the
-    // inner polygon and the surface normal of the outer contour.
-    // It is important that we use the outer contour's normal because
-    // this is the plane onto which the quadrulate algorithm will
-    // project the entire mesh.
-    std::vector<TempOpening> fake_openings;
-    fake_openings.reserve(inmesh.mVertcnt.size()-1);
-
-    std::vector<IfcVector3>::const_iterator vit = inmesh.mVerts.begin(), outer_vit;
-
-    for(iit = begin; iit != end; vit += *iit++) {
-        if (iit == outer_polygon_it) {
-            outer_vit = vit;
-            continue;
-        }
-
-        // Filter degenerate polygons to keep them from causing trouble later on
-        IfcVector3& n = normals[std::distance(begin,iit)];
-        const IfcFloat area = n.SquareLength();
-        if (area < 1e-5f) {
-            IFCImporter::LogWarn("skipping degenerate polygon (ProcessPolygonBoundaries)");
-            continue;
-        }
-
-        fake_openings.push_back(TempOpening());
-        TempOpening& opening = fake_openings.back();
-
-        opening.extrusionDir = master_normal;
-        opening.solid = nullptr;
-
-        opening.profileMesh = std::make_shared<TempMesh>();
-        opening.profileMesh->mVerts.reserve(*iit);
-        opening.profileMesh->mVertcnt.push_back(*iit);
-
-        std::copy(vit, vit + *iit, std::back_inserter(opening.profileMesh->mVerts));
-    }
-
-    // fill a mesh with ONLY the main polygon
-    TempMesh temp;
-    temp.mVerts.reserve(outer_polygon_size);
-    temp.mVertcnt.push_back(static_cast<unsigned int>(outer_polygon_size));
-    std::copy(outer_vit, outer_vit+outer_polygon_size,
-        std::back_inserter(temp.mVerts));
-
-    GenerateOpenings(fake_openings, temp, false, false);
-    result.Append(temp);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessConnectedFaceSet(const Schema_2x3::IfcConnectedFaceSet& fset, TempMesh& result, ConversionData& conv)
-{
-    for(const Schema_2x3::IfcFace& face : fset.CfsFaces) {
-        // size_t ob = -1, cnt = 0;
-        TempMesh meshout;
-        for(const Schema_2x3::IfcFaceBound& bound : face.Bounds) {
-
-            if(const Schema_2x3::IfcPolyLoop* const polyloop = bound.Bound->ToPtr<Schema_2x3::IfcPolyLoop>()) {
-                if(ProcessPolyloop(*polyloop, meshout,conv)) {
-
-                    // The outer boundary is better determined by checking which
-                    // polygon covers the largest area.
-
-                    //if(bound.ToPtr<IfcFaceOuterBound>()) {
-                    //  ob = cnt;
-                    //}
-                    //++cnt;
-
-                }
-            }
-            else {
-                IFCImporter::LogWarn("skipping unknown IfcFaceBound entity, type is ", bound.Bound->GetClassName());
-                continue;
-            }
-
-            // And this, even though it is sometimes TRUE and sometimes FALSE,
-            // does not really improve results.
-
-            /*if(!IsTrue(bound.Orientation)) {
-                size_t c = 0;
-                for(unsigned int& c : meshout.vertcnt) {
-                    std::reverse(result.verts.begin() + cnt,result.verts.begin() + cnt + c);
-                    cnt += c;
-                }
-            }*/
-        }
-        ProcessPolygonBoundaries(result, meshout);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessRevolvedAreaSolid(const Schema_2x3::IfcRevolvedAreaSolid& solid, TempMesh& result, ConversionData& conv)
-{
-    TempMesh meshout;
-
-    // first read the profile description
-    if(!ProcessProfile(*solid.SweptArea,meshout,conv) || meshout.mVerts.size()<=1) {
-        return;
-    }
-
-    IfcVector3 axis, pos;
-    ConvertAxisPlacement(axis,pos,solid.Axis);
-
-    IfcMatrix4 tb0,tb1;
-    IfcMatrix4::Translation(pos,tb0);
-    IfcMatrix4::Translation(-pos,tb1);
-
-    const std::vector<IfcVector3>& in = meshout.mVerts;
-    const size_t size=in.size();
-
-    bool has_area = solid.SweptArea->ProfileType == "AREA" && size>2;
-    const IfcFloat max_angle = solid.Angle*conv.angle_scale;
-    if(std::fabs(max_angle) < 1e-3) {
-        if(has_area) {
-            result = meshout;
-        }
-        return;
-    }
-
-    const unsigned int cnt_segments = std::max(2u,static_cast<unsigned int>(conv.settings.cylindricalTessellation * std::fabs(max_angle)/AI_MATH_HALF_PI_F));
-    const IfcFloat delta = max_angle/cnt_segments;
-
-    has_area = has_area && std::fabs(max_angle) < AI_MATH_TWO_PI_F*0.99;
-
-    result.mVerts.reserve(size*((cnt_segments+1)*4+(has_area?2:0)));
-    result.mVertcnt.reserve(size*cnt_segments+2);
-
-    IfcMatrix4 rot;
-    rot = tb0 * IfcMatrix4::Rotation(delta,axis,rot) * tb1;
-
-    size_t base = 0;
-    std::vector<IfcVector3>& out = result.mVerts;
-
-    // dummy data to simplify later processing
-    for(size_t i = 0; i < size; ++i) {
-        out.insert(out.end(),4,in[i]);
-    }
-
-    for(unsigned int seg = 0; seg < cnt_segments; ++seg) {
-        for(size_t i = 0; i < size; ++i) {
-            const size_t next = (i+1)%size;
-
-            result.mVertcnt.push_back(4);
-            const IfcVector3 base_0 = out[base+i*4+3],base_1 = out[base+next*4+3];
-
-            out.push_back(base_0);
-            out.push_back(base_1);
-            out.push_back(rot*base_1);
-            out.push_back(rot*base_0);
-        }
-        base += size*4;
-    }
-
-    out.erase(out.begin(),out.begin()+size*4);
-
-    if(has_area) {
-        // leave the triangulation of the profile area to the ear cutting
-        // implementation in aiProcess_Triangulate - for now we just
-        // feed in two huge polygons.
-        base -= size*8;
-        for(size_t i = size; i--; ) {
-            out.push_back(out[base+i*4+3]);
-        }
-        for(size_t i = 0; i < size; ++i ) {
-            out.push_back(out[i*4]);
-        }
-        result.mVertcnt.push_back(static_cast<unsigned int>(size));
-        result.mVertcnt.push_back(static_cast<unsigned int>(size));
-    }
-
-    IfcMatrix4 trafo;
-    ConvertAxisPlacement(trafo, solid.Position);
-
-    result.Transform(trafo);
-    IFCImporter::LogVerboseDebug("generate mesh procedurally by radial extrusion (IfcRevolvedAreaSolid)");
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessSweptDiskSolid(const Schema_2x3::IfcSweptDiskSolid &solid, TempMesh& result, ConversionData& conv)
-{
-    const Curve* const curve = Curve::Convert(*solid.Directrix, conv);
-    if(!curve) {
-        IFCImporter::LogError("failed to convert Directrix curve (IfcSweptDiskSolid)");
-        return;
-    }
-
-    const unsigned int cnt_segments = conv.settings.cylindricalTessellation;
-    const IfcFloat deltaAngle = AI_MATH_TWO_PI/cnt_segments;
-
-	TempMesh temp;
-	curve->SampleDiscrete(temp, solid.StartParam, solid.EndParam);
-	const std::vector<IfcVector3>& curve_points = temp.mVerts;
-
-    const size_t samples = curve_points.size();
-
-    result.mVerts.reserve(cnt_segments * samples * 4);
-    result.mVertcnt.reserve((cnt_segments - 1) * samples);
-
-    std::vector<IfcVector3> points;
-    points.reserve(cnt_segments * samples);
-
-    if(curve_points.empty()) {
-        IFCImporter::LogWarn("curve evaluation yielded no points (IfcSweptDiskSolid)");
-        return;
-    }
-
-    IfcVector3 current = curve_points[0];
-    IfcVector3 previous = current;
-    IfcVector3 next;
-
-    IfcVector3 startvec;
-    startvec.x = 1.0f;
-    startvec.y = 1.0f;
-    startvec.z = 1.0f;
-
-    unsigned int last_dir = 0;
-
-    // generate circles at the sweep positions
-    for(size_t i = 0; i < samples; ++i) {
-
-        if(i != samples - 1) {
-            next = curve_points[i + 1];
-        }
-
-        // get a direction vector reflecting the approximate curvature (i.e. tangent)
-        IfcVector3 d = (current-previous) + (next-previous);
-
-        d.Normalize();
-
-        // figure out an arbitrary point q so that (p-q) * d = 0,
-        // try to maximize ||(p-q)|| * ||(p_last-q_last)||
-        IfcVector3 q;
-        bool take_any = false;
-
-        for (unsigned int j = 0; j < 2; ++j, take_any = true) {
-            if ((last_dir == 0 || take_any) && std::abs(d.x) > ai_epsilon) {
-                q.y = startvec.y;
-                q.z = startvec.z;
-                q.x = -(d.y * q.y + d.z * q.z) / d.x;
-                last_dir = 0;
-                break;
-            } else if ((last_dir == 1 || take_any) && std::abs(d.y) > ai_epsilon) {
-                q.x = startvec.x;
-                q.z = startvec.z;
-                q.y = -(d.x * q.x + d.z * q.z) / d.y;
-                last_dir = 1;
-                break;
-            } else if ((last_dir == 2 && std::abs(d.z) > ai_epsilon) || take_any) {
-                q.y = startvec.y;
-                q.x = startvec.x;
-                q.z = -(d.y * q.y + d.x * q.x) / d.z;
-                last_dir = 2;
-                break;
-            }
-        }
-
-        q *= solid.Radius / q.Length();
-        startvec = q;
-
-        // generate a rotation matrix to rotate q around d
-        IfcMatrix4 rot;
-        IfcMatrix4::Rotation(deltaAngle,d,rot);
-
-        for (unsigned int seg = 0; seg < cnt_segments; ++seg, q *= rot ) {
-            points.push_back(q + current);
-        }
-
-        previous = current;
-        current = next;
-    }
-
-    // make quads
-    for(size_t i = 0; i < samples - 1; ++i) {
-
-        const aiVector3D& this_start = points[ i * cnt_segments ];
-
-        // locate corresponding point on next sample ring
-        unsigned int best_pair_offset = 0;
-        float best_distance_squared = 1e10f;
-        for (unsigned int seg = 0; seg < cnt_segments; ++seg) {
-            const aiVector3D& p = points[ (i+1) * cnt_segments + seg];
-            const float l = (p-this_start).SquareLength();
-
-            if(l < best_distance_squared) {
-                best_pair_offset = seg;
-                best_distance_squared = l;
-            }
-        }
-
-        for (unsigned int seg = 0; seg < cnt_segments; ++seg) {
-
-            result.mVerts.push_back(points[ i * cnt_segments + (seg % cnt_segments)]);
-            result.mVerts.push_back(points[ i * cnt_segments + (seg + 1) % cnt_segments]);
-            result.mVerts.push_back(points[ (i+1) * cnt_segments + ((seg + 1 + best_pair_offset) % cnt_segments)]);
-            result.mVerts.push_back(points[ (i+1) * cnt_segments + ((seg + best_pair_offset) % cnt_segments)]);
-
-            IfcVector3& v1 = *(result.mVerts.end()-1);
-            IfcVector3& v2 = *(result.mVerts.end()-2);
-            IfcVector3& v3 = *(result.mVerts.end()-3);
-            IfcVector3& v4 = *(result.mVerts.end()-4);
-
-            if (((v4-v3) ^ (v4-v1)) * (v4 - curve_points[i]) < 0.0f) {
-                std::swap(v4, v1);
-                std::swap(v3, v2);
-            }
-
-            result.mVertcnt.push_back(4);
-        }
-    }
-
-    IFCImporter::LogVerboseDebug("generate mesh procedurally by sweeping a disk along a curve (IfcSweptDiskSolid)");
-}
-
-// ------------------------------------------------------------------------------------------------
-IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVector3& norOut)
-{
-    const std::vector<IfcVector3>& out = curmesh.mVerts;
-    IfcMatrix3 m;
-
-    ok = true;
-
-    // The input "mesh" must be a single polygon
-    const size_t s = out.size();
-    ai_assert( curmesh.mVertcnt.size() == 1 );
-    ai_assert( curmesh.mVertcnt.back() == s);
-
-    const IfcVector3 any_point = out[s-1];
-    IfcVector3 nor;
-
-    // The input polygon is arbitrarily shaped, therefore we might need some tries
-    // until we find a suitable normal. Note that Newell's algorithm would give
-    // a more robust result, but this variant also gives us a suitable first
-    // axis for the 2D coordinate space on the polygon plane, exploiting the
-    // fact that the input polygon is nearly always a quad.
-    bool done = false;
-    size_t idx( 0 );
-    for (size_t i = 0; !done && i < s-2; done || ++i) {
-        idx = i;
-        for (size_t j = i+1; j < s-1; ++j) {
-            nor = -((out[i]-any_point)^(out[j]-any_point));
-            if(std::fabs(nor.Length()) > 1e-8f) {
-                done = true;
-                break;
-            }
-        }
-    }
-
-    if(!done) {
-        ok = false;
-        return m;
-    }
-
-    nor.Normalize();
-    norOut = nor;
-
-    IfcVector3 r = (out[idx]-any_point);
-    r.Normalize();
-
-    //if(d) {
-    //  *d = -any_point * nor;
-    //}
-
-    // Reconstruct orthonormal basis
-    // XXX use Gram Schmidt for increased robustness
-    IfcVector3 u = r ^ nor;
-    u.Normalize();
-
-    m.a1 = r.x;
-    m.a2 = r.y;
-    m.a3 = r.z;
-
-    m.b1 = u.x;
-    m.b2 = u.y;
-    m.b3 = u.z;
-
-    m.c1 = -nor.x;
-    m.c2 = -nor.y;
-    m.c3 = -nor.z;
-
-    return m;
-}
-
-const auto closeDistance = ai_epsilon;
-
-bool areClose(Schema_2x3::IfcCartesianPoint pt1,Schema_2x3::IfcCartesianPoint pt2) {
-    if(pt1.Coordinates.size() != pt2.Coordinates.size())
-    {
-        IFCImporter::LogWarn("unable to compare differently-dimensioned points");
-        return false;
-    }
-    auto coord1 = pt1.Coordinates.begin();
-    auto coord2 = pt2.Coordinates.begin();
-    // we're just testing each dimension separately rather than doing euclidean distance, as we're
-    // looking for very close coordinates
-    for(; coord1 != pt1.Coordinates.end(); coord1++,coord2++)
-    {
-        if(std::fabs(*coord1 - *coord2) > closeDistance)
-            return false;
-    }
-    return true;
-}
-
-bool areClose(IfcVector3 pt1,IfcVector3 pt2) {
-    return (std::fabs(pt1.x - pt2.x) < closeDistance &&
-        std::fabs(pt1.y - pt2.y) < closeDistance &&
-        std::fabs(pt1.z - pt2.z) < closeDistance);
-}
-// Extrudes the given polygon along the direction, converts it into an opening or applies all openings as necessary.
-void ProcessExtrudedArea(const Schema_2x3::IfcExtrudedAreaSolid& solid, const TempMesh& curve,
-    const IfcVector3& extrusionDir, TempMesh& result, ConversionData &conv, bool collect_openings)
-{
-    // Outline: 'curve' is now a list of vertex points forming the underlying profile, extrude along the given axis,
-    // forming new triangles.
-    const bool has_area = solid.SweptArea->ProfileType == "AREA" && curve.mVerts.size() > 2;
-    if (solid.Depth < ai_epsilon) {
-        if( has_area ) {
-            result.Append(curve);
-        }
-        return;
-    }
-
-    result.mVerts.reserve(curve.mVerts.size()*(has_area ? 4 : 2));
-    result.mVertcnt.reserve(curve.mVerts.size() + 2);
-    std::vector<IfcVector3> in = curve.mVerts;
-
-    // First step: transform all vertices into the target coordinate space
-    IfcMatrix4 trafo;
-    ConvertAxisPlacement(trafo, solid.Position);
-
-    IfcVector3 vmin, vmax;
-    MinMaxChooser<IfcVector3>()(vmin, vmax);
-    for(IfcVector3& v : in) {
-        v *= trafo;
-
-        vmin = std::min(vmin, v);
-        vmax = std::max(vmax, v);
-    }
-
-    vmax -= vmin;
-    const IfcFloat diag = vmax.Length();
-    IfcVector3 dir = IfcMatrix3(trafo) * extrusionDir;
-
-    // reverse profile polygon if it's winded in the wrong direction in relation to the extrusion direction
-    IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(in.data(), in.size());
-    if( profileNormal * dir < 0.0 )
-        std::reverse(in.begin(), in.end());
-
-    std::vector<IfcVector3> nors;
-    const bool openings = !!conv.apply_openings && conv.apply_openings->size();
-
-    // Compute the normal vectors for all opening polygons as a prerequisite
-    // to TryAddOpenings_Poly2Tri()
-    // XXX this belongs into the aforementioned function
-    if( openings ) {
-
-        if( !conv.settings.useCustomTriangulation ) {
-            // it is essential to apply the openings in the correct spatial order. The direction
-            // doesn't matter, but we would screw up if we started with e.g. a door in between
-            // two windows.
-            std::sort(conv.apply_openings->begin(), conv.apply_openings->end(), TempOpening::DistanceSorter(in[0]));
-        }
-
-        nors.reserve(conv.apply_openings->size());
-        for(TempOpening& t : *conv.apply_openings) {
-            TempMesh& bounds = *t.profileMesh.get();
-
-            if( bounds.mVerts.size() <= 2 ) {
-                nors.push_back(IfcVector3());
-                continue;
-            }
-            auto nor = ((bounds.mVerts[2] - bounds.mVerts[0]) ^ (bounds.mVerts[1] - bounds.mVerts[0])).Normalize();
-            auto vI0 = bounds.mVertcnt[0];
-            for(size_t faceI = 0; faceI < bounds.mVertcnt.size(); faceI++)
-            {
-                if(bounds.mVertcnt[faceI] >= 3) {
-                    // do a check that this is at least parallel to the base plane
-                    auto nor2 = ((bounds.mVerts[vI0 + 2] - bounds.mVerts[vI0]) ^ (bounds.mVerts[vI0 + 1] - bounds.mVerts[vI0])).Normalize();
-                    if(!areClose(nor,nor2)) {
-                        std::stringstream msg;
-                        msg << "Face " << faceI << " is not parallel with face 0 - opening on entity " << solid.GetID();
-                        IFCImporter::LogWarn(msg.str().c_str());
-                    }
-                }
-            }
-            nors.push_back(nor);
-        }
-    }
-
-
-    TempMesh temp;
-    TempMesh& curmesh = openings ? temp : result;
-    std::vector<IfcVector3>& out = curmesh.mVerts;
-
-    size_t sides_with_openings = 0;
-    for( size_t i = 0; i < in.size(); ++i ) {
-        const size_t next = (i + 1) % in.size();
-
-        curmesh.mVertcnt.push_back(4);
-
-        out.push_back(in[i]);
-        out.push_back(in[next]);
-        out.push_back(in[next] + dir);
-        out.push_back(in[i] + dir);
-
-        if( openings ) {
-            if( (in[i] - in[next]).Length() > diag * 0.1 && GenerateOpenings(*conv.apply_openings, temp, true, true, dir) ) {
-                ++sides_with_openings;
-            }
-
-            result.Append(temp);
-            temp.Clear();
-        }
-    }
-
-    if(openings) {
-        for(TempOpening& opening : *conv.apply_openings) {
-            if(!opening.wallPoints.empty()) {
-                std::stringstream msg;
-                msg << "failed to generate all window caps on ID " << (int)solid.GetID();
-                IFCImporter::LogError(msg.str().c_str());
-            }
-            opening.wallPoints.clear();
-        }
-    }
-
-    size_t sides_with_v_openings = 0;
-    if(has_area) {
-
-        for(size_t n = 0; n < 2; ++n) {
-            if(n > 0) {
-                for(size_t i = 0; i < in.size(); ++i)
-                    out.push_back(in[i] + dir);
-            }
-            else {
-                for(size_t i = in.size(); i--; )
-                    out.push_back(in[i]);
-            }
-
-            curmesh.mVertcnt.push_back(static_cast<unsigned int>(in.size()));
-            if(openings && in.size() > 2) {
-                if(GenerateOpenings(*conv.apply_openings,temp,true,true,dir)) {
-                    ++sides_with_v_openings;
-                }
-
-                result.Append(temp);
-                temp.Clear();
-            }
-        }
-    }
-
-    if (openings && (sides_with_openings == 1 || sides_with_v_openings == 2)) {
-        std::stringstream msg;
-        msg << "failed to resolve all openings, presumably their topology is not supported by Assimp - ID " << solid.GetID() << " sides_with_openings " << sides_with_openings << " sides_with_v_openings " << sides_with_v_openings;
-        IFCImporter::LogWarn(msg.str().c_str());
-    }
-
-    IFCImporter::LogVerboseDebug("generate mesh procedurally by extrusion (IfcExtrudedAreaSolid)");
-
-    // If this is an opening element, store both the extruded mesh and the 2D profile mesh
-    // it was created from. Return an empty mesh to the caller.
-    if( collect_openings && !result.IsEmpty() ) {
-        ai_assert(conv.collect_openings);
-        std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
-        profile->Swap(result);
-
-        std::shared_ptr<TempMesh> profile2D = std::shared_ptr<TempMesh>(new TempMesh());
-        profile2D->mVerts.insert(profile2D->mVerts.end(), in.begin(), in.end());
-        profile2D->mVertcnt.push_back(static_cast<unsigned int>(in.size()));
-        conv.collect_openings->push_back(TempOpening(&solid, dir, profile, profile2D));
-
-        ai_assert(result.IsEmpty());
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessExtrudedAreaSolid(const Schema_2x3::IfcExtrudedAreaSolid& solid, TempMesh& result,
-    ConversionData& conv, bool collect_openings)
-{
-    TempMesh meshout;
-
-    // First read the profile description.
-    if(!ProcessProfile(*solid.SweptArea,meshout,conv) || meshout.mVerts.size()<=1) {
-        return;
-    }
-
-    IfcVector3 dir;
-    ConvertDirection(dir,solid.ExtrudedDirection);
-    dir *= solid.Depth;
-
-    // Some profiles bring their own holes, for which we need to provide a container. This all is somewhat backwards,
-    // and there's still so many corner cases uncovered - we really need a generic solution to all of this hole carving.
-    std::vector<TempOpening> fisherPriceMyFirstOpenings;
-    std::vector<TempOpening>* oldApplyOpenings = conv.apply_openings;
-    if( const Schema_2x3::IfcArbitraryProfileDefWithVoids* const cprofile = solid.SweptArea->ToPtr<Schema_2x3::IfcArbitraryProfileDefWithVoids>() ) {
-        if( !cprofile->InnerCurves.empty() ) {
-            // read all inner curves and extrude them to form proper openings.
-            std::vector<TempOpening>* oldCollectOpenings = conv.collect_openings;
-            conv.collect_openings = &fisherPriceMyFirstOpenings;
-
-            for (const Schema_2x3::IfcCurve* curve : cprofile->InnerCurves) {
-                TempMesh curveMesh, tempMesh;
-                ProcessCurve(*curve, curveMesh, conv);
-                ProcessExtrudedArea(solid, curveMesh, dir, tempMesh, conv, true);
-            }
-            // and then apply those to the geometry we're about to generate
-            conv.apply_openings = conv.collect_openings;
-            conv.collect_openings = oldCollectOpenings;
-        }
-    }
-
-    ProcessExtrudedArea(solid, meshout, dir, result, conv, collect_openings);
-    conv.apply_openings = oldApplyOpenings;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh& meshout,
-    ConversionData& conv)
-{
-    if(const Schema_2x3::IfcExtrudedAreaSolid* const solid = swept.ToPtr<Schema_2x3::IfcExtrudedAreaSolid>()) {
-        ProcessExtrudedAreaSolid(*solid,meshout,conv, !!conv.collect_openings);
-    }
-    else if(const Schema_2x3::IfcRevolvedAreaSolid* const rev = swept.ToPtr<Schema_2x3::IfcRevolvedAreaSolid>()) {
-        ProcessRevolvedAreaSolid(*rev,meshout,conv);
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcSweptAreaSolid entity, type is ", swept.GetClassName());
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-bool ProcessGeometricItem(const Schema_2x3::IfcRepresentationItem& geo, unsigned int matid, std::set<unsigned int>& mesh_indices,
-    ConversionData& conv)
-{
-    bool fix_orientation = false;
-    std::shared_ptr< TempMesh > meshtmp = std::make_shared<TempMesh>();
-    if(const Schema_2x3::IfcShellBasedSurfaceModel* shellmod = geo.ToPtr<Schema_2x3::IfcShellBasedSurfaceModel>()) {
-        for (const std::shared_ptr<const Schema_2x3::IfcShell> &shell : shellmod->SbsmBoundary) {
-            try {
-                const ::Assimp::STEP::EXPRESS::ENTITY& e = shell->To<::Assimp::STEP::EXPRESS::ENTITY>();
-                const Schema_2x3::IfcConnectedFaceSet& fs = conv.db.MustGetObject(e).To<Schema_2x3::IfcConnectedFaceSet>();
-
-                ProcessConnectedFaceSet(fs,*meshtmp.get(),conv);
-            }
-            catch(std::bad_cast&) {
-                IFCImporter::LogWarn("unexpected type error, IfcShell ought to inherit from IfcConnectedFaceSet");
-            }
-        }
-        fix_orientation = true;
-    }
-    else  if(const Schema_2x3::IfcConnectedFaceSet* fset = geo.ToPtr<Schema_2x3::IfcConnectedFaceSet>()) {
-        ProcessConnectedFaceSet(*fset,*meshtmp.get(),conv);
-        fix_orientation = true;
-    }
-    else  if(const Schema_2x3::IfcSweptAreaSolid* swept = geo.ToPtr<Schema_2x3::IfcSweptAreaSolid>()) {
-        ProcessSweptAreaSolid(*swept,*meshtmp.get(),conv);
-    }
-    else  if(const Schema_2x3::IfcSweptDiskSolid* disk = geo.ToPtr<Schema_2x3::IfcSweptDiskSolid>()) {
-        ProcessSweptDiskSolid(*disk,*meshtmp.get(),conv);
-    }
-    else if(const Schema_2x3::IfcManifoldSolidBrep* brep = geo.ToPtr<Schema_2x3::IfcManifoldSolidBrep>()) {
-        ProcessConnectedFaceSet(brep->Outer,*meshtmp.get(),conv);
-        fix_orientation = true;
-    }
-    else if(const Schema_2x3::IfcFaceBasedSurfaceModel* surf = geo.ToPtr<Schema_2x3::IfcFaceBasedSurfaceModel>()) {
-        for(const Schema_2x3::IfcConnectedFaceSet& fc : surf->FbsmFaces) {
-            ProcessConnectedFaceSet(fc,*meshtmp.get(),conv);
-        }
-        fix_orientation = true;
-    }
-    else  if(const Schema_2x3::IfcBooleanResult* boolean = geo.ToPtr<Schema_2x3::IfcBooleanResult>()) {
-        ProcessBoolean(*boolean,*meshtmp.get(),conv);
-    }
-    else if(geo.ToPtr<Schema_2x3::IfcBoundingBox>()) {
-        // silently skip over bounding boxes
-        return false;
-    }
-    else {
-        std::stringstream toLog;
-        toLog << "skipping unknown IfcGeometricRepresentationItem entity, type is " << geo.GetClassName() << " id is " << geo.GetID();
-        IFCImporter::LogWarn(toLog.str().c_str());
-        return false;
-    }
-
-    // Do we just collect openings for a parent element (i.e. a wall)?
-    // In such a case, we generate the polygonal mesh as usual,
-    // but attach it to a TempOpening instance which will later be applied
-    // to the wall it pertains to.
-
-    // Note: swep area solids are added in ProcessExtrudedAreaSolid(),
-    // which returns an empty mesh.
-    if(conv.collect_openings) {
-        if (!meshtmp->IsEmpty()) {
-            conv.collect_openings->push_back(TempOpening(geo.ToPtr<Schema_2x3::IfcSolidModel>(),
-                IfcVector3(0,0,0),
-                meshtmp,
-                std::shared_ptr<TempMesh>()));
-        }
-        return true;
-    }
-
-    if (meshtmp->IsEmpty()) {
-        return false;
-    }
-
-    meshtmp->RemoveAdjacentDuplicates();
-    meshtmp->RemoveDegenerates();
-
-    if(fix_orientation) {
-//      meshtmp->FixupFaceOrientation();
-    }
-
-    aiMesh* const mesh = meshtmp->ToMesh();
-    if(mesh) {
-        mesh->mMaterialIndex = matid;
-        mesh_indices.insert(static_cast<unsigned int>(conv.meshes.size()));
-        conv.meshes.push_back(mesh);
-        return true;
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void AssignAddedMeshes(std::set<unsigned int>& mesh_indices,aiNode* nd,
-    ConversionData& /*conv*/)
-{
-    if (!mesh_indices.empty()) {
-		std::set<unsigned int>::const_iterator it = mesh_indices.cbegin();
-		std::set<unsigned int>::const_iterator end = mesh_indices.cend();
-
-        nd->mNumMeshes = static_cast<unsigned int>(mesh_indices.size());
-
-        nd->mMeshes = new unsigned int[nd->mNumMeshes];
-        for(unsigned int i = 0; it != end && i < nd->mNumMeshes; ++i, ++it) {
-            nd->mMeshes[i] = *it;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-bool TryQueryMeshCache(const Schema_2x3::IfcRepresentationItem& item,
-    std::set<unsigned int>& mesh_indices, unsigned int mat_index,
-    ConversionData& conv)
-{
-    ConversionData::MeshCacheIndex idx(&item, mat_index);
-    ConversionData::MeshCache::const_iterator it = conv.cached_meshes.find(idx);
-    if (it != conv.cached_meshes.end()) {
-        std::copy((*it).second.begin(),(*it).second.end(),std::inserter(mesh_indices, mesh_indices.end()));
-        return true;
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void PopulateMeshCache(const Schema_2x3::IfcRepresentationItem& item,
-    const std::set<unsigned int>& mesh_indices, unsigned int mat_index,
-    ConversionData& conv)
-{
-    ConversionData::MeshCacheIndex idx(&item, mat_index);
-    conv.cached_meshes[idx] = mesh_indices;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool ProcessRepresentationItem(const Schema_2x3::IfcRepresentationItem& item, unsigned int matid,
-    std::set<unsigned int>& mesh_indices,
-    ConversionData& conv)
-{
-    // determine material
-    unsigned int localmatid = ProcessMaterials(item.GetID(), matid, conv, true);
-
-    if (!TryQueryMeshCache(item,mesh_indices,localmatid,conv)) {
-        if(ProcessGeometricItem(item,localmatid,mesh_indices,conv)) {
-            if(mesh_indices.size()) {
-                PopulateMeshCache(item,mesh_indices,localmatid,conv);
-            }
-        }
-        else return false;
-    }
-    return true;
-}
-
-
-} // ! IFC
-} // ! Assimp
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.cpp
deleted file mode 100644
index 0c20686..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.cpp
+++ /dev/null
@@ -1,931 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCLoad.cpp
- *  @brief Implementation of the Industry Foundation Classes loader.
- */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include <iterator>
-#include <limits>
-#include <tuple>
-
-#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-#ifdef ASSIMP_USE_HUNTER
-#include <minizip/unzip.h>
-#else
-#include <unzip.h>
-#endif
-#endif
-
-#include "../STEPParser/STEPFileReader.h"
-#include "IFCLoader.h"
-
-#include "IFCUtil.h"
-
-#include <assimp/MemoryIOWrapper.h>
-#include <assimp/importerdesc.h>
-#include <assimp/scene.h>
-#include <assimp/Importer.hpp>
-
-namespace Assimp {
-template <>
-const char *LogFunctions<IFCImporter>::Prefix() {
-    static auto prefix = "IFC: ";
-    return prefix;
-}
-} // namespace Assimp
-
-using namespace Assimp;
-using namespace Assimp::Formatter;
-using namespace Assimp::IFC;
-
-/* DO NOT REMOVE this comment block. The genentitylist.sh script
- * just looks for names adhering to the IfcSomething naming scheme
- * and includes all matches in the whitelist for code-generation. Thus,
- * all entity classes that are only indirectly referenced need to be
- * mentioned explicitly.
-
-  IfcRepresentationMap
-  IfcProductRepresentation
-  IfcUnitAssignment
-  IfcClosedShell
-  IfcDoor
-
- */
-
-namespace {
-
-// forward declarations
-void SetUnits(ConversionData &conv);
-void SetCoordinateSpace(ConversionData &conv);
-void ProcessSpatialStructures(ConversionData &conv);
-void MakeTreeRelative(ConversionData &conv);
-void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &conv);
-
-} // namespace
-
-static const aiImporterDesc desc = {
-    "Industry Foundation Classes (IFC) Importer",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "ifc ifczip step stp"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-IFCImporter::IFCImporter() {}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-IFCImporter::~IFCImporter() {
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool IFCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    // note: this is the common identification for STEP-encoded files, so
-    // it is only unambiguous as long as we don't support any further
-    // file formats with STEP as their encoding.
-    static const char *tokens[] = { "ISO-10303-21" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
-}
-
-// ------------------------------------------------------------------------------------------------
-// List all extensions handled by this loader
-const aiImporterDesc *IFCImporter::GetInfo() const {
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties for the loader
-void IFCImporter::SetupProperties(const Importer *pImp) {
-    settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS, true);
-    settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION, true);
-    settings.conicSamplingAngle = std::min(std::max((float)pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f);
-    settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180);
-    settings.skipAnnotations = true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void IFCImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
-    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
-    if (!stream) {
-        ThrowException("Could not open file for reading");
-    }
-
-    // if this is a ifczip file, decompress its contents first
-    if (GetExtension(pFile) == "ifczip") {
-#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
-        unzFile zip = unzOpen(pFile.c_str());
-        if (zip == nullptr) {
-            ThrowException("Could not open ifczip file for reading, unzip failed");
-        }
-
-        // chop 'zip' postfix
-        std::string fileName = pFile.substr(0, pFile.length() - 3);
-
-        std::string::size_type s = pFile.find_last_of('\\');
-        if (s == std::string::npos) {
-            s = pFile.find_last_of('/');
-        }
-        if (s != std::string::npos) {
-            fileName = fileName.substr(s + 1);
-        }
-
-        // search file (same name as the IFCZIP except for the file extension) and place file pointer there
-        if (UNZ_OK == unzGoToFirstFile(zip)) {
-            do {
-                // get file size, etc.
-                unz_file_info fileInfo;
-                char filename[256];
-                unzGetCurrentFileInfo(zip, &fileInfo, filename, sizeof(filename), 0, 0, 0, 0);
-                if (GetExtension(filename) != "ifc") {
-                    continue;
-                }
-                uint8_t *buff = new uint8_t[fileInfo.uncompressed_size];
-                LogInfo("Decompressing IFCZIP file");
-                unzOpenCurrentFile(zip);
-                size_t total = 0;
-                int read = 0;
-                do {
-                    int bufferSize = fileInfo.uncompressed_size < INT16_MAX ? fileInfo.uncompressed_size : INT16_MAX;
-                    void *buffer = malloc(bufferSize);
-                    read = unzReadCurrentFile(zip, buffer, bufferSize);
-                    if (read > 0) {
-                        memcpy((char *)buff + total, buffer, read);
-                        total += read;
-                    }
-                    free(buffer);
-                } while (read > 0);
-                size_t filesize = fileInfo.uncompressed_size;
-                if (total == 0 || size_t(total) != filesize) {
-                    delete[] buff;
-                    ThrowException("Failed to decompress IFC ZIP file");
-                }
-                unzCloseCurrentFile(zip);
-                stream.reset(new MemoryIOStream(buff, fileInfo.uncompressed_size, true));
-                if (unzGoToNextFile(zip) == UNZ_END_OF_LIST_OF_FILE) {
-                    ThrowException("Found no IFC file member in IFCZIP file (1)");
-                }
-                break;
-
-            } while (true);
-        } else {
-            ThrowException("Found no IFC file member in IFCZIP file (2)");
-        }
-
-        unzClose(zip);
-#else
-        ThrowException("Could not open ifczip file for reading, assimp was built without ifczip support");
-#endif
-    }
-
-    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
-    const STEP::HeaderInfo &head = static_cast<const STEP::DB &>(*db).GetHeader();
-
-    if (!head.fileSchema.size() || head.fileSchema.substr(0, 3) != "IFC") {
-        ThrowException("Unrecognized file schema: " + head.fileSchema);
-    }
-
-    if (!DefaultLogger::isNullLogger()) {
-        LogDebug("File schema is \'", head.fileSchema, '\'');
-        if (head.timestamp.length()) {
-            LogDebug("Timestamp \'", head.timestamp, '\'');
-        }
-        if (head.app.length()) {
-            LogDebug("Application/Exporter identline is \'", head.app, '\'');
-        }
-    }
-
-    // obtain a copy of the machine-generated IFC scheme
-    ::Assimp::STEP::EXPRESS::ConversionSchema schema;
-    Schema_2x3::GetSchema(schema);
-
-    // tell the reader which entity types to track with special care
-    static const char *const types_to_track[] = {
-        "ifcsite", "ifcbuilding", "ifcproject"
-    };
-
-    // tell the reader for which types we need to simulate STEPs reverse indices
-    static const char *const inverse_indices_to_track[] = {
-        "ifcrelcontainedinspatialstructure", "ifcrelaggregates", "ifcrelvoidselement", "ifcreldefinesbyproperties", "ifcpropertyset", "ifcstyleditem"
-    };
-
-    // feed the IFC schema into the reader and pre-parse all lines
-    STEP::ReadFile(*db, schema, types_to_track, inverse_indices_to_track);
-    const STEP::LazyObject *proj = db->GetObject("ifcproject");
-    if (!proj) {
-        ThrowException("missing IfcProject entity");
-    }
-
-    ConversionData conv(*db, proj->To<Schema_2x3::IfcProject>(), pScene, settings);
-    SetUnits(conv);
-    SetCoordinateSpace(conv);
-    ProcessSpatialStructures(conv);
-    MakeTreeRelative(conv);
-
-// NOTE - this is a stress test for the importer, but it works only
-// in a build with no entities disabled. See
-//     scripts/IFCImporter/CPPGenerator.py
-// for more information.
-#ifdef ASSIMP_IFC_TEST
-    db->EvaluateAll();
-#endif
-
-    // do final data copying
-    if (conv.meshes.size()) {
-        pScene->mNumMeshes = static_cast<unsigned int>(conv.meshes.size());
-        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
-        std::copy(conv.meshes.begin(), conv.meshes.end(), pScene->mMeshes);
-
-        // needed to keep the d'tor from burning us
-        conv.meshes.clear();
-    }
-
-    if (conv.materials.size()) {
-        pScene->mNumMaterials = static_cast<unsigned int>(conv.materials.size());
-        pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]();
-        std::copy(conv.materials.begin(), conv.materials.end(), pScene->mMaterials);
-
-        // needed to keep the d'tor from burning us
-        conv.materials.clear();
-    }
-
-    // apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x)
-    aiMatrix4x4 scale, rot;
-    aiMatrix4x4::Scaling(static_cast<aiVector3D>(IfcVector3(conv.len_scale)), scale);
-    aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F, rot);
-
-    pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation;
-
-    // this must be last because objects are evaluated lazily as we process them
-    if (!DefaultLogger::isNullLogger()) {
-        LogDebug("STEP: evaluated ", db->GetEvaluatedObjectCount(), " object records");
-    }
-}
-
-namespace {
-
-// ------------------------------------------------------------------------------------------------
-void ConvertUnit(const Schema_2x3::IfcNamedUnit &unit, ConversionData &conv) {
-    if (const Schema_2x3::IfcSIUnit *const si = unit.ToPtr<Schema_2x3::IfcSIUnit>()) {
-        if (si->UnitType == "LENGTHUNIT") {
-            conv.len_scale = si->Prefix ? ConvertSIPrefix(si->Prefix) : 1.f;
-            IFCImporter::LogDebug("got units used for lengths");
-        }
-        if (si->UnitType == "PLANEANGLEUNIT") {
-            if (si->Name != "RADIAN") {
-                IFCImporter::LogWarn("expected base unit for angles to be radian");
-            }
-        }
-    } else if (const Schema_2x3::IfcConversionBasedUnit *const convu = unit.ToPtr<Schema_2x3::IfcConversionBasedUnit>()) {
-        if (convu->UnitType == "PLANEANGLEUNIT") {
-            try {
-                conv.angle_scale = convu->ConversionFactor->ValueComponent->To<::Assimp::STEP::EXPRESS::REAL>();
-                ConvertUnit(*convu->ConversionFactor->UnitComponent, conv);
-                IFCImporter::LogDebug("got units used for angles");
-            } catch (std::bad_cast &) {
-                IFCImporter::LogError("skipping unknown IfcConversionBasedUnit.ValueComponent entry - expected REAL");
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertUnit(const ::Assimp::STEP::EXPRESS::DataType &dt, ConversionData &conv) {
-    try {
-        const ::Assimp::STEP::EXPRESS::ENTITY &e = dt.To<::Assimp::STEP::EXPRESS::ENTITY>();
-
-        const Schema_2x3::IfcNamedUnit &unit = e.ResolveSelect<Schema_2x3::IfcNamedUnit>(conv.db);
-        if (unit.UnitType != "LENGTHUNIT" && unit.UnitType != "PLANEANGLEUNIT") {
-            return;
-        }
-
-        ConvertUnit(unit, conv);
-    } catch (std::bad_cast &) {
-        // not entity, somehow
-        IFCImporter::LogError("skipping unknown IfcUnit entry - expected entity");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SetUnits(ConversionData &conv) {
-    // see if we can determine the coordinate space used to express.
-    for (size_t i = 0; i < conv.proj.UnitsInContext->Units.size(); ++i) {
-        ConvertUnit(*conv.proj.UnitsInContext->Units[i], conv);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void SetCoordinateSpace(ConversionData &conv) {
-    const Schema_2x3::IfcRepresentationContext *fav = nullptr;
-    for (const Schema_2x3::IfcRepresentationContext &v : conv.proj.RepresentationContexts) {
-        fav = &v;
-        // Model should be the most suitable type of context, hence ignore the others
-        if (v.ContextType && v.ContextType.Get() == "Model") {
-            break;
-        }
-    }
-    if (fav) {
-        if (const Schema_2x3::IfcGeometricRepresentationContext *const geo = fav->ToPtr<Schema_2x3::IfcGeometricRepresentationContext>()) {
-            ConvertAxisPlacement(conv.wcs, *geo->WorldCoordinateSystem, conv);
-            IFCImporter::LogDebug("got world coordinate system");
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ResolveObjectPlacement(aiMatrix4x4 &m, const Schema_2x3::IfcObjectPlacement &place, ConversionData &conv) {
-    if (const Schema_2x3::IfcLocalPlacement *const local = place.ToPtr<Schema_2x3::IfcLocalPlacement>()) {
-        IfcMatrix4 tmp;
-        ConvertAxisPlacement(tmp, *local->RelativePlacement, conv);
-
-        m = static_cast<aiMatrix4x4>(tmp);
-
-        if (local->PlacementRelTo) {
-            aiMatrix4x4 tmpM;
-            ResolveObjectPlacement(tmpM, local->PlacementRelTo.Get(), conv);
-            m = tmpM * m;
-        }
-    } else {
-        IFCImporter::LogWarn("skipping unknown IfcObjectPlacement entity, type is ", place.GetClassName());
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-bool ProcessMappedItem(const Schema_2x3::IfcMappedItem &mapped, aiNode *nd_src, std::vector<aiNode *> &subnodes_src, unsigned int matid, ConversionData &conv) {
-    // insert a custom node here, the carthesian transform operator is simply a conventional transformation matrix
-    std::unique_ptr<aiNode> nd(new aiNode());
-    nd->mName.Set("IfcMappedItem");
-
-    // handle the Cartesian operator
-    IfcMatrix4 m;
-    ConvertTransformOperator(m, *mapped.MappingTarget);
-
-    IfcMatrix4 msrc;
-    ConvertAxisPlacement(msrc, *mapped.MappingSource->MappingOrigin, conv);
-
-    msrc = m * msrc;
-
-    std::set<unsigned int> meshes;
-    const size_t old_openings = conv.collect_openings ? conv.collect_openings->size() : 0;
-    if (conv.apply_openings) {
-        IfcMatrix4 minv = msrc;
-        minv.Inverse();
-        for (TempOpening &open : *conv.apply_openings) {
-            open.Transform(minv);
-        }
-    }
-
-    unsigned int localmatid = ProcessMaterials(mapped.GetID(), matid, conv, false);
-    const Schema_2x3::IfcRepresentation &repr = mapped.MappingSource->MappedRepresentation;
-
-    bool got = false;
-    for (const Schema_2x3::IfcRepresentationItem &item : repr.Items) {
-        if (!ProcessRepresentationItem(item, localmatid, meshes, conv)) {
-            IFCImporter::LogWarn("skipping mapped entity of type ", item.GetClassName(), ", no representations could be generated");
-        } else
-            got = true;
-    }
-
-    if (!got) {
-        return false;
-    }
-
-    AssignAddedMeshes(meshes, nd.get(), conv);
-    if (conv.collect_openings) {
-
-        // if this pass serves us only to collect opening geometry,
-        // make sure we transform the TempMesh's which we need to
-        // preserve as well.
-        if (const size_t diff = conv.collect_openings->size() - old_openings) {
-            for (size_t i = 0; i < diff; ++i) {
-                (*conv.collect_openings)[old_openings + i].Transform(msrc);
-            }
-        }
-    }
-
-    nd->mTransformation = nd_src->mTransformation * static_cast<aiMatrix4x4>(msrc);
-    subnodes_src.push_back(nd.release());
-
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-struct RateRepresentationPredicate {
-    int Rate(const Schema_2x3::IfcRepresentation *r) const {
-        // the smaller, the better
-
-        if (!r->RepresentationIdentifier) {
-            // neutral choice if no extra information is specified
-            return 0;
-        }
-
-        const std::string &name = r->RepresentationIdentifier.Get();
-        if (name == "MappedRepresentation") {
-            if (!r->Items.empty()) {
-                // take the first item and base our choice on it
-                const Schema_2x3::IfcMappedItem *const m = r->Items.front()->ToPtr<Schema_2x3::IfcMappedItem>();
-                if (m) {
-                    return Rate(m->MappingSource->MappedRepresentation);
-                }
-            }
-            return 100;
-        }
-
-        return Rate(name);
-    }
-
-    int Rate(const std::string &r) const {
-        if (r == "SolidModel") {
-            return -3;
-        }
-
-        // give strong preference to extruded geometry.
-        if (r == "SweptSolid") {
-            return -10;
-        }
-
-        if (r == "Clipping") {
-            return -5;
-        }
-
-        // 'Brep' is difficult to get right due to possible voids in the
-        // polygon boundaries, so take it only if we are forced to (i.e.
-        // if the only alternative is (non-clipping) boolean operations,
-        // which are not supported at all).
-        if (r == "Brep") {
-            return -2;
-        }
-
-        // Curves, bounding boxes - those will most likely not be loaded
-        // as we can't make any use out of this data. So consider them
-        // last.
-        if (r == "BoundingBox" || r == "Curve2D") {
-            return 100;
-        }
-        return 0;
-    }
-
-    bool operator()(const Schema_2x3::IfcRepresentation *a, const Schema_2x3::IfcRepresentation *b) const {
-        return Rate(a) < Rate(b);
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-void ProcessProductRepresentation(const Schema_2x3::IfcProduct &el, aiNode *nd, std::vector<aiNode *> &subnodes, ConversionData &conv) {
-    if (!el.Representation) {
-        return;
-    }
-
-    // extract Color from metadata, if present
-    unsigned int matid = ProcessMaterials(el.GetID(), std::numeric_limits<uint32_t>::max(), conv, false);
-    std::set<unsigned int> meshes;
-
-    // we want only one representation type, so bring them in a suitable order (i.e try those
-    // that look as if we could read them quickly at first). This way of reading
-    // representation is relatively generic and allows the concrete implementations
-    // for the different representation types to make some sensible choices what
-    // to load and what not to load.
-    const STEP::ListOf<STEP::Lazy<Schema_2x3::IfcRepresentation>, 1, 0> &src = el.Representation.Get()->Representations;
-    std::vector<const Schema_2x3::IfcRepresentation *> repr_ordered(src.size());
-    std::copy(src.begin(), src.end(), repr_ordered.begin());
-    std::sort(repr_ordered.begin(), repr_ordered.end(), RateRepresentationPredicate());
-    for (const Schema_2x3::IfcRepresentation *repr : repr_ordered) {
-        bool res = false;
-        for (const Schema_2x3::IfcRepresentationItem &item : repr->Items) {
-            if (const Schema_2x3::IfcMappedItem *const geo = item.ToPtr<Schema_2x3::IfcMappedItem>()) {
-                res = ProcessMappedItem(*geo, nd, subnodes, matid, conv) || res;
-            } else {
-                res = ProcessRepresentationItem(item, matid, meshes, conv) || res;
-            }
-        }
-        // if we got something meaningful at this point, skip any further representations
-        if (res) {
-            break;
-        }
-    }
-    AssignAddedMeshes(meshes, nd, conv);
-}
-
-typedef std::map<std::string, std::string> Metadata;
-
-// ------------------------------------------------------------------------------------------------
-void ProcessMetadata(const Schema_2x3::ListOf<Schema_2x3::Lazy<Schema_2x3::IfcProperty>, 1, 0> &set, ConversionData &conv, Metadata &properties,
-        const std::string &prefix = std::string(),
-        unsigned int nest = 0) {
-    for (const Schema_2x3::IfcProperty &property : set) {
-        const std::string &key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
-        if (const Schema_2x3::IfcPropertySingleValue *const singleValue = property.ToPtr<Schema_2x3::IfcPropertySingleValue>()) {
-            if (singleValue->NominalValue) {
-                if (const ::Assimp::STEP::EXPRESS::STRING *str = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
-                    std::string value = static_cast<std::string>(*str);
-                    properties[key] = value;
-                } else if (const ::Assimp::STEP::EXPRESS::REAL *val1 = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                    float value = static_cast<float>(*val1);
-                    std::stringstream s;
-                    s << value;
-                    properties[key] = s.str();
-                } else if (const ::Assimp::STEP::EXPRESS::INTEGER *val2 = singleValue->NominalValue.Get()->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
-                    int64_t curValue = static_cast<int64_t>(*val2);
-                    std::stringstream s;
-                    s << curValue;
-                    properties[key] = s.str();
-                }
-            }
-        } else if (const Schema_2x3::IfcPropertyListValue *const listValue = property.ToPtr<Schema_2x3::IfcPropertyListValue>()) {
-            std::stringstream ss;
-            ss << "[";
-            unsigned index = 0;
-            for (const Schema_2x3::IfcValue::Out &v : listValue->ListValues) {
-                if (!v) continue;
-                if (const ::Assimp::STEP::EXPRESS::STRING *str = v->ToPtr<::Assimp::STEP::EXPRESS::STRING>()) {
-                    std::string value = static_cast<std::string>(*str);
-                    ss << "'" << value << "'";
-                } else if (const ::Assimp::STEP::EXPRESS::REAL *val1 = v->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                    float value = static_cast<float>(*val1);
-                    ss << value;
-                } else if (const ::Assimp::STEP::EXPRESS::INTEGER *val2 = v->ToPtr<::Assimp::STEP::EXPRESS::INTEGER>()) {
-                    int64_t value = static_cast<int64_t>(*val2);
-                    ss << value;
-                }
-                if (index + 1 < listValue->ListValues.size()) {
-                    ss << ",";
-                }
-                index++;
-            }
-            ss << "]";
-            properties[key] = ss.str();
-        } else if (const Schema_2x3::IfcComplexProperty *const complexProp = property.ToPtr<Schema_2x3::IfcComplexProperty>()) {
-            if (nest > 2) { // mostly arbitrary limit to prevent stack overflow vulnerabilities
-                IFCImporter::LogError("maximum nesting level for IfcComplexProperty reached, skipping this property.");
-            } else {
-                ProcessMetadata(complexProp->HasProperties, conv, properties, key, nest + 1);
-            }
-        } else {
-            properties[key] = std::string();
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessMetadata(uint64_t relDefinesByPropertiesID, ConversionData &conv, Metadata &properties) {
-    if (const Schema_2x3::IfcRelDefinesByProperties *const pset = conv.db.GetObject(relDefinesByPropertiesID)->ToPtr<Schema_2x3::IfcRelDefinesByProperties>()) {
-        if (const Schema_2x3::IfcPropertySet *const set = conv.db.GetObject(pset->RelatingPropertyDefinition->GetID())->ToPtr<Schema_2x3::IfcPropertySet>()) {
-            ProcessMetadata(set->HasProperties, conv, properties);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-aiNode *ProcessSpatialStructure(aiNode *parent, const Schema_2x3::IfcProduct &el, ConversionData &conv,
-        std::vector<TempOpening> *collect_openings = nullptr) {
-    const STEP::DB::RefMap &refs = conv.db.GetRefs();
-
-    // skip over space and annotation nodes - usually, these have no meaning in Assimp's context
-    bool skipGeometry = false;
-    if (conv.settings.skipSpaceRepresentations) {
-        if (el.ToPtr<Schema_2x3::IfcSpace>()) {
-            IFCImporter::LogVerboseDebug("skipping IfcSpace entity due to importer settings");
-            skipGeometry = true;
-        }
-    }
-
-    if (conv.settings.skipAnnotations) {
-        if (el.ToPtr<Schema_2x3::IfcAnnotation>()) {
-            IFCImporter::LogVerboseDebug("skipping IfcAnnotation entity due to importer settings");
-            return nullptr;
-        }
-    }
-
-    // add an output node for this spatial structure
-    aiNode *nd(new aiNode);
-    nd->mName.Set(el.GetClassName() + "_" + (el.Name ? el.Name.Get() : "Unnamed") + "_" + el.GlobalId);
-    nd->mParent = parent;
-
-    conv.already_processed.insert(el.GetID());
-
-    // check for node metadata
-    STEP::DB::RefMapRange children = refs.equal_range(el.GetID());
-    if (children.first != refs.end()) {
-        Metadata properties;
-        if (children.first == children.second) {
-            // handles single property set
-            ProcessMetadata((*children.first).second, conv, properties);
-        } else {
-            // handles multiple property sets (currently all property sets are merged,
-            // which may not be the best solution in the long run)
-            for (STEP::DB::RefMap::const_iterator it = children.first; it != children.second; ++it) {
-                ProcessMetadata((*it).second, conv, properties);
-            }
-        }
-
-        if (!properties.empty()) {
-            aiMetadata *data = aiMetadata::Alloc(static_cast<unsigned int>(properties.size()));
-            unsigned int index(0);
-            for (const Metadata::value_type &kv : properties) {
-                data->Set(index++, kv.first, aiString(kv.second));
-            }
-            nd->mMetaData = data;
-        }
-    }
-
-    if (el.ObjectPlacement) {
-        ResolveObjectPlacement(nd->mTransformation, el.ObjectPlacement.Get(), conv);
-    }
-
-    std::vector<TempOpening> openings;
-
-    IfcMatrix4 myInv;
-    bool didinv = false;
-
-    // convert everything contained directly within this structure,
-    // this may result in more nodes.
-    std::vector<aiNode *> subnodes;
-    try {
-        // locate aggregates and 'contained-in-here'-elements of this spatial structure and add them in recursively
-        // on our way, collect openings in *this* element
-        STEP::DB::RefMapRange range = refs.equal_range(el.GetID());
-
-        for (STEP::DB::RefMapRange range2 = range; range2.first != range.second; ++range2.first) {
-            // skip over meshes that have already been processed before. This is strictly necessary
-            // because the reverse indices also include references contained in argument lists and
-            // therefore every element has a back-reference hold by its parent.
-            if (conv.already_processed.find((*range2.first).second) != conv.already_processed.end()) {
-                continue;
-            }
-            const STEP::LazyObject &obj = conv.db.MustGetObject((*range2.first).second);
-
-            // handle regularly-contained elements
-            if (const Schema_2x3::IfcRelContainedInSpatialStructure *const cont = obj->ToPtr<Schema_2x3::IfcRelContainedInSpatialStructure>()) {
-                if (cont->RelatingStructure->GetID() != el.GetID()) {
-                    continue;
-                }
-                for (const Schema_2x3::IfcProduct &pro : cont->RelatedElements) {
-                    if (pro.ToPtr<Schema_2x3::IfcOpeningElement>()) {
-                        // IfcOpeningElement is handled below. Sadly we can't use it here as is:
-                        // The docs say that opening elements are USUALLY attached to building storey,
-                        // but we want them for the building elements to which they belong.
-                        continue;
-                    }
-
-                    aiNode *const ndnew = ProcessSpatialStructure(nd, pro, conv, nullptr);
-                    if (ndnew) {
-                        subnodes.push_back(ndnew);
-                    }
-                }
-            }
-            // handle openings, which we collect in a list rather than adding them to the node graph
-            else if (const Schema_2x3::IfcRelVoidsElement *const fills = obj->ToPtr<Schema_2x3::IfcRelVoidsElement>()) {
-                if (fills->RelatingBuildingElement->GetID() == el.GetID()) {
-                    const Schema_2x3::IfcFeatureElementSubtraction &open = fills->RelatedOpeningElement;
-
-                    // move opening elements to a separate node since they are semantically different than elements that are just 'contained'
-                    std::unique_ptr<aiNode> nd_aggr(new aiNode());
-                    nd_aggr->mName.Set("$RelVoidsElement");
-                    nd_aggr->mParent = nd;
-
-                    nd_aggr->mTransformation = nd->mTransformation;
-
-                    std::vector<TempOpening> openings_local;
-                    aiNode *const ndnew = ProcessSpatialStructure(nd_aggr.get(), open, conv, &openings_local);
-                    if (ndnew) {
-
-                        nd_aggr->mNumChildren = 1;
-                        nd_aggr->mChildren = new aiNode *[1]();
-
-                        nd_aggr->mChildren[0] = ndnew;
-
-                        if (openings_local.size()) {
-                            if (!didinv) {
-                                myInv = aiMatrix4x4(nd->mTransformation).Inverse();
-                                didinv = true;
-                            }
-
-                            // we need all openings to be in the local space of *this* node, so transform them
-                            for (TempOpening &op : openings_local) {
-                                op.Transform(myInv * nd_aggr->mChildren[0]->mTransformation);
-                                openings.push_back(op);
-                            }
-                        }
-                        subnodes.push_back(nd_aggr.release());
-                    }
-                }
-            }
-        }
-
-        for (; range.first != range.second; ++range.first) {
-            // see note in loop above
-            if (conv.already_processed.find((*range.first).second) != conv.already_processed.end()) {
-                continue;
-            }
-            if (const Schema_2x3::IfcRelAggregates *const aggr = conv.db.GetObject((*range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
-                if (aggr->RelatingObject->GetID() != el.GetID()) {
-                    continue;
-                }
-
-                // move aggregate elements to a separate node since they are semantically different than elements that are just 'contained'
-                std::unique_ptr<aiNode> nd_aggr(new aiNode());
-                nd_aggr->mName.Set("$RelAggregates");
-                nd_aggr->mParent = nd;
-
-                nd_aggr->mTransformation = nd->mTransformation;
-
-                nd_aggr->mChildren = new aiNode *[aggr->RelatedObjects.size()]();
-                for (const Schema_2x3::IfcObjectDefinition &def : aggr->RelatedObjects) {
-                    if (const Schema_2x3::IfcProduct *const prod = def.ToPtr<Schema_2x3::IfcProduct>()) {
-
-                        aiNode *const ndnew = ProcessSpatialStructure(nd_aggr.get(), *prod, conv, nullptr);
-                        if (ndnew) {
-                            nd_aggr->mChildren[nd_aggr->mNumChildren++] = ndnew;
-                        }
-                    }
-                }
-
-                subnodes.push_back(nd_aggr.release());
-            }
-        }
-
-        conv.collect_openings = collect_openings;
-        if (!conv.collect_openings) {
-            conv.apply_openings = &openings;
-        }
-
-        if (!skipGeometry) {
-            ProcessProductRepresentation(el, nd, subnodes, conv);
-            conv.apply_openings = conv.collect_openings = nullptr;
-        }
-
-        if (subnodes.size()) {
-            nd->mChildren = new aiNode *[subnodes.size()]();
-            for (aiNode *nd2 : subnodes) {
-                nd->mChildren[nd->mNumChildren++] = nd2;
-                nd2->mParent = nd;
-            }
-        }
-    } catch (...) {
-        // it hurts, but I don't want to pull boost::ptr_vector into -noboost only for these few spots here
-        std::for_each(subnodes.begin(), subnodes.end(), delete_fun<aiNode>());
-        throw;
-    }
-
-    ai_assert(conv.already_processed.find(el.GetID()) != conv.already_processed.end());
-    conv.already_processed.erase(conv.already_processed.find(el.GetID()));
-    return nd;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessSpatialStructures(ConversionData &conv) {
-    // XXX add support for multiple sites (i.e. IfcSpatialStructureElements with composition == COMPLEX)
-
-    // process all products in the file. it is reasonable to assume that a
-    // file that is relevant for us contains at least a site or a building.
-    const STEP::DB::ObjectMapByType &map = conv.db.GetObjectsByType();
-
-    ai_assert(map.find("ifcsite") != map.end());
-    const STEP::DB::ObjectSet *range = &map.find("ifcsite")->second;
-
-    if (range->empty()) {
-        ai_assert(map.find("ifcbuilding") != map.end());
-        range = &map.find("ifcbuilding")->second;
-        if (range->empty()) {
-            // no site, no building -  fail;
-            IFCImporter::ThrowException("no root element found (expected IfcBuilding or preferably IfcSite)");
-        }
-    }
-
-    std::vector<aiNode *> nodes;
-
-    for (const STEP::LazyObject *lz : *range) {
-        const Schema_2x3::IfcSpatialStructureElement *const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
-        if (!prod) {
-            continue;
-        }
-        IFCImporter::LogVerboseDebug("looking at spatial structure `", (prod->Name ? prod->Name.Get() : "unnamed"), "`", (prod->ObjectType ? " which is of type " + prod->ObjectType.Get() : ""));
-
-        // the primary sites are referenced by an IFCRELAGGREGATES element which assigns them to the IFCPRODUCT
-        const STEP::DB::RefMap &refs = conv.db.GetRefs();
-        STEP::DB::RefMapRange ref_range = refs.equal_range(conv.proj.GetID());
-        for (; ref_range.first != ref_range.second; ++ref_range.first) {
-            if (const Schema_2x3::IfcRelAggregates *const aggr = conv.db.GetObject((*ref_range.first).second)->ToPtr<Schema_2x3::IfcRelAggregates>()) {
-
-                for (const Schema_2x3::IfcObjectDefinition &def : aggr->RelatedObjects) {
-                    // comparing pointer values is not sufficient, we would need to cast them to the same type first
-                    // as there is multiple inheritance in the game.
-                    if (def.GetID() == prod->GetID()) {
-                        IFCImporter::LogVerboseDebug("selecting this spatial structure as root structure");
-                        // got it, this is one primary site.
-                        nodes.push_back(ProcessSpatialStructure(nullptr, *prod, conv, nullptr));
-                    }
-                }
-            }
-        }
-    }
-
-    size_t nb_nodes = nodes.size();
-
-    if (nb_nodes == 0) {
-        IFCImporter::LogWarn("failed to determine primary site element, taking all the IfcSite");
-        for (const STEP::LazyObject *lz : *range) {
-            const Schema_2x3::IfcSpatialStructureElement *const prod = lz->ToPtr<Schema_2x3::IfcSpatialStructureElement>();
-            if (!prod) {
-                continue;
-            }
-
-            nodes.push_back(ProcessSpatialStructure(nullptr, *prod, conv, nullptr));
-        }
-
-        nb_nodes = nodes.size();
-    }
-
-    if (nb_nodes == 1) {
-        conv.out->mRootNode = nodes[0];
-    } else if (nb_nodes > 1) {
-        conv.out->mRootNode = new aiNode("Root");
-        conv.out->mRootNode->mParent = nullptr;
-        conv.out->mRootNode->mNumChildren = static_cast<unsigned int>(nb_nodes);
-        conv.out->mRootNode->mChildren = new aiNode *[conv.out->mRootNode->mNumChildren];
-
-        for (size_t i = 0; i < nb_nodes; ++i) {
-            aiNode *node = nodes[i];
-
-            node->mParent = conv.out->mRootNode;
-
-            conv.out->mRootNode->mChildren[i] = node;
-        }
-    } else {
-        IFCImporter::ThrowException("failed to determine primary site element");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void MakeTreeRelative(aiNode *start, const aiMatrix4x4 &combined) {
-    // combined is the parent's absolute transformation matrix
-    const aiMatrix4x4 old = start->mTransformation;
-
-    if (!combined.IsIdentity()) {
-        start->mTransformation = aiMatrix4x4(combined).Inverse() * start->mTransformation;
-    }
-
-    // All nodes store absolute transformations right now, so we need to make them relative
-    for (unsigned int i = 0; i < start->mNumChildren; ++i) {
-        MakeTreeRelative(start->mChildren[i], old);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void MakeTreeRelative(ConversionData &conv) {
-    MakeTreeRelative(conv.out->mRootNode, IfcMatrix4());
-}
-
-} // namespace
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.h
deleted file mode 100644
index 7b2c3aa..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCLoader.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFC.h
- *  @brief Declaration of the Industry Foundation Classes (IFC) loader main class
- */
-#ifndef INCLUDED_AI_IFC_LOADER_H
-#define INCLUDED_AI_IFC_LOADER_H
-
-#include <assimp/BaseImporter.h>
-#include <assimp/LogAux.h>
-
-namespace Assimp {
-
-// TinyFormatter.h
-namespace Formatter {
-
-template <typename T, typename TR, typename A>
-class basic_formatter;
-typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
-
-} // namespace Formatter
-
-namespace STEP {
-
-class DB;
-
-}
-
-// -------------------------------------------------------------------------------------------
-/** Load the IFC format, which is an open specification to describe building and construction
-    industry data.
-
- See http://en.wikipedia.org/wiki/Industry_Foundation_Classes
-*/
-// -------------------------------------------------------------------------------------------
-class IFCImporter : public BaseImporter, public LogFunctions<IFCImporter> {
-public:
-    // loader settings, publicly accessible via their corresponding AI_CONFIG constants
-    struct Settings {
-        Settings() :
-                skipSpaceRepresentations(), useCustomTriangulation(), skipAnnotations(), conicSamplingAngle(10.f), cylindricalTessellation(32) {}
-
-        bool skipSpaceRepresentations;
-        bool useCustomTriangulation;
-        bool skipAnnotations;
-        float conicSamplingAngle;
-        int cylindricalTessellation;
-    };
-
-    IFCImporter();
-    ~IFCImporter() override;
-
-    // --------------------
-    bool CanRead(const std::string &pFile,
-            IOSystem *pIOHandler,
-            bool checkSig) const override;
-
-protected:
-    // --------------------
-    const aiImporterDesc *GetInfo() const override;
-
-    // --------------------
-    void SetupProperties(const Importer *pImp) override;
-
-    // --------------------
-    void InternReadFile(const std::string &pFile,
-            aiScene *pScene,
-            IOSystem *pIOHandler) override;
-
-private:
-    Settings settings;
-
-}; // !class IFCImporter
-
-} // end of namespace Assimp
-#endif // !INCLUDED_AI_IFC_LOADER_H
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCMaterial.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCMaterial.cpp
deleted file mode 100644
index 6cd0e59..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCMaterial.cpp
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCMaterial.cpp
- *  @brief Implementation of conversion routines to convert IFC materials to aiMaterial
- */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "IFCUtil.h"
-#include <limits>
-#include <assimp/material.h>
-
-namespace Assimp {
-namespace IFC {
-
-// ------------------------------------------------------------------------------------------------
-static int ConvertShadingMode(const std::string& name) {
-    if (name == "BLINN") {
-        return aiShadingMode_Blinn;
-    }
-    else if (name == "FLAT" || name == "NOTDEFINED") {
-        return aiShadingMode_NoShading;
-    }
-    else if (name == "PHONG") {
-        return aiShadingMode_Phong;
-    }
-    IFCImporter::LogWarn("shading mode ", name, " not recognized by Assimp, using Phong instead");
-    return aiShadingMode_Phong;
-}
-
-// ------------------------------------------------------------------------------------------------
-static void FillMaterial(aiMaterial* mat,const IFC::Schema_2x3::IfcSurfaceStyle* surf,ConversionData& conv) {
-    aiString name;
-    name.Set((surf->Name? surf->Name.Get() : "IfcSurfaceStyle_Unnamed"));
-    mat->AddProperty(&name,AI_MATKEY_NAME);
-
-    // now see which kinds of surface information are present
-    for (const std::shared_ptr<const IFC::Schema_2x3::IfcSurfaceStyleElementSelect> &sel2 : surf->Styles) {
-        if (const IFC::Schema_2x3::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyleShading>(conv.db)) {
-            aiColor4D col_base,col;
-
-            ConvertColor(col_base, shade->SurfaceColour);
-            mat->AddProperty(&col_base,1, AI_MATKEY_COLOR_DIFFUSE);
-
-            if (const IFC::Schema_2x3::IfcSurfaceStyleRendering* ren = shade->ToPtr<IFC::Schema_2x3::IfcSurfaceStyleRendering>()) {
-
-                if (ren->Transparency) {
-                    const float t = 1.f-static_cast<float>(ren->Transparency.Get());
-                    mat->AddProperty(&t,1, AI_MATKEY_OPACITY);
-                }
-
-                if (ren->DiffuseColour) {
-                    ConvertColor(col, *ren->DiffuseColour.Get(),conv,&col_base);
-                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_DIFFUSE);
-                }
-
-                if (ren->SpecularColour) {
-                    ConvertColor(col, *ren->SpecularColour.Get(),conv,&col_base);
-                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_SPECULAR);
-                }
-
-                if (ren->TransmissionColour) {
-                    ConvertColor(col, *ren->TransmissionColour.Get(),conv,&col_base);
-                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_TRANSPARENT);
-                }
-
-                if (ren->ReflectionColour) {
-                    ConvertColor(col, *ren->ReflectionColour.Get(),conv,&col_base);
-                    mat->AddProperty(&col,1, AI_MATKEY_COLOR_REFLECTIVE);
-                }
-
-                const int shading = (ren->SpecularHighlight && ren->SpecularColour)?ConvertShadingMode(ren->ReflectanceMethod):static_cast<int>(aiShadingMode_Gouraud);
-                mat->AddProperty(&shading,1, AI_MATKEY_SHADING_MODEL);
-
-                if (ren->SpecularHighlight) {
-                    if(const ::Assimp::STEP::EXPRESS::REAL* rt = ren->SpecularHighlight.Get()->ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-                        // at this point we don't distinguish between the two distinct ways of
-                        // specifying highlight intensities. leave this to the user.
-                        const float e = static_cast<float>(*rt);
-                        mat->AddProperty(&e,1,AI_MATKEY_SHININESS);
-                    }
-                    else {
-                        IFCImporter::LogWarn("unexpected type error, SpecularHighlight should be a REAL");
-                    }
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionData& conv, bool forceDefaultMat) {
-    STEP::DB::RefMapRange range = conv.db.GetRefs().equal_range(id);
-    for(;range.first != range.second; ++range.first) {
-        if(const IFC::Schema_2x3::IfcStyledItem* const styled = conv.db.GetObject((*range.first).second)->ToPtr<IFC::Schema_2x3::IfcStyledItem>()) {
-            for(const IFC::Schema_2x3::IfcPresentationStyleAssignment& as : styled->Styles) {
-                for (const std::shared_ptr<const IFC::Schema_2x3::IfcPresentationStyleSelect> &sel : as.Styles) {
-
-                    if( const IFC::Schema_2x3::IfcSurfaceStyle* const surf = sel->ResolveSelectPtr<IFC::Schema_2x3::IfcSurfaceStyle>(conv.db) ) {
-                        // try to satisfy from cache
-                        ConversionData::MaterialCache::iterator mit = conv.cached_materials.find(surf);
-                        if( mit != conv.cached_materials.end() )
-                            return mit->second;
-
-                        // not found, create new material
-                        const std::string side = static_cast<std::string>(surf->Side);
-                        if( side != "BOTH" ) {
-                            IFCImporter::LogWarn("ignoring surface side marker on IFC::IfcSurfaceStyle: ", side);
-                        }
-
-                        std::unique_ptr<aiMaterial> mat(new aiMaterial());
-
-                        FillMaterial(mat.get(), surf, conv);
-
-                        conv.materials.push_back(mat.release());
-                        unsigned int matindex = static_cast<unsigned int>(conv.materials.size() - 1);
-                        conv.cached_materials[surf] = matindex;
-                        return matindex;
-                    }
-                }
-            }
-        }
-    }
-
-    // no local material defined. If there's global one, use that instead
-    if ( prevMatId != std::numeric_limits<uint32_t>::max() ) {
-        return prevMatId;
-    }
-
-    // we're still here - create an default material if required, or simply fail otherwise
-    if ( !forceDefaultMat ) {
-        return std::numeric_limits<uint32_t>::max();
-    }
-
-    aiString name;
-    name.Set("<IFCDefault>");
-    //  ConvertColorToString( color, name);
-
-    // look if there's already a default material with this base color
-    for( size_t a = 0; a < conv.materials.size(); ++a ) {
-        aiString mname;
-        conv.materials[a]->Get(AI_MATKEY_NAME, mname);
-        if ( name == mname ) {
-            return ( unsigned int )a;
-        }
-    }
-
-    // we're here, yet - no default material with suitable color available. Generate one
-    std::unique_ptr<aiMaterial> mat(new aiMaterial());
-    mat->AddProperty(&name,AI_MATKEY_NAME);
-
-    const aiColor4D col = aiColor4D( 0.6f, 0.6f, 0.6f, 1.0f); // aiColor4D( color.r, color.g, color.b, 1.0f);
-    mat->AddProperty(&col,1, AI_MATKEY_COLOR_DIFFUSE);
-
-    conv.materials.push_back(mat.release());
-    return (unsigned int) conv.materials.size() - 1;
-}
-
-} // ! IFC
-} // ! Assimp
-
-#endif // ASSIMP_BUILD_NO_IFC_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCOpenings.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCOpenings.cpp
deleted file mode 100644
index 7420019..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCOpenings.cpp
+++ /dev/null
@@ -1,1955 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCOpenings.cpp
- *  @brief Implements a subset of Ifc CSG operations for pouring
-  *    holes for windows and doors into walls.
- */
-
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "IFCUtil.h"
-#include "Common/PolyTools.h"
-#include "PostProcessing/ProcessHelper.h"
-
-#ifdef ASSIMP_USE_HUNTER
-#  include <poly2tri/poly2tri.h>
-#  include <polyclipping/clipper.hpp>
-#else
-#  include "../contrib/poly2tri/poly2tri/poly2tri.h"
-#  include "../contrib/clipper/clipper.hpp"
-#endif
-
-#include <iterator>
-#include <forward_list>
-#include <deque>
-
-namespace Assimp {
-    namespace IFC {
-
-        using ClipperLib::ulong64;
-        // XXX use full -+ range ...
-        const ClipperLib::long64 max_ulong64 = 1518500249; // clipper.cpp / hiRange var
-
-        //#define to_int64(p)  (static_cast<ulong64>( std::max( 0., std::min( static_cast<IfcFloat>((p)), 1.) ) * max_ulong64 ))
-#define to_int64(p)  (static_cast<ulong64>(static_cast<IfcFloat>((p) ) * max_ulong64 ))
-#define from_int64(p) (static_cast<IfcFloat>((p)) / max_ulong64)
-#define one_vec (IfcVector2(static_cast<IfcFloat>(1.0),static_cast<IfcFloat>(1.0)))
-
-
-        // fallback method to generate wall openings
-        bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,
-            TempMesh& curmesh);
-
-
-typedef std::pair< IfcVector2, IfcVector2 > BoundingBox;
-typedef std::map<IfcVector2,size_t,XYSorter> XYSortedField;
-
-
-// ------------------------------------------------------------------------------------------------
-void QuadrifyPart(const IfcVector2& pmin, const IfcVector2& pmax, XYSortedField& field,
-    const std::vector< BoundingBox >& bbs,
-    std::vector<IfcVector2>& out)
-{
-    if (!(pmin.x-pmax.x) || !(pmin.y-pmax.y)) {
-        return;
-    }
-
-    IfcFloat xs = 1e10, xe = 1e10;
-    bool found = false;
-
-    // Search along the x-axis until we find an opening
-    XYSortedField::iterator start = field.begin();
-    for(; start != field.end(); ++start) {
-        const BoundingBox& bb = bbs[(*start).second];
-        if(bb.first.x >= pmax.x) {
-            break;
-        }
-
-        if (bb.second.x > pmin.x && bb.second.y > pmin.y && bb.first.y < pmax.y) {
-            xs = bb.first.x;
-            xe = bb.second.x;
-            found = true;
-            break;
-        }
-    }
-
-    if (!found) {
-        // the rectangle [pmin,pend] is opaque, fill it
-        out.push_back(pmin);
-        out.push_back(IfcVector2(pmin.x,pmax.y));
-        out.push_back(pmax);
-        out.push_back(IfcVector2(pmax.x,pmin.y));
-        return;
-    }
-
-    xs = std::max(pmin.x,xs);
-    xe = std::min(pmax.x,xe);
-
-    // see if there's an offset to fill at the top of our quad
-    if (xs - pmin.x) {
-        out.push_back(pmin);
-        out.push_back(IfcVector2(pmin.x,pmax.y));
-        out.push_back(IfcVector2(xs,pmax.y));
-        out.push_back(IfcVector2(xs,pmin.y));
-    }
-
-    // search along the y-axis for all openings that overlap xs and our quad
-    IfcFloat ylast = pmin.y;
-    found = false;
-    for(; start != field.end(); ++start) {
-        const BoundingBox& bb = bbs[(*start).second];
-        if (bb.first.x > xs || bb.first.y >= pmax.y) {
-            break;
-        }
-
-        if (bb.second.y > ylast) {
-
-            found = true;
-            const IfcFloat ys = std::max(bb.first.y,pmin.y), ye = std::min(bb.second.y,pmax.y);
-            if (ys - ylast > 0.0f) {
-                QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,ys) ,field,bbs,out);
-            }
-
-            // the following are the window vertices
-
-            /*wnd.push_back(IfcVector2(xs,ys));
-            wnd.push_back(IfcVector2(xs,ye));
-            wnd.push_back(IfcVector2(xe,ye));
-            wnd.push_back(IfcVector2(xe,ys));*/
-            ylast = ye;
-        }
-    }
-    if (!found) {
-        // the rectangle [pmin,pend] is opaque, fill it
-        out.push_back(IfcVector2(xs,pmin.y));
-        out.push_back(IfcVector2(xs,pmax.y));
-        out.push_back(IfcVector2(xe,pmax.y));
-        out.push_back(IfcVector2(xe,pmin.y));
-        return;
-    }
-    if (ylast < pmax.y) {
-        QuadrifyPart( IfcVector2(xs,ylast), IfcVector2(xe,pmax.y) ,field,bbs,out);
-    }
-
-    // now for the whole rest
-    if (pmax.x-xe) {
-        QuadrifyPart(IfcVector2(xe,pmin.y), pmax ,field,bbs,out);
-    }
-}
-
-typedef std::vector<IfcVector2> Contour;
-typedef std::vector<bool> SkipList; // should probably use int for performance reasons
-
-struct ProjectedWindowContour
-{
-    Contour contour;
-    BoundingBox bb;
-    SkipList skiplist;
-    bool is_rectangular;
-
-
-    ProjectedWindowContour(const Contour& contour, const BoundingBox& bb, bool is_rectangular)
-        : contour(contour)
-        , bb(bb)
-        , is_rectangular(is_rectangular)
-    {}
-
-
-    bool IsInvalid() const {
-        return contour.empty();
-    }
-
-    void FlagInvalid() {
-        contour.clear();
-    }
-
-    void PrepareSkiplist() {
-        skiplist.resize(contour.size(),false);
-    }
-};
-
-typedef std::vector< ProjectedWindowContour > ContourVector;
-
-// ------------------------------------------------------------------------------------------------
-bool BoundingBoxesOverlapping( const BoundingBox &ibb, const BoundingBox &bb )
-{
-    // count the '=' case as non-overlapping but as adjacent to each other
-    return ibb.first.x < bb.second.x && ibb.second.x > bb.first.x &&
-        ibb.first.y < bb.second.y && ibb.second.y > bb.first.y;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool IsDuplicateVertex(const IfcVector2& vv, const std::vector<IfcVector2>& temp_contour)
-{
-    // sanity check for duplicate vertices
-    for(const IfcVector2& cp : temp_contour) {
-        if ((cp-vv).SquareLength() < 1e-5f) {
-            return true;
-        }
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ExtractVerticesFromClipper(const ClipperLib::Polygon& poly, std::vector<IfcVector2>& temp_contour,
-    bool filter_duplicates = false)
-{
-    temp_contour.clear();
-    for(const ClipperLib::IntPoint& point : poly) {
-        IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y));
-        vv = std::max(vv,IfcVector2());
-        vv = std::min(vv,one_vec);
-
-        if (!filter_duplicates || !IsDuplicateVertex(vv, temp_contour)) {
-            temp_contour.push_back(vv);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-BoundingBox GetBoundingBox(const ClipperLib::Polygon& poly)
-{
-    IfcVector2 newbb_min, newbb_max;
-    MinMaxChooser<IfcVector2>()(newbb_min, newbb_max);
-
-    for(const ClipperLib::IntPoint& point : poly) {
-        IfcVector2 vv = IfcVector2( from_int64(point.X), from_int64(point.Y));
-
-        // sanity rounding
-        vv = std::max(vv,IfcVector2());
-        vv = std::min(vv,one_vec);
-
-        newbb_min = std::min(newbb_min,vv);
-        newbb_max = std::max(newbb_max,vv);
-    }
-    return BoundingBox(newbb_min, newbb_max);
-}
-
-// ------------------------------------------------------------------------------------------------
-void InsertWindowContours(const ContourVector& contours,
-    const std::vector<TempOpening>& /*openings*/,
-    TempMesh& curmesh)
-{
-    // fix windows - we need to insert the real, polygonal shapes into the quadratic holes that we have now
-    for(size_t i = 0; i < contours.size();++i) {
-        const BoundingBox& bb = contours[i].bb;
-        const std::vector<IfcVector2>& contour = contours[i].contour;
-        if(contour.empty()) {
-            continue;
-        }
-
-        // check if we need to do it at all - many windows just fit perfectly into their quadratic holes,
-        // i.e. their contours *are* already their bounding boxes.
-        if (contour.size() == 4) {
-            std::set<IfcVector2,XYSorter> verts;
-            for(size_t n = 0; n < 4; ++n) {
-                verts.insert(contour[n]);
-            }
-            const std::set<IfcVector2,XYSorter>::const_iterator end = verts.end();
-            if (verts.find(bb.first)!=end && verts.find(bb.second)!=end
-                && verts.find(IfcVector2(bb.first.x,bb.second.y))!=end
-                && verts.find(IfcVector2(bb.second.x,bb.first.y))!=end
-                ) {
-                    continue;
-            }
-        }
-
-        const IfcFloat diag = (bb.first-bb.second).Length();
-        const IfcFloat epsilon = diag/1000.f;
-
-        // walk through all contour points and find those that lie on the BB corner
-        size_t last_hit = (size_t)-1, very_first_hit = (size_t)-1;
-        IfcVector2 edge;
-        for(size_t n = 0, e=0, size = contour.size();; n=(n+1)%size, ++e) {
-
-            // sanity checking
-            if (e == size*2) {
-                IFCImporter::LogError("encountered unexpected topology while generating window contour");
-                break;
-            }
-
-            const IfcVector2& v = contour[n];
-
-            bool hit = false;
-            if (std::fabs(v.x-bb.first.x)<epsilon) {
-                edge.x = bb.first.x;
-                hit = true;
-            }
-            else if (std::fabs(v.x-bb.second.x)<epsilon) {
-                edge.x = bb.second.x;
-                hit = true;
-            }
-
-            if (std::fabs(v.y-bb.first.y)<epsilon) {
-                edge.y = bb.first.y;
-                hit = true;
-            }
-            else if (std::fabs(v.y-bb.second.y)<epsilon) {
-                edge.y = bb.second.y;
-                hit = true;
-            }
-
-            if (hit) {
-                if (last_hit != (size_t)-1) {
-
-                    const size_t old = curmesh.mVerts.size();
-                    size_t cnt = last_hit > n ? size-(last_hit-n) : n-last_hit;
-                    for(size_t a = last_hit, ee = 0; ee <= cnt; a=(a+1)%size, ++ee) {
-                        // hack: this is to fix cases where opening contours are self-intersecting.
-                        // Clipper doesn't produce such polygons, but as soon as we're back in
-                        // our brave new floating-point world, very small distances are consumed
-                        // by the maximum available precision, leading to self-intersecting
-                        // polygons. This fix makes concave windows fail even worse, but
-                        // anyway, fail is fail.
-                        if ((contour[a] - edge).SquareLength() > diag*diag*0.7) {
-                            continue;
-                        }
-                        curmesh.mVerts.push_back(IfcVector3(contour[a].x, contour[a].y, 0.0f));
-                    }
-
-                    if (edge != contour[last_hit]) {
-
-                        IfcVector2 corner = edge;
-
-                        if (std::fabs(contour[last_hit].x-bb.first.x)<epsilon) {
-                            corner.x = bb.first.x;
-                        }
-                        else if (std::fabs(contour[last_hit].x-bb.second.x)<epsilon) {
-                            corner.x = bb.second.x;
-                        }
-
-                        if (std::fabs(contour[last_hit].y-bb.first.y)<epsilon) {
-                            corner.y = bb.first.y;
-                        }
-                        else if (std::fabs(contour[last_hit].y-bb.second.y)<epsilon) {
-                            corner.y = bb.second.y;
-                        }
-
-                        curmesh.mVerts.push_back(IfcVector3(corner.x, corner.y, 0.0f));
-                    }
-                    else if (cnt == 1) {
-                        // avoid degenerate polygons (also known as lines or points)
-                        curmesh.mVerts.erase(curmesh.mVerts.begin()+old,curmesh.mVerts.end());
-                    }
-
-                    if (const size_t d = curmesh.mVerts.size()-old) {
-                        curmesh.mVertcnt.push_back(static_cast<unsigned int>(d));
-                        std::reverse(curmesh.mVerts.rbegin(),curmesh.mVerts.rbegin()+d);
-                    }
-                    if (n == very_first_hit) {
-                        break;
-                    }
-                }
-                else {
-                    very_first_hit = n;
-                }
-
-                last_hit = n;
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void MergeWindowContours (const std::vector<IfcVector2>& a,
-    const std::vector<IfcVector2>& b,
-    ClipperLib::ExPolygons& out)
-{
-    out.clear();
-
-    ClipperLib::Clipper clipper;
-    ClipperLib::Polygon clip;
-
-    for(const IfcVector2& pip : a) {
-        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-    }
-
-    if (ClipperLib::Orientation(clip)) {
-        std::reverse(clip.begin(), clip.end());
-    }
-
-    clipper.AddPolygon(clip, ClipperLib::ptSubject);
-    clip.clear();
-
-    for(const IfcVector2& pip : b) {
-        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-    }
-
-    if (ClipperLib::Orientation(clip)) {
-        std::reverse(clip.begin(), clip.end());
-    }
-
-    clipper.AddPolygon(clip, ClipperLib::ptSubject);
-    clipper.Execute(ClipperLib::ctUnion, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Subtract a from b
-void MakeDisjunctWindowContours (const std::vector<IfcVector2>& a,
-    const std::vector<IfcVector2>& b,
-    ClipperLib::ExPolygons& out)
-{
-    out.clear();
-
-    ClipperLib::Clipper clipper;
-    ClipperLib::Polygon clip;
-
-    for(const IfcVector2& pip : a) {
-        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-    }
-
-    if (ClipperLib::Orientation(clip)) {
-        std::reverse(clip.begin(), clip.end());
-    }
-
-    clipper.AddPolygon(clip, ClipperLib::ptClip);
-    clip.clear();
-
-    for(const IfcVector2& pip : b) {
-        clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-    }
-
-    if (ClipperLib::Orientation(clip)) {
-        std::reverse(clip.begin(), clip.end());
-    }
-
-    clipper.AddPolygon(clip, ClipperLib::ptSubject);
-    clipper.Execute(ClipperLib::ctDifference, out,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
-}
-
-// ------------------------------------------------------------------------------------------------
-void CleanupWindowContour(ProjectedWindowContour& window)
-{
-    std::vector<IfcVector2> scratch;
-    std::vector<IfcVector2>& contour = window.contour;
-
-    ClipperLib::Polygon subject;
-    ClipperLib::Clipper clipper;
-    ClipperLib::ExPolygons clipped;
-
-    for(const IfcVector2& pip : contour) {
-        subject.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-    }
-
-    clipper.AddPolygon(subject,ClipperLib::ptSubject);
-    clipper.Execute(ClipperLib::ctUnion,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
-
-    // This should yield only one polygon or something went wrong
-    if (clipped.size() != 1) {
-
-        // Empty polygon? drop the contour altogether
-        if(clipped.empty()) {
-            IFCImporter::LogError("error during polygon clipping, window contour is degenerate");
-            window.FlagInvalid();
-            return;
-        }
-
-        // Else: take the first only
-        IFCImporter::LogError("error during polygon clipping, window contour is not convex");
-    }
-
-    ExtractVerticesFromClipper(clipped[0].outer, scratch);
-    // Assume the bounding box doesn't change during this operation
-}
-
-// ------------------------------------------------------------------------------------------------
-void CleanupWindowContours(ContourVector& contours)
-{
-    // Use PolyClipper to clean up window contours
-    try {
-        for(ProjectedWindowContour& window : contours) {
-            CleanupWindowContour(window);
-        }
-    }
-    catch (const char* sx) {
-        IFCImporter::LogError("error during polygon clipping, window shape may be wrong: (Clipper: "
-            + std::string(sx) + ")");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh& curmesh)
-{
-    std::vector<IfcVector3> vold;
-    std::vector<unsigned int> iold;
-
-    vold.reserve(curmesh.mVerts.size());
-    iold.reserve(curmesh.mVertcnt.size());
-
-    // Fix the outer contour using polyclipper
-    try {
-
-        ClipperLib::Polygon subject;
-        ClipperLib::Clipper clipper;
-        ClipperLib::ExPolygons clipped;
-
-        ClipperLib::Polygon clip;
-        clip.reserve(contour_flat.size());
-        for(const IfcVector2& pip : contour_flat) {
-            clip.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-        }
-
-        if (!ClipperLib::Orientation(clip)) {
-            std::reverse(clip.begin(), clip.end());
-        }
-
-        // We need to run polyclipper on every single polygon -- we can't run it one all
-        // of them at once or it would merge them all together which would undo all
-        // previous steps
-        subject.reserve(4);
-        size_t index = 0;
-        size_t countdown = 0;
-        for(const IfcVector3& pip : curmesh.mVerts) {
-            if (!countdown) {
-                countdown = curmesh.mVertcnt[index++];
-                if (!countdown) {
-                    continue;
-                }
-            }
-            subject.push_back(ClipperLib::IntPoint(  to_int64(pip.x), to_int64(pip.y) ));
-            if (--countdown == 0) {
-                if (!ClipperLib::Orientation(subject)) {
-                    std::reverse(subject.begin(), subject.end());
-                }
-
-                clipper.AddPolygon(subject,ClipperLib::ptSubject);
-                clipper.AddPolygon(clip,ClipperLib::ptClip);
-
-                clipper.Execute(ClipperLib::ctIntersection,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
-
-                for(const ClipperLib::ExPolygon& ex : clipped) {
-                    iold.push_back(static_cast<unsigned int>(ex.outer.size()));
-                    for(const ClipperLib::IntPoint& point : ex.outer) {
-                        vold.push_back(IfcVector3(
-                            from_int64(point.X),
-                            from_int64(point.Y),
-                            0.0f));
-                    }
-                }
-
-                subject.clear();
-                clipped.clear();
-                clipper.Clear();
-            }
-        }
-    }
-    catch (const char* sx) {
-        IFCImporter::LogError("Ifc: error during polygon clipping, wall contour line may be wrong: (Clipper: "
-            + std::string(sx) + ")");
-
-        return;
-    }
-
-    // swap data arrays
-    std::swap(vold,curmesh.mVerts);
-    std::swap(iold,curmesh.mVertcnt);
-}
-
-typedef std::vector<TempOpening*> OpeningRefs;
-typedef std::vector<OpeningRefs > OpeningRefVector;
-
-typedef std::vector<std::pair<
-    ContourVector::const_iterator,
-    Contour::const_iterator>
-> ContourRefVector;
-
-// ------------------------------------------------------------------------------------------------
-bool BoundingBoxesAdjacent(const BoundingBox& bb, const BoundingBox& ibb)
-{
-    // TODO: I'm pretty sure there is a much more compact way to check this
-    const IfcFloat epsilon = Math::getEpsilon<float>();
-    return  (std::fabs(bb.second.x - ibb.first.x) < epsilon && bb.first.y <= ibb.second.y && bb.second.y >= ibb.first.y) ||
-        (std::fabs(bb.first.x - ibb.second.x) < epsilon && ibb.first.y <= bb.second.y && ibb.second.y >= bb.first.y) ||
-        (std::fabs(bb.second.y - ibb.first.y) < epsilon && bb.first.x <= ibb.second.x && bb.second.x >= ibb.first.x) ||
-        (std::fabs(bb.first.y - ibb.second.y) < epsilon && ibb.first.x <= bb.second.x && ibb.second.x >= bb.first.x);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Check if m0,m1 intersects n0,n1 assuming same ordering of the points in the line segments
-// output the intersection points on n0,n1
-bool IntersectingLineSegments(const IfcVector2& n0, const IfcVector2& n1,
-    const IfcVector2& m0, const IfcVector2& m1,
-    IfcVector2& out0, IfcVector2& out1)
-{
-    const IfcVector2 n0_to_n1 = n1 - n0;
-
-    const IfcVector2 n0_to_m0 = m0 - n0;
-    const IfcVector2 n1_to_m1 = m1 - n1;
-
-    const IfcVector2 n0_to_m1 = m1 - n0;
-
-    const IfcFloat e = 1e-5f;
-    const IfcFloat smalle = 1e-9f;
-
-    static const IfcFloat inf = std::numeric_limits<IfcFloat>::infinity();
-
-    if (!(n0_to_m0.SquareLength() < e*e || std::fabs(n0_to_m0 * n0_to_n1) / (n0_to_m0.Length() * n0_to_n1.Length()) > 1-1e-5 )) {
-        return false;
-    }
-
-    if (!(n1_to_m1.SquareLength() < e*e || std::fabs(n1_to_m1 * n0_to_n1) / (n1_to_m1.Length() * n0_to_n1.Length()) > 1-1e-5 )) {
-        return false;
-    }
-
-    IfcFloat s0;
-    IfcFloat s1;
-
-    // pick the axis with the higher absolute difference so the result
-    // is more accurate. Since we cannot guarantee that the axis with
-    // the higher absolute difference is big enough as to avoid
-    // divisions by zero, the case 0/0 ~ infinity is detected and
-    // handled separately.
-    if(std::fabs(n0_to_n1.x) > std::fabs(n0_to_n1.y)) {
-        s0 = n0_to_m0.x / n0_to_n1.x;
-        s1 = n0_to_m1.x / n0_to_n1.x;
-
-        if (std::fabs(s0) == inf && std::fabs(n0_to_m0.x) < smalle) {
-            s0 = 0.;
-        }
-        if (std::fabs(s1) == inf && std::fabs(n0_to_m1.x) < smalle) {
-            s1 = 0.;
-        }
-    }
-    else {
-        s0 = n0_to_m0.y / n0_to_n1.y;
-        s1 = n0_to_m1.y / n0_to_n1.y;
-
-        if (std::fabs(s0) == inf && std::fabs(n0_to_m0.y) < smalle) {
-            s0 = 0.;
-        }
-        if (std::fabs(s1) == inf && std::fabs(n0_to_m1.y) < smalle) {
-            s1 = 0.;
-        }
-    }
-
-    if (s1 < s0) {
-        std::swap(s1,s0);
-    }
-
-    s0 = std::max(0.0,s0);
-    s1 = std::max(0.0,s1);
-
-    s0 = std::min(1.0,s0);
-    s1 = std::min(1.0,s1);
-
-    if (std::fabs(s1-s0) < e) {
-        return false;
-    }
-
-    out0 = n0 + s0 * n0_to_n1;
-    out1 = n0 + s1 * n0_to_n1;
-
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-void FindAdjacentContours(ContourVector::iterator current, const ContourVector& contours)
-{
-    const IfcFloat sqlen_epsilon = static_cast<IfcFloat>(Math::getEpsilon<float>());
-    const BoundingBox& bb = (*current).bb;
-
-    // What is to be done here is to populate the skip lists for the contour
-    // and to add necessary padding points when needed.
-    SkipList& skiplist = (*current).skiplist;
-
-    // First step to find possible adjacent contours is to check for adjacent bounding
-    // boxes. If the bounding boxes are not adjacent, the contours lines cannot possibly be.
-    for (ContourVector::const_iterator it = contours.begin(), end = contours.end(); it != end; ++it) {
-        if ((*it).IsInvalid()) {
-            continue;
-        }
-
-        // this left here to make clear we also run on the current contour
-        // to check for overlapping contour segments (which can happen due
-        // to projection artifacts).
-        //if(it == current) {
-        //  continue;
-        //}
-
-        const bool is_me = it == current;
-
-        const BoundingBox& ibb = (*it).bb;
-
-        // Assumption: the bounding boxes are pairwise disjoint or identical
-        ai_assert(is_me || !BoundingBoxesOverlapping(bb, ibb));
-
-        if (is_me || BoundingBoxesAdjacent(bb, ibb)) {
-
-            // Now do a each-against-everyone check for intersecting contour
-            // lines. This obviously scales terribly, but in typical real
-            // world Ifc files it will not matter since most windows that
-            // are adjacent to each others are rectangular anyway.
-
-            Contour& ncontour = (*current).contour;
-            const Contour& mcontour = (*it).contour;
-
-            for (size_t n = 0; n < ncontour.size(); ++n) {
-                const IfcVector2 n0 = ncontour[n];
-                const IfcVector2 n1 = ncontour[(n+1) % ncontour.size()];
-
-                for (size_t m = 0, mend = (is_me ? n : mcontour.size()); m < mend; ++m) {
-                    ai_assert(&mcontour != &ncontour || m < n);
-
-                    const IfcVector2 m0 = mcontour[m];
-                    const IfcVector2 m1 = mcontour[(m+1) % mcontour.size()];
-
-                    IfcVector2 isect0, isect1;
-                    if (IntersectingLineSegments(n0,n1, m0, m1, isect0, isect1)) {
-
-                        if ((isect0 - n0).SquareLength() > sqlen_epsilon) {
-                            ++n;
-
-                            ncontour.insert(ncontour.begin() + n, isect0);
-                            skiplist.insert(skiplist.begin() + n, true);
-                        }
-                        else {
-                            skiplist[n] = true;
-                        }
-
-                        if ((isect1 - n1).SquareLength() > sqlen_epsilon) {
-                            ++n;
-
-                            ncontour.insert(ncontour.begin() + n, isect1);
-                            skiplist.insert(skiplist.begin() + n, false);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_FORCE_INLINE bool LikelyBorder(const IfcVector2& vdelta)
-{
-    const IfcFloat dot_point_epsilon = static_cast<IfcFloat>(Math::getEpsilon<float>());
-    return std::fabs(vdelta.x * vdelta.y) < dot_point_epsilon;
-}
-
-// ------------------------------------------------------------------------------------------------
-void FindBorderContours(ContourVector::iterator current)
-{
-    const IfcFloat border_epsilon_upper = static_cast<IfcFloat>(1-1e-4);
-    const IfcFloat border_epsilon_lower = static_cast<IfcFloat>(1e-4);
-
-    bool outer_border = false;
-    bool start_on_outer_border = false;
-
-    SkipList& skiplist = (*current).skiplist;
-    IfcVector2 last_proj_point;
-
-    const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end();
-
-    for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
-        const IfcVector2& proj_point = *cit;
-
-        // Check if this connection is along the outer boundary of the projection
-        // plane. In such a case we better drop it because such 'edges' should
-        // not have any geometry to close them (think of door openings).
-        if (proj_point.x <= border_epsilon_lower || proj_point.x >= border_epsilon_upper ||
-            proj_point.y <= border_epsilon_lower || proj_point.y >= border_epsilon_upper) {
-
-                if (outer_border) {
-                    ai_assert(cit != cbegin);
-                    if (LikelyBorder(proj_point - last_proj_point)) {
-                        skiplist[std::distance(cbegin, cit) - 1] = true;
-                    }
-                }
-                else if (cit == cbegin) {
-                    start_on_outer_border = true;
-                }
-
-                outer_border = true;
-        }
-        else {
-            outer_border = false;
-        }
-
-        last_proj_point = proj_point;
-    }
-
-    // handle last segment
-    if (outer_border && start_on_outer_border) {
-        const IfcVector2& proj_point = *cbegin;
-        if (LikelyBorder(proj_point - last_proj_point)) {
-            skiplist[skiplist.size()-1] = true;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_FORCE_INLINE bool LikelyDiagonal(IfcVector2 vdelta)
-{
-    vdelta.x = std::fabs(vdelta.x);
-    vdelta.y = std::fabs(vdelta.y);
-    return (std::fabs(vdelta.x-vdelta.y) < 0.8 * std::max(vdelta.x, vdelta.y));
-}
-
-// ------------------------------------------------------------------------------------------------
-void FindLikelyCrossingLines(ContourVector::iterator current)
-{
-    SkipList& skiplist = (*current).skiplist;
-    IfcVector2 last_proj_point;
-
-    const Contour::const_iterator cbegin = (*current).contour.begin(), cend = (*current).contour.end();
-    for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
-        const IfcVector2& proj_point = *cit;
-
-        if (cit != cbegin) {
-            IfcVector2 vdelta = proj_point - last_proj_point;
-            if (LikelyDiagonal(vdelta)) {
-                skiplist[std::distance(cbegin, cit) - 1] = true;
-            }
-        }
-
-        last_proj_point = proj_point;
-    }
-
-    // handle last segment
-    if (LikelyDiagonal(*cbegin - last_proj_point)) {
-        skiplist[skiplist.size()-1] = true;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-size_t CloseWindows(ContourVector& contours,
-    const IfcMatrix4& minv,
-    OpeningRefVector& contours_to_openings,
-    TempMesh& curmesh)
-{
-    size_t closed = 0;
-    // For all contour points, check if one of the assigned openings does
-    // already have points assigned to it. In this case, assume this is
-    // the other side of the wall and generate connections between
-    // the two holes in order to close the window.
-
-    // All this gets complicated by the fact that contours may pertain to
-    // multiple openings(due to merging of adjacent or overlapping openings).
-    // The code is based on the assumption that this happens symmetrically
-    // on both sides of the wall. If it doesn't (which would be a bug anyway)
-    // wrong geometry may be generated.
-    for (ContourVector::iterator it = contours.begin(), end = contours.end(); it != end; ++it) {
-        if ((*it).IsInvalid()) {
-            continue;
-        }
-        OpeningRefs& refs = contours_to_openings[std::distance(contours.begin(), it)];
-
-        bool has_other_side = false;
-        for(const TempOpening* opening : refs) {
-            if(!opening->wallPoints.empty()) {
-                has_other_side = true;
-                break;
-            }
-        }
-
-        if (has_other_side) {
-
-            ContourRefVector adjacent_contours;
-
-            // prepare a skiplist for this contour. The skiplist is used to
-            // eliminate unwanted contour lines for adjacent windows and
-            // those bordering the outer frame.
-            (*it).PrepareSkiplist();
-
-            FindAdjacentContours(it, contours);
-            FindBorderContours(it);
-
-            // if the window is the result of a finite union or intersection of rectangles,
-            // there shouldn't be any crossing or diagonal lines in it. Such lines would
-            // be artifacts caused by numerical inaccuracies or other bugs in polyclipper
-            // and our own code. Since rectangular openings are by far the most frequent
-            // case, it is worth filtering for this corner case.
-            if((*it).is_rectangular) {
-                FindLikelyCrossingLines(it);
-            }
-
-            ai_assert((*it).skiplist.size() == (*it).contour.size());
-
-            SkipList::const_iterator skipbegin = (*it).skiplist.begin();
-
-            curmesh.mVerts.reserve(curmesh.mVerts.size() + (*it).contour.size() * 4);
-            curmesh.mVertcnt.reserve(curmesh.mVertcnt.size() + (*it).contour.size());
-
-			bool reverseCountourFaces = false;
-
-            // compare base poly normal and contour normal to detect if we need to reverse the face winding
-			if(curmesh.mVertcnt.size() > 0) {
-				IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.mVerts.data(), curmesh.mVertcnt.front());
-
-				std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
-
-				for(size_t a = 0; a < it->contour.size(); ++a)
-					worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0);
-
-				IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
-
-				reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
-			}
-
-            // XXX this algorithm is really a bit inefficient - both in terms
-            // of constant factor and of asymptotic runtime.
-            std::vector<bool>::const_iterator skipit = skipbegin;
-
-            IfcVector3 start0;
-            IfcVector3 start1;
-
-            const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end();
-
-            bool drop_this_edge = false;
-            for (Contour::const_iterator cit = cbegin; cit != cend; ++cit, drop_this_edge = *skipit++) {
-                const IfcVector2& proj_point = *cit;
-
-                // Locate the closest opposite point. This should be a good heuristic to
-                // connect only the points that are really intended to be connected.
-                IfcFloat best = static_cast<IfcFloat>(1e10);
-                IfcVector3 bestv;
-
-                const IfcVector3 world_point = minv * IfcVector3(proj_point.x,proj_point.y,0.0f);
-
-                for(const TempOpening* opening : refs) {
-                    for(const IfcVector3& other : opening->wallPoints) {
-                        const IfcFloat sqdist = (world_point - other).SquareLength();
-
-                        if (sqdist < best) {
-                            // avoid self-connections
-                            if(sqdist < 1e-5) {
-                                continue;
-                            }
-
-                            bestv = other;
-                            best = sqdist;
-                        }
-                    }
-                }
-
-                if (drop_this_edge) {
-                    curmesh.mVerts.pop_back();
-                    curmesh.mVerts.pop_back();
-                }
-                else {
-                    curmesh.mVerts.push_back(((cit == cbegin) != reverseCountourFaces) ? world_point : bestv);
-                    curmesh.mVerts.push_back(((cit == cbegin) != reverseCountourFaces) ? bestv : world_point);
-
-                    curmesh.mVertcnt.push_back(4);
-                    ++closed;
-                }
-
-                if (cit == cbegin) {
-                    start0 = world_point;
-                    start1 = bestv;
-                    continue;
-                }
-
-                curmesh.mVerts.push_back(reverseCountourFaces ? bestv : world_point);
-                curmesh.mVerts.push_back(reverseCountourFaces ? world_point : bestv);
-
-                if (cit == cend - 1) {
-                    drop_this_edge = *skipit;
-
-                    // Check if the final connection (last to first element) is itself
-                    // a border edge that needs to be dropped.
-                    if (drop_this_edge) {
-                        --closed;
-                        curmesh.mVertcnt.pop_back();
-                        curmesh.mVerts.pop_back();
-                        curmesh.mVerts.pop_back();
-                    }
-                    else {
-                        curmesh.mVerts.push_back(reverseCountourFaces ? start0 : start1);
-                        curmesh.mVerts.push_back(reverseCountourFaces ? start1 : start0);
-                    }
-                }
-            }
-        }
-        else {
-
-            const Contour::const_iterator cbegin = (*it).contour.begin(), cend = (*it).contour.end();
-            for(TempOpening* opening : refs) {
-                ai_assert(opening->wallPoints.empty());
-                opening->wallPoints.reserve(opening->wallPoints.capacity() + (*it).contour.size());
-                for (Contour::const_iterator cit = cbegin; cit != cend; ++cit) {
-
-                    const IfcVector2& proj_point = *cit;
-                    opening->wallPoints.push_back(minv * IfcVector3(proj_point.x,proj_point.y,0.0f));
-                }
-            }
-        }
-    }
-    return closed;
-}
-
-// ------------------------------------------------------------------------------------------------
-void Quadrify(const std::vector< BoundingBox >& bbs, TempMesh& curmesh)
-{
-    ai_assert(curmesh.IsEmpty());
-
-    std::vector<IfcVector2> quads;
-    quads.reserve(bbs.size()*4);
-
-    // sort openings by x and y axis as a preliminiary to the QuadrifyPart() algorithm
-    XYSortedField field;
-    for (std::vector<BoundingBox>::const_iterator it = bbs.begin(); it != bbs.end(); ++it) {
-        if (field.find((*it).first) != field.end()) {
-            IFCImporter::LogWarn("constraint failure during generation of wall openings, results may be faulty");
-        }
-        field[(*it).first] = std::distance(bbs.begin(),it);
-    }
-
-    QuadrifyPart(IfcVector2(),one_vec,field,bbs,quads);
-    ai_assert(!(quads.size() % 4));
-
-    curmesh.mVertcnt.resize(quads.size()/4,4);
-    curmesh.mVerts.reserve(quads.size());
-    for(const IfcVector2& v2 : quads) {
-        curmesh.mVerts.push_back(IfcVector3(v2.x, v2.y, static_cast<IfcFloat>(0.0)));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void Quadrify(const ContourVector& contours, TempMesh& curmesh)
-{
-    std::vector<BoundingBox> bbs;
-    bbs.reserve(contours.size());
-
-    for(const ContourVector::value_type& val : contours) {
-        bbs.push_back(val.bb);
-    }
-
-    Quadrify(bbs, curmesh);
-}
-
-// ------------------------------------------------------------------------------------------------
-IfcMatrix4 ProjectOntoPlane(std::vector<IfcVector2>& out_contour, const TempMesh& in_mesh,
-    bool &ok, IfcVector3& nor_out)
-{
-    const std::vector<IfcVector3>& in_verts = in_mesh.mVerts;
-    ok = true;
-
-    IfcMatrix4 m = IfcMatrix4(DerivePlaneCoordinateSpace(in_mesh, ok, nor_out));
-    if(!ok) {
-        return IfcMatrix4();
-    }
-#ifdef ASSIMP_BUILD_DEBUG
-    const IfcFloat det = m.Determinant();
-    ai_assert(std::fabs(det-1) < 1e-5);
-#endif
-
-    IfcFloat zcoord = 0;
-    out_contour.reserve(in_verts.size());
-
-
-    IfcVector3 vmin, vmax;
-    MinMaxChooser<IfcVector3>()(vmin, vmax);
-
-    // Project all points into the new coordinate system, collect min/max verts on the way
-    for(const IfcVector3& x : in_verts) {
-        const IfcVector3 vv = m * x;
-        // keep Z offset in the plane coordinate system. Ignoring precision issues
-        // (which  are present, of course), this should be the same value for
-        // all polygon vertices (assuming the polygon is planar).
-
-        // XXX this should be guarded, but we somehow need to pick a suitable
-        // epsilon
-        // if(coord != -1.0f) {
-        //  assert(std::fabs(coord - vv.z) < 1e-3f);
-        // }
-        zcoord += vv.z;
-        vmin = std::min(vv, vmin);
-        vmax = std::max(vv, vmax);
-
-        out_contour.push_back(IfcVector2(vv.x,vv.y));
-    }
-
-    zcoord /= in_verts.size();
-
-    // Further improve the projection by mapping the entire working set into
-    // [0,1] range. This gives us a consistent data range so all epsilons
-    // used below can be constants.
-    vmax -= vmin;
-    for(IfcVector2& vv : out_contour) {
-        vv.x  = (vv.x - vmin.x) / vmax.x;
-        vv.y  = (vv.y - vmin.y) / vmax.y;
-
-        // sanity rounding
-        vv = std::max(vv,IfcVector2());
-        vv = std::min(vv,one_vec);
-    }
-
-    IfcMatrix4 mult;
-    mult.a1 = static_cast<IfcFloat>(1.0) / vmax.x;
-    mult.b2 = static_cast<IfcFloat>(1.0) / vmax.y;
-
-    mult.a4 = -vmin.x * mult.a1;
-    mult.b4 = -vmin.y * mult.b2;
-    mult.c4 = -zcoord;
-    m = mult * m;
-
-    // debug code to verify correctness
-#ifdef ASSIMP_BUILD_DEBUG
-    std::vector<IfcVector2> out_contour2;
-    for(const IfcVector3& x : in_verts) {
-        const IfcVector3& vv = m * x;
-
-        out_contour2.push_back(IfcVector2(vv.x,vv.y));
-        ai_assert(std::fabs(vv.z) < vmax.z + 1e-8);
-    }
-
-    for(size_t i = 0; i < out_contour.size(); ++i) {
-        ai_assert((out_contour[i] - out_contour2[i]).SquareLength() < ai_epsilon);
-    }
-#endif
-
-    return m;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool GenerateOpenings(std::vector<TempOpening>& openings,
-    TempMesh& curmesh,
-    bool check_intersection,
-    bool generate_connection_geometry,
-    const IfcVector3& wall_extrusion_axis)
-{
-    OpeningRefVector contours_to_openings;
-
-    // Try to derive a solid base plane within the current surface for use as
-    // working coordinate system. Map all vertices onto this plane and
-    // rescale them to [0,1] range. This normalization means all further
-    // epsilons need not be scaled.
-    bool ok = true;
-
-    std::vector<IfcVector2> contour_flat;
-
-    IfcVector3 nor;
-    const IfcMatrix4 m = ProjectOntoPlane(contour_flat, curmesh,  ok, nor);
-    if(!ok) {
-        return false;
-    }
-
-    // Obtain inverse transform for getting back to world space later on
-    const IfcMatrix4 minv = IfcMatrix4(m).Inverse();
-
-    // Compute bounding boxes for all 2D openings in projection space
-    ContourVector contours;
-
-    std::vector<IfcVector2> temp_contour;
-    std::vector<IfcVector2> temp_contour2;
-
-    IfcVector3 wall_extrusion_axis_norm = wall_extrusion_axis;
-    wall_extrusion_axis_norm.Normalize();
-
-    for(TempOpening& opening :openings) {
-
-        // extrusionDir may be 0,0,0 on case where the opening mesh is not an
-        // IfcExtrudedAreaSolid but something else (i.e. a brep)
-        IfcVector3 norm_extrusion_dir = opening.extrusionDir;
-        if (norm_extrusion_dir.SquareLength() > 1e-10) {
-            norm_extrusion_dir.Normalize();
-        }
-        else {
-            norm_extrusion_dir = IfcVector3();
-        }
-
-        TempMesh* profile_data =  opening.profileMesh.get();
-        bool is_2d_source = false;
-        if (opening.profileMesh2D && norm_extrusion_dir.SquareLength() > 0) {
-            if (std::fabs(norm_extrusion_dir * nor) > 0.9) {
-                profile_data = opening.profileMesh2D.get();
-                is_2d_source = true;
-            }
-        }
-        std::vector<IfcVector3> profile_verts = profile_data->mVerts;
-        std::vector<unsigned int> profile_vertcnts = profile_data->mVertcnt;
-        if(profile_verts.size() <= 2) {
-            continue;
-        }
-
-        // The opening meshes are real 3D meshes so skip over all faces
-        // clearly facing into the wrong direction. Also, we need to check
-        // whether the meshes do actually intersect the base surface plane.
-        // This is done by recording minimum and maximum values for the
-        // d component of the plane equation for all polys and checking
-        // against surface d.
-
-        // Use the sign of the dot product of the face normal to the plane
-        // normal to determine to which side of the difference mesh a
-        // triangle belongs. Get independent bounding boxes and vertex
-        // sets for both sides and take the better one (we can't just
-        // take both - this would likely cause major screwup of vertex
-        // winding, producing errors as late as in CloseWindows()).
-        IfcFloat dmin, dmax;
-        MinMaxChooser<IfcFloat>()(dmin,dmax);
-
-        temp_contour.clear();
-        temp_contour2.clear();
-
-        IfcVector2 vpmin,vpmax;
-        MinMaxChooser<IfcVector2>()(vpmin,vpmax);
-
-        IfcVector2 vpmin2,vpmax2;
-        MinMaxChooser<IfcVector2>()(vpmin2,vpmax2);
-
-        for (size_t f = 0, vi_total = 0, fend = profile_vertcnts.size(); f < fend; ++f) {
-
-            bool side_flag = true;
-            if (!is_2d_source) {
-                const IfcVector3 face_nor = ((profile_verts[vi_total+2] - profile_verts[vi_total]) ^
-                    (profile_verts[vi_total+1] - profile_verts[vi_total])).Normalize();
-
-                const IfcFloat abs_dot_face_nor = std::abs(nor * face_nor);
-                if (abs_dot_face_nor < 0.9) {
-                    vi_total += profile_vertcnts[f];
-                    continue;
-                }
-
-                side_flag = nor * face_nor > 0;
-            }
-
-            for (unsigned int vi = 0, vend = profile_vertcnts[f]; vi < vend; ++vi, ++vi_total) {
-                const IfcVector3& x = profile_verts[vi_total];
-
-                const IfcVector3 v = m * x;
-                IfcVector2 vv(v.x, v.y);
-
-                //if(check_intersection) {
-                    dmin = std::min(dmin, v.z);
-                    dmax = std::max(dmax, v.z);
-                //}
-
-                // sanity rounding
-                vv = std::max(vv,IfcVector2());
-                vv = std::min(vv,one_vec);
-
-                if(side_flag) {
-                    vpmin = std::min(vpmin,vv);
-                    vpmax = std::max(vpmax,vv);
-                }
-                else {
-                    vpmin2 = std::min(vpmin2,vv);
-                    vpmax2 = std::max(vpmax2,vv);
-                }
-
-                std::vector<IfcVector2>& store = side_flag ? temp_contour : temp_contour2;
-
-                if (!IsDuplicateVertex(vv, store)) {
-                    store.push_back(vv);
-                }
-            }
-        }
-
-        if (temp_contour2.size() > 2) {
-            ai_assert(!is_2d_source);
-            const IfcVector2 area = vpmax-vpmin;
-            const IfcVector2 area2 = vpmax2-vpmin2;
-            if (temp_contour.size() <= 2 || std::fabs(area2.x * area2.y) > std::fabs(area.x * area.y)) {
-                temp_contour.swap(temp_contour2);
-
-                vpmax = vpmax2;
-                vpmin = vpmin2;
-            }
-        }
-        if(temp_contour.size() <= 2) {
-            continue;
-        }
-
-        // TODO: This epsilon may be too large
-        const IfcFloat epsilon = std::fabs(dmax-dmin) * 0.0001;
-        if (!is_2d_source && check_intersection && (0 < dmin-epsilon || 0 > dmax+epsilon)) {
-            continue;
-        }
-
-        BoundingBox bb = BoundingBox(vpmin,vpmax);
-
-        // Skip over very small openings - these are likely projection errors
-        // (i.e. they don't belong to this side of the wall)
-        if(std::fabs(vpmax.x - vpmin.x) * std::fabs(vpmax.y - vpmin.y) < static_cast<IfcFloat>(1e-10)) {
-            continue;
-        }
-        std::vector<TempOpening*> joined_openings(1, &opening);
-
-        bool is_rectangle = temp_contour.size() == 4;
-
-        // See if this BB intersects or is in close adjacency to any other BB we have so far.
-        for (ContourVector::iterator it = contours.begin(); it != contours.end(); ) {
-            const BoundingBox& ibb = (*it).bb;
-
-            if (BoundingBoxesOverlapping(ibb, bb)) {
-
-                if (!(*it).is_rectangular) {
-                    is_rectangle = false;
-                }
-
-                const std::vector<IfcVector2>& other = (*it).contour;
-                ClipperLib::ExPolygons poly;
-
-                // First check whether subtracting the old contour (to which ibb belongs)
-                // from the new contour (to which bb belongs) yields an updated bb which
-                // no longer overlaps ibb
-                MakeDisjunctWindowContours(other, temp_contour, poly);
-                if(poly.size() == 1) {
-
-                    const BoundingBox newbb = GetBoundingBox(poly[0].outer);
-                    if (!BoundingBoxesOverlapping(ibb, newbb )) {
-                         // Good guy bounding box
-                         bb = newbb ;
-
-                         ExtractVerticesFromClipper(poly[0].outer, temp_contour, false);
-                         continue;
-                    }
-                }
-
-                // Take these two overlapping contours and try to merge them. If they
-                // overlap (which should not happen, but in fact happens-in-the-real-
-                // world [tm] ), resume using a single contour and a single bounding box.
-                MergeWindowContours(temp_contour, other, poly);
-
-                if (poly.size() > 1) {
-                    return TryAddOpenings_Poly2Tri(openings, curmesh);
-                }
-                else if (poly.size() == 0) {
-                    IFCImporter::LogWarn("ignoring duplicate opening");
-                    temp_contour.clear();
-                    break;
-                }
-                else {
-                    IFCImporter::LogVerboseDebug("merging overlapping openings");
-                    ExtractVerticesFromClipper(poly[0].outer, temp_contour, false);
-
-                    // Generate the union of the bounding boxes
-                    bb.first = std::min(bb.first, ibb.first);
-                    bb.second = std::max(bb.second, ibb.second);
-
-                    // Update contour-to-opening tables accordingly
-                    if (generate_connection_geometry) {
-                        std::vector<TempOpening*>& t = contours_to_openings[std::distance(contours.begin(),it)];
-                        joined_openings.insert(joined_openings.end(), t.begin(), t.end());
-
-                        contours_to_openings.erase(contours_to_openings.begin() + std::distance(contours.begin(),it));
-                    }
-
-                    contours.erase(it);
-
-                    // Restart from scratch because the newly formed BB might now
-                    // overlap any other BB which its constituent BBs didn't
-                    // previously overlap.
-                    it = contours.begin();
-                    continue;
-                }
-            }
-            ++it;
-        }
-
-        if(!temp_contour.empty()) {
-            if (generate_connection_geometry) {
-                contours_to_openings.push_back(std::vector<TempOpening*>(
-                    joined_openings.begin(),
-                    joined_openings.end()));
-            }
-
-            contours.push_back(ProjectedWindowContour(temp_contour, bb, is_rectangle));
-        }
-    }
-
-    // Check if we still have any openings left - it may well be that this is
-    // not the cause, for example if all the opening candidates don't intersect
-    // this surface or point into a direction perpendicular to it.
-    if (contours.empty()) {
-        return false;
-    }
-
-    curmesh.Clear();
-
-    // Generate a base subdivision into quads to accommodate the given list
-    // of window bounding boxes.
-    Quadrify(contours,curmesh);
-
-    // Run a sanity cleanup pass on the window contours to avoid generating
-    // artifacts during the contour generation phase later on.
-    CleanupWindowContours(contours);
-
-    // Previously we reduced all windows to rectangular AABBs in projection
-    // space, now it is time to fill the gaps between the BBs and the real
-    // window openings.
-    InsertWindowContours(contours,openings, curmesh);
-
-    // Clip the entire outer contour of our current result against the real
-    // outer contour of the surface. This is necessary because the result
-    // of the Quadrify() algorithm is always a square area spanning
-    // over [0,1]^2 (i.e. entire projection space).
-    CleanupOuterContour(contour_flat, curmesh);
-
-    // Undo the projection and get back to world (or local object) space
-    for(IfcVector3& v3 : curmesh.mVerts) {
-        v3 = minv * v3;
-    }
-
-    // Generate window caps to connect the symmetric openings on both sides
-    // of the wall.
-    if (generate_connection_geometry) {
-        CloseWindows(contours, minv, contours_to_openings, curmesh);
-    }
-    return true;
-}
-
-std::vector<IfcVector2> GetContourInPlane2D(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
-    IfcVector3 planeNor,IfcFloat planeOffset,
-    IfcVector3 extrusionDir,IfcVector3& wall_extrusion,bool& first,bool& ok) {
-    std::vector<IfcVector2> contour;
-
-    const auto outernor = ((mesh->mVerts[2] - mesh->mVerts[0]) ^ (mesh->mVerts[1] - mesh->mVerts[0])).Normalize();
-    const IfcFloat dot = planeNor * outernor;
-    if (std::fabs(dot) < 1.f - ai_epsilon) {
-        std::stringstream msg;
-        msg << "Skipping: Unaligned opening (" << planeNor.x << ", " << planeNor.y << ", " << planeNor.z << ")";
-        msg << " . ( " << outernor.x << ", " << outernor.y << ", " << outernor.z << ") = " << dot;
-        IFCImporter::LogDebug(msg.str().c_str());
-        ok = false;
-        return contour;
-    }
-
-    const std::vector<IfcVector3>& va = mesh->mVerts;
-    if(va.size() <= 2) {
-        std::stringstream msg;
-        msg << "Skipping: Only " << va.size() << " verticies in opening mesh.";
-        IFCImporter::LogDebug(msg.str().c_str());
-        ok = false;
-        return contour;
-    }
-
-    for(const IfcVector3& xx : mesh->mVerts) {
-        IfcVector3 vv = planeSpace * xx,vv_extr = planeSpace * (xx + extrusionDir);
-
-        const bool is_extruded_side = std::fabs(vv.z - planeOffset) > std::fabs(vv_extr.z - planeOffset);
-        if(first) {
-            first = false;
-            if(dot > 0.f) {
-                wall_extrusion = extrusionDir;
-                if(is_extruded_side) {
-                    wall_extrusion = -wall_extrusion;
-                }
-            }
-        }
-
-        // XXX should not be necessary - but it is. Why? For precision reasons?
-        vv = is_extruded_side ? vv_extr : vv;
-        contour.push_back(IfcVector2(vv.x,vv.y));
-    }
-    ok = true;
-
-    return contour;
-}
-
-const float close{ ai_epsilon };
-
-static bool isClose(IfcVector2 first,IfcVector2 second) {
-    auto diff = (second - first);
-    return (std::fabs(diff.x) < close && std::fabs(diff.y) < close);
-}
-
-static void logSegment(std::pair<IfcVector2,IfcVector2> segment) {
-    std::stringstream msg2;
-    msg2 << " Segment: \n";
-    msg2 << "   " << segment.first.x << " " << segment.first.y << " \n";
-    msg2 << "   " << segment.second.x << " " << segment.second.y << " \n";
-    IFCImporter::LogInfo(msg2.str().c_str());
-}
-
-std::vector<std::vector<IfcVector2>> GetContoursInPlane3D(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
-    IfcFloat planeOffset) {
-
-        {
-            std::stringstream msg;
-            msg << "GetContoursInPlane3D: planeSpace is \n";
-            msg << planeSpace.a1 << " " << planeSpace.a2 << " " << planeSpace.a3 << " " << "\n";
-            msg << planeSpace.b1 << " " << planeSpace.b2 << " " << planeSpace.b3 << " " << "\n";
-            msg << planeSpace.c1 << " " << planeSpace.c2 << " " << planeSpace.c3 << " " << "\n";
-            msg << "\n planeOffset is " << planeOffset;
-            IFCImporter::LogInfo(msg.str().c_str());
-        }
-
-        // we'll put our line segments in here, and then merge them together into contours later
-        std::deque<std::pair<IfcVector2,IfcVector2>> lineSegments;
-
-        // find the lines giving the intersection of the faces with the plane - we'll work in planeSpace throughout.
-        size_t vI0{ 0 }; // vertex index for first vertex in plane
-        for(auto nVertices : mesh->mVertcnt) { // iterate over faces
-            {
-                std::stringstream msg;
-                msg << "GetContoursInPlane3D: face (transformed) is  \n";
-                for(auto vI = vI0; vI < vI0 + nVertices; vI++) {
-                    auto v = planeSpace * mesh->mVerts[vI];
-                    msg << "   " << v.x << " " << v.y << " " << v.z << " " << "\n";
-                }
-                IFCImporter::LogInfo(msg.str().c_str());
-            }
-
-            if(nVertices <= 2) // not a plane, a point or line
-            {
-                std::stringstream msg;
-                msg << "GetContoursInPlane3D: found point or line when expecting plane (only " << nVertices << " vertices)";
-                IFCImporter::LogWarn(msg.str().c_str());
-                vI0 += nVertices;
-                continue;
-            }
-
-            auto v0 = planeSpace * mesh->mVerts[vI0];
-
-            // now calculate intersections between face and plane
-            IfcVector2 firstPoint;
-            bool gotFirstPoint(false);
-
-            if(std::fabs(v0.z - planeOffset) < close) {
-                // first point is on the plane
-                firstPoint.x = v0.x;
-                firstPoint.y = v0.y;
-                gotFirstPoint = true;
-            }
-
-            auto vn = v0;
-            for(auto vI = vI0 + 1; vI < vI0 + nVertices; vI++) {
-                auto vp = vn;
-                vn = planeSpace * mesh->mVerts[vI];
-                IfcVector3 intersection;
-
-                if(std::fabs(vn.z - planeOffset) < close) {
-                    // on the plane
-                    intersection = vn;
-                }
-                else if((vn.z > planeOffset) != (vp.z > planeOffset))
-                {
-                    // passes through the plane
-                    auto vdir = vn - vp;
-                    auto scale = (planeOffset - vp.z) / vdir.z;
-                    intersection = vp + scale * vdir;
-                }
-                else {
-                    // nowhere near - move on
-                    continue;
-                }
-
-                if(!gotFirstPoint) {
-                    if(std::fabs(vp.z - planeOffset) < close) {
-                        // just had a second line along the plane
-                        firstPoint.x = vp.x;
-                        firstPoint.y = vp.y;
-                        IfcVector2 secondPoint(intersection.x,intersection.y);
-                        auto s = std::pair<IfcVector2,IfcVector2>(firstPoint,secondPoint);
-                        logSegment(s);
-                        lineSegments.push_back(s);
-                        // next firstpoint should be this one
-                    }
-                    else {
-                        // store the first intersection point
-                        firstPoint.x = intersection.x;
-                        firstPoint.y = intersection.y;
-                        gotFirstPoint = true;
-                    }
-                }
-                else {
-                    // now got the second point, so store the pair
-                    IfcVector2 secondPoint(intersection.x,intersection.y);
-                    auto s = std::pair<IfcVector2,IfcVector2>(firstPoint,secondPoint);
-                    logSegment(s);
-                    lineSegments.push_back(s);
-
-                    // - note that we don't move onto the next face as a non-convex face can create two or more intersections with a plane
-                    gotFirstPoint = false;
-                }
-            }
-            if(gotFirstPoint) {
-                IFCImporter::LogWarn("GetContoursInPlane3D: odd number of intersections with plane");
-            }
-            vI0 += nVertices;
-        }
-
-        {
-            std::stringstream msg;
-            msg << "GetContoursInPlane3D: found " << lineSegments.size() << " line segments:\n";
-            IFCImporter::LogInfo(msg.str().c_str());
-
-            for(auto& s : lineSegments) {
-                logSegment(s);
-            }
-
-        }
-
-        // now merge contours until we have the best-looking polygons we can
-        std::vector<Contour> contours;
-        while(!lineSegments.empty()) {
-            // start with a polygon and make the best closed contour we can
-            const auto& firstSeg = lineSegments.front();
-            std::deque<IfcVector2> contour{ firstSeg.first, firstSeg.second };
-            lineSegments.pop_front();
-            bool foundNextPoint{ true };
-            bool closedContour{ false };
-            while(foundNextPoint) {
-                foundNextPoint = false;
-                for(auto nextSeg = lineSegments.begin(); nextSeg != lineSegments.end(); nextSeg++) {
-                    // see if we can match up both ends - in which case we've closed the contour
-                    if((isClose(contour.front(),nextSeg->first) && isClose(contour.back(),nextSeg->second)) ||
-                        (isClose(contour.back(),nextSeg->first) && isClose(contour.front(),nextSeg->second))
-                        ) {
-                        lineSegments.erase(nextSeg);
-                        closedContour = true;
-                        break;
-                    }
-
-                    // otherwise, see if we can match up either end
-                    foundNextPoint = true;
-                    if(isClose(contour.front(),nextSeg->first)) {
-                        contour.push_front(nextSeg->second);
-                    }
-                    else if(isClose(contour.front(),nextSeg->second)) {
-                        contour.push_front(nextSeg->first);
-                    }
-                    else if(isClose(contour.back(),nextSeg->first)) {
-                        contour.push_back(nextSeg->second);
-                    }
-                    else if(isClose(contour.back(),nextSeg->second)) {
-                        contour.push_back(nextSeg->first);
-                    }
-                    else {
-                        foundNextPoint = false;
-                    }
-                    if(foundNextPoint) {
-                        lineSegments.erase(nextSeg);
-                        break;
-                    }
-                }
-            }
-
-            if(!closedContour) {
-                IFCImporter::LogWarn("GetContoursInPlane3D: did not close contour");
-            }
-
-            // now add the contour if we can
-            if(contour.size() <= 2) {
-                IFCImporter::LogWarn("GetContoursInPlane3D: discarding line/point contour");
-                continue;
-            }
-            Contour c{};
-            for(auto p : contour)
-            {
-                c.push_back(p);
-            }
-            contours.push_back(c);
-        }
-
-        {
-            std::stringstream msg;
-            msg << "GetContoursInPlane3D: found " << contours.size() << " contours:\n";
-
-            for(auto c : contours) {
-                msg << " Contour: \n";
-                for(auto p : c) {
-                    msg << "   " << p.x << " " << p.y << " \n";
-                }
-            }
-
-            IFCImporter::LogInfo(msg.str().c_str());
-        }
-
-
-        return contours;
-}
-
-std::vector<std::vector<IfcVector2>> GetContoursInPlane(std::shared_ptr<TempMesh> mesh,IfcMatrix3 planeSpace,
-    IfcVector3 planeNor,IfcFloat planeOffset,
-    IfcVector3 extrusionDir,IfcVector3& wall_extrusion,bool& first) {
-
-    if(mesh->mVertcnt.size() == 1)
-    {
-        bool ok;
-        auto contour = GetContourInPlane2D(mesh,planeSpace,planeNor,planeOffset,extrusionDir,wall_extrusion,first,ok);
-        if(ok)
-            return std::vector<std::vector<IfcVector2>> {contour};
-        else
-            return std::vector<std::vector<IfcVector2>> {};
-    }
-    else
-    {
-        return GetContoursInPlane3D(mesh,planeSpace,planeOffset);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-bool TryAddOpenings_Poly2Tri(const std::vector<TempOpening>& openings,
-    TempMesh& curmesh)
-{
-    IFCImporter::LogWarn("forced to use poly2tri fallback method to generate wall openings");
-    std::vector<IfcVector3>& out = curmesh.mVerts;
-
-    bool result = false;
-
-    // Try to derive a solid base plane within the current surface for use as
-    // working coordinate system.
-    bool ok;
-    IfcVector3 nor;
-    const IfcMatrix3 m = DerivePlaneCoordinateSpace(curmesh, ok, nor);
-    if (!ok) {
-        return false;
-    }
-
-    const IfcMatrix3 minv = IfcMatrix3(m).Inverse();
-
-
-    IfcFloat coord = -1;
-
-    std::vector<IfcVector2> contour_flat;
-    contour_flat.reserve(out.size());
-
-    IfcVector2 vmin, vmax;
-    MinMaxChooser<IfcVector2>()(vmin, vmax);
-
-    // Move all points into the new coordinate system, collecting min/max verts on the way
-    for(IfcVector3& x : out) {
-        const IfcVector3 vv = m * x;
-
-        // keep Z offset in the plane coordinate system. Ignoring precision issues
-        // (which  are present, of course), this should be the same value for
-        // all polygon vertices (assuming the polygon is planar).
-
-
-        // XXX this should be guarded, but we somehow need to pick a suitable
-        // epsilon
-        // if(coord != -1.0f) {
-        //  assert(std::fabs(coord - vv.z) < 1e-3f);
-        // }
-
-        coord = vv.z;
-
-        vmin = std::min(IfcVector2(vv.x, vv.y), vmin);
-        vmax = std::max(IfcVector2(vv.x, vv.y), vmax);
-
-        contour_flat.push_back(IfcVector2(vv.x,vv.y));
-    }
-
-    // With the current code in DerivePlaneCoordinateSpace,
-    // vmin,vmax should always be the 0...1 rectangle (+- numeric inaccuracies)
-    // but here we won't rely on this.
-
-    vmax -= vmin;
-
-    // If this happens then the projection must have been wrong.
-    ai_assert(vmax.Length());
-
-    ClipperLib::ExPolygons clipped;
-    ClipperLib::Polygons holes_union;
-
-
-    IfcVector3 wall_extrusion;
-    bool first = true;
-
-    try {
-
-        ClipperLib::Clipper clipper_holes;
-
-        for(const TempOpening& t : openings) {
-            auto contours = GetContoursInPlane(t.profileMesh,m,nor,coord,t.extrusionDir,wall_extrusion,first);
-
-            for(auto& contour : contours) {
-                // scale to clipping space
-                ClipperLib::Polygon hole;
-                for(IfcVector2& pip : contour) {
-                    pip.x = (pip.x - vmin.x) / vmax.x;
-                    pip.y = (pip.y - vmin.y) / vmax.y;
-
-                    hole.push_back(ClipperLib::IntPoint(to_int64(pip.x),to_int64(pip.y)));
-                }
-
-                if(!ClipperLib::Orientation(hole)) {
-                    std::reverse(hole.begin(),hole.end());
-                    //  assert(ClipperLib::Orientation(hole));
-                }
-
-                /*ClipperLib::Polygons pol_temp(1), pol_temp2(1);
-                pol_temp[0] = hole;
-
-                ClipperLib::OffsetPolygons(pol_temp,pol_temp2,5.0);
-                hole = pol_temp2[0];*/
-
-                clipper_holes.AddPolygon(hole,ClipperLib::ptSubject);
-                {
-                    std::stringstream msg;
-                    msg << "- added polygon ";
-                    for(auto elem : hole) {
-                        msg << " (" << elem.X << ", " << elem.Y << ")";
-                    }
-                    IFCImporter::LogDebug(msg.str().c_str());
-                }
-            }
-        }
-
-        clipper_holes.Execute(ClipperLib::ctUnion,holes_union,
-            ClipperLib::pftNonZero,
-            ClipperLib::pftNonZero);
-
-        if (holes_union.empty()) {
-            return false;
-        }
-
-        // Now that we have the big union of all holes, subtract it from the outer contour
-        // to obtain the final polygon to feed into the triangulator.
-        {
-            ClipperLib::Polygon poly;
-            for(IfcVector2& pip : contour_flat) {
-                pip.x  = (pip.x - vmin.x) / vmax.x;
-                pip.y  = (pip.y - vmin.y) / vmax.y;
-
-                poly.push_back(ClipperLib::IntPoint( to_int64(pip.x), to_int64(pip.y) ));
-            }
-
-            if (ClipperLib::Orientation(poly)) {
-                std::reverse(poly.begin(), poly.end());
-            }
-            clipper_holes.Clear();
-            clipper_holes.AddPolygon(poly,ClipperLib::ptSubject);
-
-            clipper_holes.AddPolygons(holes_union,ClipperLib::ptClip);
-            clipper_holes.Execute(ClipperLib::ctDifference,clipped,
-                ClipperLib::pftNonZero,
-                ClipperLib::pftNonZero);
-        }
-
-    }
-    catch (const char* sx) {
-        IFCImporter::LogError("Ifc: error during polygon clipping, skipping openings for this face: (Clipper: "
-            + std::string(sx) + ")");
-
-        return false;
-    }
-
-    std::vector<IfcVector3> old_verts;
-    std::vector<unsigned int> old_vertcnt;
-
-    old_verts.swap(curmesh.mVerts);
-    old_vertcnt.swap(curmesh.mVertcnt);
-
-    std::vector< std::vector<p2t::Point*> > contours;
-    for(ClipperLib::ExPolygon& clip : clipped) {
-
-        contours.clear();
-
-        // Build the outer polygon contour line for feeding into poly2tri
-        std::vector<p2t::Point*> contour_points;
-        for(ClipperLib::IntPoint& point : clip.outer) {
-            contour_points.push_back( new p2t::Point(from_int64(point.X), from_int64(point.Y)) );
-        }
-
-        p2t::CDT* cdt ;
-        try {
-            // Note: this relies on custom modifications in poly2tri to raise runtime_error's
-            // instead if assertions. These failures are not debug only, they can actually
-            // happen in production use if the input data is broken. An assertion would be
-            // inappropriate.
-            cdt = new p2t::CDT(contour_points);
-        }
-        catch(const std::exception& e) {
-            IFCImporter::LogError("Ifc: error during polygon triangulation, skipping some openings: (poly2tri: "
-                + std::string(e.what()) + ")");
-            continue;
-        }
-
-
-        // Build the poly2tri inner contours for all holes we got from ClipperLib
-        for(ClipperLib::Polygon& opening : clip.holes) {
-
-            contours.push_back(std::vector<p2t::Point*>());
-            std::vector<p2t::Point*>& contour = contours.back();
-
-            for(ClipperLib::IntPoint& point : opening) {
-                contour.push_back( new p2t::Point(from_int64(point.X), from_int64(point.Y)) );
-            }
-
-            cdt->AddHole(contour);
-        }
-
-        try {
-            // Note: See above
-            cdt->Triangulate();
-        }
-        catch(const std::exception& e) {
-            IFCImporter::LogError("Ifc: error during polygon triangulation, skipping some openings: (poly2tri: "
-                + std::string(e.what()) + ")");
-            continue;
-        }
-
-        const std::vector<p2t::Triangle*> tris = cdt->GetTriangles();
-
-        // Collect the triangles we just produced
-        for(p2t::Triangle* tri : tris) {
-            for(int i = 0; i < 3; ++i) {
-
-                const IfcVector2 v = IfcVector2(
-                    static_cast<IfcFloat>( tri->GetPoint(i)->x ),
-                    static_cast<IfcFloat>( tri->GetPoint(i)->y )
-                );
-
-                ai_assert(v.x <= 1.0 && v.x >= 0.0 && v.y <= 1.0 && v.y >= 0.0);
-                const IfcVector3 v3 = minv * IfcVector3(vmin.x + v.x * vmax.x, vmin.y + v.y * vmax.y,coord) ;
-
-                curmesh.mVerts.push_back(v3);
-            }
-            curmesh.mVertcnt.push_back(3);
-        }
-
-        result = true;
-    }
-
-    if (!result) {
-        // revert -- it's a shame, but better than nothing
-        curmesh.mVerts.insert(curmesh.mVerts.end(),old_verts.begin(), old_verts.end());
-        curmesh.mVertcnt.insert(curmesh.mVertcnt.end(),old_vertcnt.begin(), old_vertcnt.end());
-
-        IFCImporter::LogError("Ifc: revert, could not generate openings for this wall");
-    }
-
-    return result;
-}
-
-
-    } // ! IFC
-} // ! Assimp
-
-#undef to_int64
-#undef from_int64
-#undef one_vec
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCProfile.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCProfile.cpp
deleted file mode 100644
index aa31124..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCProfile.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCProfile.cpp
- *  @brief Read profile and curves entities from IFC files
- */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "IFCUtil.h"
-
-namespace Assimp {
-namespace IFC {
-
-// ------------------------------------------------------------------------------------------------
-void ProcessPolyLine(const Schema_2x3::IfcPolyline& def, TempMesh& meshout, ConversionData& /*conv*/)
-{
-    // this won't produce a valid mesh, it just spits out a list of vertices
-    IfcVector3 t;
-    for(const Schema_2x3::IfcCartesianPoint& cp : def.Points) {
-        ConvertCartesianPoint(t,cp);
-        meshout.mVerts.push_back(t);
-    }
-    meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
-}
-
-// ------------------------------------------------------------------------------------------------
-bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv)
-{
-    std::unique_ptr<const Curve> cv(Curve::Convert(curve,conv));
-    if (!cv) {
-        IFCImporter::LogWarn("skipping unknown IfcCurve entity, type is ", curve.GetClassName());
-        return false;
-    }
-
-    // we must have a bounded curve at this point
-    if (const BoundedCurve* bc = dynamic_cast<const BoundedCurve*>(cv.get())) {
-        try {
-            bc->SampleDiscrete(meshout);
-        }
-        catch(const  CurveError& cv) {
-            IFCImporter::LogError(cv.mStr, " (error occurred while processing curve)");
-            return false;
-        }
-        meshout.mVertcnt.push_back(static_cast<unsigned int>(meshout.mVerts.size()));
-        return true;
-    }
-
-    IFCImporter::LogError("cannot use unbounded curve as profile");
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessClosedProfile(const Schema_2x3::IfcArbitraryClosedProfileDef& def, TempMesh& meshout, ConversionData& conv)
-{
-    ProcessCurve(def.OuterCurve,meshout,conv);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessOpenProfile(const Schema_2x3::IfcArbitraryOpenProfileDef& def, TempMesh& meshout, ConversionData& conv)
-{
-    ProcessCurve(def.Curve,meshout,conv);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ProcessParametrizedProfile(const Schema_2x3::IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& conv)
-{
-    if(const Schema_2x3::IfcRectangleProfileDef* const cprofile = def.ToPtr<Schema_2x3::IfcRectangleProfileDef>()) {
-        const IfcFloat x = cprofile->XDim*0.5f, y = cprofile->YDim*0.5f;
-
-        meshout.mVerts.reserve(meshout.mVerts.size()+4);
-        meshout.mVerts.push_back( IfcVector3( x, y, 0.f ));
-        meshout.mVerts.push_back( IfcVector3(-x, y, 0.f ));
-        meshout.mVerts.push_back( IfcVector3(-x,-y, 0.f ));
-        meshout.mVerts.push_back( IfcVector3( x,-y, 0.f ));
-        meshout.mVertcnt.push_back(4);
-    }
-    else if( const Schema_2x3::IfcCircleProfileDef* const circle = def.ToPtr<Schema_2x3::IfcCircleProfileDef>()) {
-        if(def.ToPtr<Schema_2x3::IfcCircleHollowProfileDef>()) {
-            // TODO
-        }
-        const size_t segments = conv.settings.cylindricalTessellation;
-        const IfcFloat delta = AI_MATH_TWO_PI_F/segments, radius = circle->Radius;
-
-        meshout.mVerts.reserve(segments);
-
-        IfcFloat angle = 0.f;
-        for(size_t i = 0; i < segments; ++i, angle += delta) {
-            meshout.mVerts.push_back( IfcVector3( std::cos(angle)*radius, std::sin(angle)*radius, 0.f ));
-        }
-
-        meshout.mVertcnt.push_back(static_cast<unsigned int>(segments));
-    }
-    else if( const Schema_2x3::IfcIShapeProfileDef* const ishape = def.ToPtr<Schema_2x3::IfcIShapeProfileDef>()) {
-        // construct simplified IBeam shape
-        const IfcFloat offset = (ishape->OverallWidth - ishape->WebThickness) / 2;
-        const IfcFloat inner_height = ishape->OverallDepth - ishape->FlangeThickness * 2;
-
-        meshout.mVerts.reserve(12);
-        meshout.mVerts.push_back(IfcVector3(0,0,0));
-        meshout.mVerts.push_back(IfcVector3(0,ishape->FlangeThickness,0));
-        meshout.mVerts.push_back(IfcVector3(offset,ishape->FlangeThickness,0));
-        meshout.mVerts.push_back(IfcVector3(offset,ishape->FlangeThickness + inner_height,0));
-        meshout.mVerts.push_back(IfcVector3(0,ishape->FlangeThickness + inner_height,0));
-        meshout.mVerts.push_back(IfcVector3(0,ishape->OverallDepth,0));
-        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,ishape->OverallDepth,0));
-        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,ishape->FlangeThickness + inner_height,0));
-        meshout.mVerts.push_back(IfcVector3(offset+ishape->WebThickness,ishape->FlangeThickness + inner_height,0));
-        meshout.mVerts.push_back(IfcVector3(offset+ishape->WebThickness,ishape->FlangeThickness,0));
-        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,ishape->FlangeThickness,0));
-        meshout.mVerts.push_back(IfcVector3(ishape->OverallWidth,0,0));
-
-        meshout.mVertcnt.push_back(12);
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcParameterizedProfileDef entity, type is ", def.GetClassName());
-        return;
-    }
-
-    IfcMatrix4 trafo;
-    ConvertAxisPlacement(trafo, *def.Position);
-    meshout.Transform(trafo);
-}
-
-// ------------------------------------------------------------------------------------------------
-bool ProcessProfile(const Schema_2x3::IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv)
-{
-    if(const Schema_2x3::IfcArbitraryClosedProfileDef* const cprofile = prof.ToPtr<Schema_2x3::IfcArbitraryClosedProfileDef>()) {
-        ProcessClosedProfile(*cprofile,meshout,conv);
-    }
-    else if(const Schema_2x3::IfcArbitraryOpenProfileDef* const copen = prof.ToPtr<Schema_2x3::IfcArbitraryOpenProfileDef>()) {
-        ProcessOpenProfile(*copen,meshout,conv);
-    }
-    else if(const Schema_2x3::IfcParameterizedProfileDef* const cparam = prof.ToPtr<Schema_2x3::IfcParameterizedProfileDef>()) {
-        ProcessParametrizedProfile(*cparam,meshout,conv);
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcProfileDef entity, type is ", prof.GetClassName());
-        return false;
-    }
-    meshout.RemoveAdjacentDuplicates();
-    if (!meshout.mVertcnt.size() || meshout.mVertcnt.front() <= 1) {
-        return false;
-    }
-    return true;
-}
-
-} // ! IFC
-} // ! Assimp
-
-#endif // ASSIMP_BUILD_NO_IFC_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
deleted file mode 100644
index a6f7ae3..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
+++ /dev/null
@@ -1,3177 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
-
-//#include "AssimpPCH.h"
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "IFCReaderGen_2x3.h"
-
-#if _MSC_VER
-#    pragma warning(push)
-#    pragma warning(disable : 4702)
-#endif // _MSC_VER
-
-namespace Assimp {
-
-using namespace ::Assimp::IFC;
-using namespace ::Assimp::IFC::Schema_2x3;
-
-namespace {
-	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
-
-    static const SchemaEntry schema_raw_2x3[] =  {
-		SchemaEntry("ifcstairtypeenum",nullptr )
-,		SchemaEntry("ifcspacetypeenum",nullptr )
-,		SchemaEntry("ifcwalltypeenum",nullptr )
-,		SchemaEntry("ifcmonthinyearnumber",nullptr )
-,		SchemaEntry("ifcheatfluxdensitymeasure",nullptr )
-,		SchemaEntry("ifckinematicviscositymeasure",nullptr )
-,		SchemaEntry("ifcsequenceenum",nullptr )
-,		SchemaEntry("ifcairtoairheatrecoverytypeenum",nullptr )
-,		SchemaEntry("ifcactorselect",nullptr )
-,		SchemaEntry("ifctransformertypeenum",nullptr )
-,		SchemaEntry("ifcunitaryequipmenttypeenum",nullptr )
-,		SchemaEntry("ifcelectricflowstoragedevicetypeenum",nullptr )
-,		SchemaEntry("ifcenergysequenceenum",nullptr )
-,		SchemaEntry("ifcworkcontroltypeenum",nullptr )
-,		SchemaEntry("ifccurvaturemeasure",nullptr )
-,		SchemaEntry("ifcparametervalue",nullptr )
-,		SchemaEntry("ifcappliedvalueselect",nullptr )
-,		SchemaEntry("ifcwarpingconstantmeasure",nullptr )
-,		SchemaEntry("ifcarithmeticoperatorenum",nullptr )
-,		SchemaEntry("ifclinearforcemeasure",nullptr )
-,		SchemaEntry("ifcwindowpanelpositionenum",nullptr )
-,		SchemaEntry("ifcflowmetertypeenum",nullptr )
-,		SchemaEntry("ifcrampflighttypeenum",nullptr )
-,		SchemaEntry("ifcspecularhighlightselect",nullptr )
-,		SchemaEntry("ifcactiontypeenum",nullptr )
-,		SchemaEntry("ifcgeometricprojectionenum",nullptr )
-,		SchemaEntry("ifctimeseriesdatatypeenum",nullptr )
-,		SchemaEntry("ifcmagneticfluxmeasure",nullptr )
-,		SchemaEntry("ifcobjecttypeenum",nullptr )
-,		SchemaEntry("ifcdataoriginenum",nullptr )
-,		SchemaEntry("ifcmassdensitymeasure",nullptr )
-,		SchemaEntry("ifclightfixturetypeenum",nullptr )
-,		SchemaEntry("ifcservicelifetypeenum",nullptr )
-,		SchemaEntry("ifcelectricvoltagemeasure",nullptr )
-,		SchemaEntry("ifcheatingvaluemeasure",nullptr )
-,		SchemaEntry("ifcpresentabletext",nullptr )
-,		SchemaEntry("ifcaheadorbehind",nullptr )
-,		SchemaEntry("ifcsimplevalue",nullptr )
-,		SchemaEntry("ifcsensortypeenum",nullptr )
-,		SchemaEntry("ifcderivedunitenum",nullptr )
-,		SchemaEntry("ifcsizeselect",nullptr )
-,		SchemaEntry("ifctransportelementtypeenum",nullptr )
-,		SchemaEntry("ifcinventorytypeenum",nullptr )
-,		SchemaEntry("ifctextdecoration",nullptr )
-,		SchemaEntry("ifcdirectionsenseenum",nullptr )
-,		SchemaEntry("ifcductfittingtypeenum",nullptr )
-,		SchemaEntry("ifcdocumentstatusenum",nullptr )
-,		SchemaEntry("ifcslabtypeenum",nullptr )
-,		SchemaEntry("ifcdoorstyleconstructionenum",nullptr )
-,		SchemaEntry("ifcvolumemeasure",nullptr )
-,		SchemaEntry("ifcinductancemeasure",nullptr )
-,		SchemaEntry("ifccurtainwalltypeenum",nullptr )
-,		SchemaEntry("ifcsiunitname",nullptr )
-,		SchemaEntry("ifcspecularexponent",nullptr )
-,		SchemaEntry("ifcsoundpressuremeasure",nullptr )
-,		SchemaEntry("ifcanalysistheorytypeenum",nullptr )
-,		SchemaEntry("ifcgasterminaltypeenum",nullptr )
-,		SchemaEntry("ifcyearnumber",nullptr )
-,		SchemaEntry("ifcmodulusofelasticitymeasure",nullptr )
-,		SchemaEntry("ifcchangeactionenum",nullptr )
-,		SchemaEntry("ifcdampertypeenum",nullptr )
-,		SchemaEntry("ifcevaporatortypeenum",nullptr )
-,		SchemaEntry("ifcionconcentrationmeasure",nullptr )
-,		SchemaEntry("ifcductsegmenttypeenum",nullptr )
-,		SchemaEntry("ifcprotectivedevicetypeenum",nullptr )
-,		SchemaEntry("ifcabsorbeddosemeasure",nullptr )
-,		SchemaEntry("ifcmassperlengthmeasure",nullptr )
-,		SchemaEntry("ifctextfontname",nullptr )
-,		SchemaEntry("ifcorientationselect",nullptr )
-,		SchemaEntry("ifcilluminancemeasure",nullptr )
-,		SchemaEntry("ifcfiresuppressionterminaltypeenum",nullptr )
-,		SchemaEntry("ifcfontstyle",nullptr )
-,		SchemaEntry("ifcmomentofinertiameasure",nullptr )
-,		SchemaEntry("ifcmodulusofsubgradereactionmeasure",nullptr )
-,		SchemaEntry("ifccomplexnumber",nullptr )
-,		SchemaEntry("ifchumidifiertypeenum",nullptr )
-,		SchemaEntry("ifcpresentationstyleselect",nullptr )
-,		SchemaEntry("ifcthermaltransmittancemeasure",nullptr )
-,		SchemaEntry("ifcribplatedirectionenum",nullptr )
-,		SchemaEntry("ifcclassificationnotationselect",nullptr )
-,		SchemaEntry("ifcminuteinhour",nullptr )
-,		SchemaEntry("ifcinternalorexternalenum",nullptr )
-,		SchemaEntry("ifcrotationalfrequencymeasure",nullptr )
-,		SchemaEntry("ifcsanitaryterminaltypeenum",nullptr )
-,		SchemaEntry("ifcsymbolstyleselect",nullptr )
-,		SchemaEntry("ifcelementcompositionenum",nullptr )
-,		SchemaEntry("ifctextpath",nullptr )
-,		SchemaEntry("ifcpowermeasure",nullptr )
-,		SchemaEntry("ifcsurfacestyleelementselect",nullptr )
-,		SchemaEntry("ifcresourceconsumptionenum",nullptr )
-,		SchemaEntry("ifcelectriccapacitancemeasure",nullptr )
-,		SchemaEntry("ifclayersetdirectionenum",nullptr )
-,		SchemaEntry("ifcrailingtypeenum",nullptr )
-,		SchemaEntry("ifcobjectiveenum",nullptr )
-,		SchemaEntry("ifcdocumentselect",nullptr )
-,		SchemaEntry("ifcmodulusoflinearsubgradereactionmeasure",nullptr )
-,		SchemaEntry("ifcthermaladmittancemeasure",nullptr )
-,		SchemaEntry("ifctransitioncode",nullptr )
-,		SchemaEntry("ifcconnectiontypeenum",nullptr )
-,		SchemaEntry("ifcmonetarymeasure",nullptr )
-,		SchemaEntry("ifcstackterminaltypeenum",nullptr )
-,		SchemaEntry("ifccolour",nullptr )
-,		SchemaEntry("ifctext",nullptr )
-,		SchemaEntry("ifccontextdependentmeasure",nullptr )
-,		SchemaEntry("ifcthermalconductivitymeasure",nullptr )
-,		SchemaEntry("ifcprojectedortruelengthenum",nullptr )
-,		SchemaEntry("ifcpressuremeasure",nullptr )
-,		SchemaEntry("ifcmoisturediffusivitymeasure",nullptr )
-,		SchemaEntry("ifcbooleanoperator",nullptr )
-,		SchemaEntry("ifcpropertysourceenum",nullptr )
-,		SchemaEntry("ifctimestamp",nullptr )
-,		SchemaEntry("ifcmaterialselect",nullptr )
-,		SchemaEntry("ifcgloballyuniqueid",nullptr )
-,		SchemaEntry("ifcreflectancemethodenum",nullptr )
-,		SchemaEntry("ifcvaporpermeabilitymeasure",nullptr )
-,		SchemaEntry("ifctimeseriesscheduletypeenum",nullptr )
-,		SchemaEntry("ifclinearmomentmeasure",nullptr )
-,		SchemaEntry("ifcgeometricsetselect",nullptr )
-,		SchemaEntry("ifcsectionmodulusmeasure",nullptr )
-,		SchemaEntry("ifcbsplinecurveform",nullptr )
-,		SchemaEntry("ifcdimensionextentusage",nullptr )
-,		SchemaEntry("ifcthermalexpansioncoefficientmeasure",nullptr )
-,		SchemaEntry("ifchourinday",nullptr )
-,		SchemaEntry("ifclinearvelocitymeasure",nullptr )
-,		SchemaEntry("ifctorquemeasure",nullptr )
-,		SchemaEntry("ifctemperaturegradientmeasure",nullptr )
-,		SchemaEntry("ifcfillstyleselect",nullptr )
-,		SchemaEntry("ifcelectricchargemeasure",nullptr )
-,		SchemaEntry("ifcheatexchangertypeenum",nullptr )
-,		SchemaEntry("ifcelectriccurrentenum",nullptr )
-,		SchemaEntry("ifcdaylightsavinghour",nullptr )
-,		SchemaEntry("ifcshell",nullptr )
-,		SchemaEntry("ifcdoseequivalentmeasure",nullptr )
-,		SchemaEntry("ifcprojectordertypeenum",nullptr )
-,		SchemaEntry("ifcderivedmeasurevalue",nullptr )
-,		SchemaEntry("ifclightdistributioncurveenum",nullptr )
-,		SchemaEntry("ifcwarpingmomentmeasure",nullptr )
-,		SchemaEntry("ifcmembertypeenum",nullptr )
-,		SchemaEntry("ifcsoundpowermeasure",nullptr )
-,		SchemaEntry("ifctextalignment",nullptr )
-,		SchemaEntry("ifccurveoredgecurve",nullptr )
-,		SchemaEntry("ifcmassflowratemeasure",nullptr )
-,		SchemaEntry("ifcisothermalmoisturecapacitymeasure",nullptr )
-,		SchemaEntry("ifccsgselect",nullptr )
-,		SchemaEntry("ifccoolingtowertypeenum",nullptr )
-,		SchemaEntry("ifcmassmeasure",nullptr )
-,		SchemaEntry("ifcpileconstructionenum",nullptr )
-,		SchemaEntry("ifcdoorstyleoperationenum",nullptr )
-,		SchemaEntry("ifcflowdirectionenum",nullptr )
-,		SchemaEntry("ifcthermalloadsourceenum",nullptr )
-,		SchemaEntry("ifclengthmeasure",nullptr )
-,		SchemaEntry("ifcconstraintenum",nullptr )
-,		SchemaEntry("ifcaxis2placement",nullptr )
-,		SchemaEntry("ifcloadgrouptypeenum",nullptr )
-,		SchemaEntry("ifcvalue",nullptr )
-,		SchemaEntry("ifcreinforcingbarsurfaceenum",nullptr )
-,		SchemaEntry("ifcprojectorderrecordtypeenum",nullptr )
-,		SchemaEntry("ifcdatetimeselect",nullptr )
-,		SchemaEntry("ifcstructuralsurfacetypeenum",nullptr )
-,		SchemaEntry("ifcpermeablecoveringoperationenum",nullptr )
-,		SchemaEntry("ifcfontweight",nullptr )
-,		SchemaEntry("ifcphmeasure",nullptr )
-,		SchemaEntry("ifcdescriptivemeasure",nullptr )
-,		SchemaEntry("ifccurvestylefontselect",nullptr )
-,		SchemaEntry("ifcunit",nullptr )
-,		SchemaEntry("ifchatchlinedistanceselect",nullptr )
-,		SchemaEntry("ifctextstyleselect",nullptr )
-,		SchemaEntry("ifcmetricvalueselect",nullptr )
-,		SchemaEntry("ifcvectorordirection",nullptr )
-,		SchemaEntry("ifcassemblyplaceenum",nullptr )
-,		SchemaEntry("ifcairterminaltypeenum",nullptr )
-,		SchemaEntry("ifccoveringtypeenum",nullptr )
-,		SchemaEntry("ifcplanarforcemeasure",nullptr )
-,		SchemaEntry("ifcvalvetypeenum",nullptr )
-,		SchemaEntry("ifcalarmtypeenum",nullptr )
-,		SchemaEntry("ifcdynamicviscositymeasure",nullptr )
-,		SchemaEntry("ifccurrencyenum",nullptr )
-,		SchemaEntry("ifcmodulusofrotationalsubgradereactionmeasure",nullptr )
-,		SchemaEntry("ifccablecarrierfittingtypeenum",nullptr )
-,		SchemaEntry("ifcboolean",nullptr )
-,		SchemaEntry("ifcactionsourcetypeenum",nullptr )
-,		SchemaEntry("ifcstructuralactivityassignmentselect",nullptr )
-,		SchemaEntry("ifcdistributionchamberelementtypeenum",nullptr )
-,		SchemaEntry("ifcevaporativecoolertypeenum",nullptr )
-,		SchemaEntry("ifcmagneticfluxdensitymeasure",nullptr )
-,		SchemaEntry("ifclightdistributiondatasourceselect",nullptr )
-,		SchemaEntry("ifctubebundletypeenum",nullptr )
-,		SchemaEntry("ifcaccelerationmeasure",nullptr )
-,		SchemaEntry("ifcboilertypeenum",nullptr )
-,		SchemaEntry("ifcramptypeenum",nullptr )
-,		SchemaEntry("ifcluminousintensitydistributionmeasure",nullptr )
-,		SchemaEntry("ifctrimmingpreference",nullptr )
-,		SchemaEntry("ifcspecificheatcapacitymeasure",nullptr )
-,		SchemaEntry("ifcamountofsubstancemeasure",nullptr )
-,		SchemaEntry("ifcroleenum",nullptr )
-,		SchemaEntry("ifcdocumentconfidentialityenum",nullptr )
-,		SchemaEntry("ifcfrequencymeasure",nullptr )
-,		SchemaEntry("ifcsectiontypeenum",nullptr )
-,		SchemaEntry("ifcelementassemblytypeenum",nullptr )
-,		SchemaEntry("ifcfootingtypeenum",nullptr )
-,		SchemaEntry("ifclayereditem",nullptr )
-,		SchemaEntry("ifccablesegmenttypeenum",nullptr )
-,		SchemaEntry("ifcdefinedsymbolselect",nullptr )
-,		SchemaEntry("ifcbuildingelementproxytypeenum",nullptr )
-,		SchemaEntry("ifcelectricgeneratortypeenum",nullptr )
-,		SchemaEntry("ifcrotationalstiffnessmeasure",nullptr )
-,		SchemaEntry("ifcspaceheatertypeenum",nullptr )
-,		SchemaEntry("ifcareameasure",nullptr )
-,		SchemaEntry("ifclabel",nullptr )
-,		SchemaEntry("ifccostscheduletypeenum",nullptr )
-,		SchemaEntry("ifcswitchingdevicetypeenum",nullptr )
-,		SchemaEntry("ifcelectrictimecontroltypeenum",nullptr )
-,		SchemaEntry("ifcfiltertypeenum",nullptr )
-,		SchemaEntry("ifcpositivelengthmeasure",nullptr )
-,		SchemaEntry("ifcnullstyle",nullptr )
-,		SchemaEntry("ifcconditioncriterionselect",nullptr )
-,		SchemaEntry("ifcshearmodulusmeasure",nullptr )
-,		SchemaEntry("ifcnormalisedratiomeasure",nullptr )
-,		SchemaEntry("ifcdoorpaneloperationenum",nullptr )
-,		SchemaEntry("ifcpointorvertexpoint",nullptr )
-,		SchemaEntry("ifcrooftypeenum",nullptr )
-,		SchemaEntry("ifccountmeasure",nullptr )
-,		SchemaEntry("ifcelectricconductancemeasure",nullptr )
-,		SchemaEntry("ifcproceduretypeenum",nullptr )
-,		SchemaEntry("ifcflowinstrumenttypeenum",nullptr )
-,		SchemaEntry("ifcelectricmotortypeenum",nullptr )
-,		SchemaEntry("ifcsurfaceside",nullptr )
-,		SchemaEntry("ifcstructuralcurvetypeenum",nullptr )
-,		SchemaEntry("ifccondensertypeenum",nullptr )
-,		SchemaEntry("ifclinearstiffnessmeasure",nullptr )
-,		SchemaEntry("ifcunitenum",nullptr )
-,		SchemaEntry("ifcoccupanttypeenum",nullptr )
-,		SchemaEntry("ifcthermalloadtypeenum",nullptr )
-,		SchemaEntry("ifcreinforcingbarroleenum",nullptr )
-,		SchemaEntry("ifcbenchmarkenum",nullptr )
-,		SchemaEntry("ifcpositiveplaneanglemeasure",nullptr )
-,		SchemaEntry("ifctexttransformation",nullptr )
-,		SchemaEntry("ifcdraughtingcalloutelement",nullptr )
-,		SchemaEntry("ifcratiomeasure",nullptr )
-,		SchemaEntry("ifcsolidanglemeasure",nullptr )
-,		SchemaEntry("ifcpipesegmenttypeenum",nullptr )
-,		SchemaEntry("ifccablecarriersegmenttypeenum",nullptr )
-,		SchemaEntry("ifccolourorfactor",nullptr )
-,		SchemaEntry("ifcidentifier",nullptr )
-,		SchemaEntry("ifctendontypeenum",nullptr )
-,		SchemaEntry("ifccontrollertypeenum",nullptr )
-,		SchemaEntry("ifcradioactivitymeasure",nullptr )
-,		SchemaEntry("ifctimemeasure",nullptr )
-,		SchemaEntry("ifcpumptypeenum",nullptr )
-,		SchemaEntry("ifcelectricheatertypeenum",nullptr )
-,		SchemaEntry("ifcbeamtypeenum",nullptr )
-,		SchemaEntry("ifcstateenum",nullptr )
-,		SchemaEntry("ifcsiprefix",nullptr )
-,		SchemaEntry("ifcnumericmeasure",nullptr )
-,		SchemaEntry("ifcoutlettypeenum",nullptr )
-,		SchemaEntry("ifccompoundplaneanglemeasure",nullptr )
-,		SchemaEntry("ifcservicelifefactortypeenum",nullptr )
-,		SchemaEntry("ifclogicaloperatorenum",nullptr )
-,		SchemaEntry("ifcbooleanoperand",nullptr )
-,		SchemaEntry("ifcobjectreferenceselect",nullptr )
-,		SchemaEntry("ifccooledbeamtypeenum",nullptr )
-,		SchemaEntry("ifcductsilencertypeenum",nullptr )
-,		SchemaEntry("ifcsectionalareaintegralmeasure",nullptr )
-,		SchemaEntry("ifcfontvariant",nullptr )
-,		SchemaEntry("ifcvolumetricflowratemeasure",nullptr )
-,		SchemaEntry("ifcplatetypeenum",nullptr )
-,		SchemaEntry("ifcenvironmentalimpactcategoryenum",nullptr )
-,		SchemaEntry("ifcvibrationisolatortypeenum",nullptr )
-,		SchemaEntry("ifcthermodynamictemperaturemeasure",nullptr )
-,		SchemaEntry("ifcrotationalmassmeasure",nullptr )
-,		SchemaEntry("ifcsecondinminute",nullptr )
-,		SchemaEntry("ifcdayinmonthnumber",nullptr )
-,		SchemaEntry("ifcdimensioncount",nullptr )
-,		SchemaEntry("ifcwindowstyleoperationenum",nullptr )
-,		SchemaEntry("ifcthermalresistancemeasure",nullptr )
-,		SchemaEntry("ifcmeasurevalue",nullptr )
-,		SchemaEntry("ifcwindowpaneloperationenum",nullptr )
-,		SchemaEntry("ifcchillertypeenum",nullptr )
-,		SchemaEntry("ifcpositiveratiomeasure",nullptr )
-,		SchemaEntry("ifcinteger",nullptr )
-,		SchemaEntry("ifclogical",nullptr )
-,		SchemaEntry("ifcjunctionboxtypeenum",nullptr )
-,		SchemaEntry("ifcaddresstypeenum",nullptr )
-,		SchemaEntry("ifcwasteterminaltypeenum",nullptr )
-,		SchemaEntry("ifctrimmingselect",nullptr )
-,		SchemaEntry("ifclightemissionsourceenum",nullptr )
-,		SchemaEntry("ifcsoundscaleenum",nullptr )
-,		SchemaEntry("ifcluminousfluxmeasure",nullptr )
-,		SchemaEntry("ifcelectricresistancemeasure",nullptr )
-,		SchemaEntry("ifcintegercountratemeasure",nullptr )
-,		SchemaEntry("ifcphysicalorvirtualenum",nullptr )
-,		SchemaEntry("ifcmolecularweightmeasure",nullptr )
-,		SchemaEntry("ifcprofiletypeenum",nullptr )
-,		SchemaEntry("ifcboxalignment",nullptr )
-,		SchemaEntry("ifcglobalorlocalenum",nullptr )
-,		SchemaEntry("ifcspecularroughness",nullptr )
-,		SchemaEntry("ifclamptypeenum",nullptr )
-,		SchemaEntry("ifcpiletypeenum",nullptr )
-,		SchemaEntry("ifcelectriccurrentmeasure",nullptr )
-,		SchemaEntry("ifcfantypeenum",nullptr )
-,		SchemaEntry("ifcsurfaceorfacesurface",nullptr )
-,		SchemaEntry("ifcpipefittingtypeenum",nullptr )
-,		SchemaEntry("ifctanktypeenum",nullptr )
-,		SchemaEntry("ifccurvefontorscaledcurvefontselect",nullptr )
-,		SchemaEntry("ifcwindowstyleconstructionenum",nullptr )
-,		SchemaEntry("ifcairterminalboxtypeenum",nullptr )
-,		SchemaEntry("ifcstairflighttypeenum",nullptr )
-,		SchemaEntry("ifcluminousintensitymeasure",nullptr )
-,		SchemaEntry("ifcmotorconnectiontypeenum",nullptr )
-,		SchemaEntry("ifcplaneanglemeasure",nullptr )
-,		SchemaEntry("ifcactuatortypeenum",nullptr )
-,		SchemaEntry("ifccolumntypeenum",nullptr )
-,		SchemaEntry("ifctextfontselect",nullptr )
-,		SchemaEntry("ifcdoorpanelpositionenum",nullptr )
-,		SchemaEntry("ifccoiltypeenum",nullptr )
-,		SchemaEntry("ifcangularvelocitymeasure",nullptr )
-,		SchemaEntry("ifcanalysismodeltypeenum",nullptr )
-,		SchemaEntry("ifclibraryselect",nullptr )
-,		SchemaEntry("ifcforcemeasure",nullptr )
-,		SchemaEntry("ifcfillareastyletileshapeselect",nullptr )
-,		SchemaEntry("ifcelectricappliancetypeenum",nullptr )
-,		SchemaEntry("ifcsurfacetextureenum",nullptr )
-,		SchemaEntry("ifccharacterstyleselect",nullptr )
-,		SchemaEntry("ifcenergymeasure",nullptr )
-,		SchemaEntry("ifcreal",nullptr )
-,		SchemaEntry("ifccompressortypeenum",nullptr )
-,		SchemaEntry("ifcelectricdistributionpointfunctionenum",nullptr )
-,		SchemaEntry("ifcroot",&STEP::ObjectHelper<IfcRoot,4>::Construct )
-,		SchemaEntry("ifcobjectdefinition",&STEP::ObjectHelper<IfcObjectDefinition,0>::Construct )
-,		SchemaEntry("ifctypeobject",&STEP::ObjectHelper<IfcTypeObject,2>::Construct )
-,		SchemaEntry("ifctypeproduct",&STEP::ObjectHelper<IfcTypeProduct,2>::Construct )
-,		SchemaEntry("ifcelementtype",&STEP::ObjectHelper<IfcElementType,1>::Construct )
-,		SchemaEntry("ifcdistributionelementtype",&STEP::ObjectHelper<IfcDistributionElementType,0>::Construct )
-,		SchemaEntry("ifcdistributionflowelementtype",&STEP::ObjectHelper<IfcDistributionFlowElementType,0>::Construct )
-,		SchemaEntry("ifcflowcontrollertype",&STEP::ObjectHelper<IfcFlowControllerType,0>::Construct )
-,		SchemaEntry("ifcelectrictimecontroltype",&STEP::ObjectHelper<IfcElectricTimeControlType,1>::Construct )
-,		SchemaEntry("ifcrepresentation",&STEP::ObjectHelper<IfcRepresentation,4>::Construct )
-,		SchemaEntry("ifcshapemodel",&STEP::ObjectHelper<IfcShapeModel,0>::Construct )
-,		SchemaEntry("ifctopologyrepresentation",&STEP::ObjectHelper<IfcTopologyRepresentation,0>::Construct )
-,		SchemaEntry("ifcrelationship",&STEP::ObjectHelper<IfcRelationship,0>::Construct )
-,		SchemaEntry("ifcrelconnects",&STEP::ObjectHelper<IfcRelConnects,0>::Construct )
-,		SchemaEntry("ifcrelcoversspaces",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowfittingtype",&STEP::ObjectHelper<IfcFlowFittingType,0>::Construct )
-,		SchemaEntry("ifccablecarrierfittingtype",&STEP::ObjectHelper<IfcCableCarrierFittingType,1>::Construct )
-,		SchemaEntry("ifcstructuralconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcslippageconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcenergyconversiondevicetype",&STEP::ObjectHelper<IfcEnergyConversionDeviceType,0>::Construct )
-,		SchemaEntry("ifccoiltype",&STEP::ObjectHelper<IfcCoilType,1>::Construct )
-,		SchemaEntry("ifcobject",&STEP::ObjectHelper<IfcObject,1>::Construct )
-,		SchemaEntry("ifccontrol",&STEP::ObjectHelper<IfcControl,0>::Construct )
-,		SchemaEntry("ifcperformancehistory",&STEP::ObjectHelper<IfcPerformanceHistory,1>::Construct )
-,		SchemaEntry("ifcrepresentationitem",&STEP::ObjectHelper<IfcRepresentationItem,0>::Construct )
-,		SchemaEntry("ifcgeometricrepresentationitem",&STEP::ObjectHelper<IfcGeometricRepresentationItem,0>::Construct )
-,		SchemaEntry("ifctextliteral",&STEP::ObjectHelper<IfcTextLiteral,3>::Construct )
-,		SchemaEntry("ifctextliteralwithextent",&STEP::ObjectHelper<IfcTextLiteralWithExtent,2>::Construct )
-,		SchemaEntry("ifcproductrepresentation",&STEP::ObjectHelper<IfcProductRepresentation,3>::Construct )
-,		SchemaEntry("ifcproduct",&STEP::ObjectHelper<IfcProduct,2>::Construct )
-,		SchemaEntry("ifcelement",&STEP::ObjectHelper<IfcElement,1>::Construct )
-,		SchemaEntry("ifcdistributionelement",&STEP::ObjectHelper<IfcDistributionElement,0>::Construct )
-,		SchemaEntry("ifcdistributionflowelement",&STEP::ObjectHelper<IfcDistributionFlowElement,0>::Construct )
-,		SchemaEntry("ifccurve",&STEP::ObjectHelper<IfcCurve,0>::Construct )
-,		SchemaEntry("ifcboundedcurve",&STEP::ObjectHelper<IfcBoundedCurve,0>::Construct )
-,		SchemaEntry("ifccompositecurve",&STEP::ObjectHelper<IfcCompositeCurve,2>::Construct )
-,		SchemaEntry("ifc2dcompositecurve",&STEP::ObjectHelper<Ifc2DCompositeCurve,0>::Construct )
-,		SchemaEntry("ifcboundarycondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboundaryfacecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator",&STEP::ObjectHelper<IfcCartesianTransformationOperator,4>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator3d",&STEP::ObjectHelper<IfcCartesianTransformationOperator3D,1>::Construct )
-,		SchemaEntry("ifcproperty",&STEP::ObjectHelper<IfcProperty,2>::Construct )
-,		SchemaEntry("ifcsimpleproperty",&STEP::ObjectHelper<IfcSimpleProperty,0>::Construct )
-,		SchemaEntry("ifcpropertyenumeratedvalue",&STEP::ObjectHelper<IfcPropertyEnumeratedValue,2>::Construct )
-,		SchemaEntry("ifcpresentationlayerassignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpresentationlayerwithstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcbuildingelementtype",&STEP::ObjectHelper<IfcBuildingElementType,0>::Construct )
-,		SchemaEntry("ifcstairflighttype",&STEP::ObjectHelper<IfcStairFlightType,1>::Construct )
-,		SchemaEntry("ifcsurface",&STEP::ObjectHelper<IfcSurface,0>::Construct )
-,		SchemaEntry("ifcelementarysurface",&STEP::ObjectHelper<IfcElementarySurface,1>::Construct )
-,		SchemaEntry("ifcplane",&STEP::ObjectHelper<IfcPlane,0>::Construct )
-,		SchemaEntry("ifcbooleanresult",&STEP::ObjectHelper<IfcBooleanResult,3>::Construct )
-,		SchemaEntry("ifcbooleanclippingresult",&STEP::ObjectHelper<IfcBooleanClippingResult,0>::Construct )
-,		SchemaEntry("ifcsolidmodel",&STEP::ObjectHelper<IfcSolidModel,0>::Construct )
-,		SchemaEntry("ifcmanifoldsolidbrep",&STEP::ObjectHelper<IfcManifoldSolidBrep,1>::Construct )
-,		SchemaEntry("ifcprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcgeneralprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowterminaltype",&STEP::ObjectHelper<IfcFlowTerminalType,0>::Construct )
-,		SchemaEntry("ifcstackterminaltype",&STEP::ObjectHelper<IfcStackTerminalType,1>::Construct )
-,		SchemaEntry("ifcstructuralitem",&STEP::ObjectHelper<IfcStructuralItem,0>::Construct )
-,		SchemaEntry("ifcstructuralconnection",&STEP::ObjectHelper<IfcStructuralConnection,1>::Construct )
-,		SchemaEntry("ifcstructuralcurveconnection",&STEP::ObjectHelper<IfcStructuralCurveConnection,0>::Construct )
-,		SchemaEntry("ifcjunctionboxtype",&STEP::ObjectHelper<IfcJunctionBoxType,1>::Construct )
-,		SchemaEntry("ifcrelassociates",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertydefinition",&STEP::ObjectHelper<IfcPropertyDefinition,0>::Construct )
-,		SchemaEntry("ifcpropertysetdefinition",&STEP::ObjectHelper<IfcPropertySetDefinition,0>::Construct )
-,		SchemaEntry("ifcdoorpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconstraintrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcspacethermalloadproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclibraryinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcprocess",&STEP::ObjectHelper<IfcProcess,0>::Construct )
-,		SchemaEntry("ifctask",&STEP::ObjectHelper<IfcTask,5>::Construct )
-,		SchemaEntry("ifcappliedvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcenvironmentalimpactvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelfillselement",&STEP::ObjectHelper<IfcRelFillsElement,2>::Construct )
-,		SchemaEntry("ifcprocedure",&STEP::ObjectHelper<IfcProcedure,3>::Construct )
-,		SchemaEntry("ifcstructuralload",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadstatic",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingledisplacement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcproxy",&STEP::ObjectHelper<IfcProxy,2>::Construct )
-,		SchemaEntry("ifccurvestylefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcresource",&STEP::ObjectHelper<IfcResource,0>::Construct )
-,		SchemaEntry("ifcconstructionresource",&STEP::ObjectHelper<IfcConstructionResource,4>::Construct )
-,		SchemaEntry("ifcsubcontractresource",&STEP::ObjectHelper<IfcSubContractResource,2>::Construct )
-,		SchemaEntry("ifccalendardate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdocumentelectronicformat",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelcontainedinspatialstructure",&STEP::ObjectHelper<IfcRelContainedInSpatialStructure,2>::Construct )
-,		SchemaEntry("ifcmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcproductsofcombustionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctopologicalrepresentationitem",&STEP::ObjectHelper<IfcTopologicalRepresentationItem,0>::Construct )
-,		SchemaEntry("ifcedge",&STEP::ObjectHelper<IfcEdge,2>::Construct )
-,		SchemaEntry("ifcedgecurve",&STEP::ObjectHelper<IfcEdgeCurve,2>::Construct )
-,		SchemaEntry("ifcplatetype",&STEP::ObjectHelper<IfcPlateType,1>::Construct )
-,		SchemaEntry("ifcobjectplacement",&STEP::ObjectHelper<IfcObjectPlacement,0>::Construct )
-,		SchemaEntry("ifcgridplacement",&STEP::ObjectHelper<IfcGridPlacement,2>::Construct )
-,		SchemaEntry("ifcfiresuppressionterminaltype",&STEP::ObjectHelper<IfcFireSuppressionTerminalType,1>::Construct )
-,		SchemaEntry("ifcmechanicalmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowstoragedevice",&STEP::ObjectHelper<IfcFlowStorageDevice,0>::Construct )
-,		SchemaEntry("ifcperson",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsweptsurface",&STEP::ObjectHelper<IfcSweptSurface,2>::Construct )
-,		SchemaEntry("ifcsurfaceofrevolution",&STEP::ObjectHelper<IfcSurfaceOfRevolution,1>::Construct )
-,		SchemaEntry("ifcorientededge",&STEP::ObjectHelper<IfcOrientedEdge,2>::Construct )
-,		SchemaEntry("ifcownerhistory",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassigns",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstoactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdirection",&STEP::ObjectHelper<IfcDirection,1>::Construct )
-,		SchemaEntry("ifcreinforcementbarproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcprofiledef",&STEP::ObjectHelper<IfcProfileDef,2>::Construct )
-,		SchemaEntry("ifcparameterizedprofiledef",&STEP::ObjectHelper<IfcParameterizedProfileDef,1>::Construct )
-,		SchemaEntry("ifccshapeprofiledef",&STEP::ObjectHelper<IfcCShapeProfileDef,6>::Construct )
-,		SchemaEntry("ifcfeatureelement",&STEP::ObjectHelper<IfcFeatureElement,0>::Construct )
-,		SchemaEntry("ifcfeatureelementsubtraction",&STEP::ObjectHelper<IfcFeatureElementSubtraction,0>::Construct )
-,		SchemaEntry("ifcedgefeature",&STEP::ObjectHelper<IfcEdgeFeature,1>::Construct )
-,		SchemaEntry("ifcchamferedgefeature",&STEP::ObjectHelper<IfcChamferEdgeFeature,2>::Construct )
-,		SchemaEntry("ifcbuildingelement",&STEP::ObjectHelper<IfcBuildingElement,0>::Construct )
-,		SchemaEntry("ifccolumn",&STEP::ObjectHelper<IfcColumn,0>::Construct )
-,		SchemaEntry("ifcpropertyreferencevalue",&STEP::ObjectHelper<IfcPropertyReferenceValue,2>::Construct )
-,		SchemaEntry("ifcmaterialclassificationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelectricmotortype",&STEP::ObjectHelper<IfcElectricMotorType,1>::Construct )
-,		SchemaEntry("ifcspatialstructureelementtype",&STEP::ObjectHelper<IfcSpatialStructureElementType,0>::Construct )
-,		SchemaEntry("ifcspacetype",&STEP::ObjectHelper<IfcSpaceType,1>::Construct )
-,		SchemaEntry("ifcexternalreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcexternallydefinedhatchstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccolumntype",&STEP::ObjectHelper<IfcColumnType,1>::Construct )
-,		SchemaEntry("ifccranerailashapeprofiledef",&STEP::ObjectHelper<IfcCraneRailAShapeProfileDef,12>::Construct )
-,		SchemaEntry("ifccondensertype",&STEP::ObjectHelper<IfcCondenserType,1>::Construct )
-,		SchemaEntry("ifcrelconnectselements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectswithrealizingelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccircleprofiledef",&STEP::ObjectHelper<IfcCircleProfileDef,1>::Construct )
-,		SchemaEntry("ifccirclehollowprofiledef",&STEP::ObjectHelper<IfcCircleHollowProfileDef,1>::Construct )
-,		SchemaEntry("ifcorganizationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcplacement",&STEP::ObjectHelper<IfcPlacement,1>::Construct )
-,		SchemaEntry("ifcaxis2placement3d",&STEP::ObjectHelper<IfcAxis2Placement3D,2>::Construct )
-,		SchemaEntry("ifcpresentationstyle",&STEP::ObjectHelper<IfcPresentationStyle,1>::Construct )
-,		SchemaEntry("ifccurvestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcequipmentelement",&STEP::ObjectHelper<IfcEquipmentElement,0>::Construct )
-,		SchemaEntry("ifccompositecurvesegment",&STEP::ObjectHelper<IfcCompositeCurveSegment,3>::Construct )
-,		SchemaEntry("ifcrectangleprofiledef",&STEP::ObjectHelper<IfcRectangleProfileDef,2>::Construct )
-,		SchemaEntry("ifcphysicalquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcphysicalcomplexquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociateslibrary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelsequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcbuildingelementproxy",&STEP::ObjectHelper<IfcBuildingElementProxy,1>::Construct )
-,		SchemaEntry("ifcdistributioncontrolelementtype",&STEP::ObjectHelper<IfcDistributionControlElementType,0>::Construct )
-,		SchemaEntry("ifcflowinstrumenttype",&STEP::ObjectHelper<IfcFlowInstrumentType,1>::Construct )
-,		SchemaEntry("ifcdraughtingcallout",&STEP::ObjectHelper<IfcDraughtingCallout,1>::Construct )
-,		SchemaEntry("ifcdimensioncurvedirectedcallout",&STEP::ObjectHelper<IfcDimensionCurveDirectedCallout,0>::Construct )
-,		SchemaEntry("ifclineardimension",&STEP::ObjectHelper<IfcLinearDimension,0>::Construct )
-,		SchemaEntry("ifcelementassembly",&STEP::ObjectHelper<IfcElementAssembly,2>::Construct )
-,		SchemaEntry("ifcdraughtingcalloutrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccsgprimitive3d",&STEP::ObjectHelper<IfcCsgPrimitive3D,1>::Construct )
-,		SchemaEntry("ifcrightcircularcone",&STEP::ObjectHelper<IfcRightCircularCone,2>::Construct )
-,		SchemaEntry("ifcexternallydefinedsurfacestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcprojectorder",&STEP::ObjectHelper<IfcProjectOrder,3>::Construct )
-,		SchemaEntry("ifcpropertyconstraintrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclshapeprofiledef",&STEP::ObjectHelper<IfcLShapeProfileDef,8>::Construct )
-,		SchemaEntry("ifcangulardimension",&STEP::ObjectHelper<IfcAngularDimension,0>::Construct )
-,		SchemaEntry("ifctextstylefordefinedfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclocalplacement",&STEP::ObjectHelper<IfcLocalPlacement,2>::Construct )
-,		SchemaEntry("ifcsweptareasolid",&STEP::ObjectHelper<IfcSweptAreaSolid,2>::Construct )
-,		SchemaEntry("ifcrevolvedareasolid",&STEP::ObjectHelper<IfcRevolvedAreaSolid,2>::Construct )
-,		SchemaEntry("ifcstructuralsurfaceconnection",&STEP::ObjectHelper<IfcStructuralSurfaceConnection,0>::Construct )
-,		SchemaEntry("ifcradiusdimension",&STEP::ObjectHelper<IfcRadiusDimension,0>::Construct )
-,		SchemaEntry("ifcsweptdisksolid",&STEP::ObjectHelper<IfcSweptDiskSolid,5>::Construct )
-,		SchemaEntry("ifchalfspacesolid",&STEP::ObjectHelper<IfcHalfSpaceSolid,2>::Construct )
-,		SchemaEntry("ifcpolygonalboundedhalfspace",&STEP::ObjectHelper<IfcPolygonalBoundedHalfSpace,2>::Construct )
-,		SchemaEntry("ifctimeseriesschedule",&STEP::ObjectHelper<IfcTimeSeriesSchedule,3>::Construct )
-,		SchemaEntry("ifcdimensioncalloutrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccooledbeamtype",&STEP::ObjectHelper<IfcCooledBeamType,1>::Construct )
-,		SchemaEntry("ifcproject",&STEP::ObjectHelper<IfcProject,4>::Construct )
-,		SchemaEntry("ifcapprovalrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcevaporatortype",&STEP::ObjectHelper<IfcEvaporatorType,1>::Construct )
-,		SchemaEntry("ifclaborresource",&STEP::ObjectHelper<IfcLaborResource,1>::Construct )
-,		SchemaEntry("ifcstructuralloadsingledisplacementdistortion",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertyboundedvalue",&STEP::ObjectHelper<IfcPropertyBoundedValue,3>::Construct )
-,		SchemaEntry("ifcrampflighttype",&STEP::ObjectHelper<IfcRampFlightType,1>::Construct )
-,		SchemaEntry("ifcmember",&STEP::ObjectHelper<IfcMember,0>::Construct )
-,		SchemaEntry("ifcstructuralloadplanarforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctubebundletype",&STEP::ObjectHelper<IfcTubeBundleType,1>::Construct )
-,		SchemaEntry("ifcvalvetype",&STEP::ObjectHelper<IfcValveType,1>::Construct )
-,		SchemaEntry("ifcexternallydefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctrimmedcurve",&STEP::ObjectHelper<IfcTrimmedCurve,5>::Construct )
-,		SchemaEntry("ifcreldefines",&STEP::ObjectHelper<IfcRelDefines,1>::Construct )
-,		SchemaEntry("ifcreldefinesbyproperties",&STEP::ObjectHelper<IfcRelDefinesByProperties,1>::Construct )
-,		SchemaEntry("ifcrelassignstocontrol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcactor",&STEP::ObjectHelper<IfcActor,1>::Construct )
-,		SchemaEntry("ifcoccupant",&STEP::ObjectHelper<IfcOccupant,1>::Construct )
-,		SchemaEntry("ifchumidifiertype",&STEP::ObjectHelper<IfcHumidifierType,1>::Construct )
-,		SchemaEntry("ifcarbitraryopenprofiledef",&STEP::ObjectHelper<IfcArbitraryOpenProfileDef,1>::Construct )
-,		SchemaEntry("ifcrelassignstoprojectorder",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpermit",&STEP::ObjectHelper<IfcPermit,1>::Construct )
-,		SchemaEntry("ifcoffsetcurve3d",&STEP::ObjectHelper<IfcOffsetCurve3D,4>::Construct )
-,		SchemaEntry("ifclightsource",&STEP::ObjectHelper<IfcLightSource,4>::Construct )
-,		SchemaEntry("ifclightsourcepositional",&STEP::ObjectHelper<IfcLightSourcePositional,5>::Construct )
-,		SchemaEntry("ifcsurfacetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcblobtexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccompositeprofiledef",&STEP::ObjectHelper<IfcCompositeProfileDef,2>::Construct )
-,		SchemaEntry("ifcdocumentinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacestylelighting",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcphysicalsimplequantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantityarea",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcclassificationnotation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcramp",&STEP::ObjectHelper<IfcRamp,1>::Construct )
-,		SchemaEntry("ifcpredefineditem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurrencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowmovingdevice",&STEP::ObjectHelper<IfcFlowMovingDevice,0>::Construct )
-,		SchemaEntry("ifcspaceheatertype",&STEP::ObjectHelper<IfcSpaceHeaterType,1>::Construct )
-,		SchemaEntry("ifclamptype",&STEP::ObjectHelper<IfcLampType,1>::Construct )
-,		SchemaEntry("ifcbuildingelementcomponent",&STEP::ObjectHelper<IfcBuildingElementComponent,0>::Construct )
-,		SchemaEntry("ifcreinforcingelement",&STEP::ObjectHelper<IfcReinforcingElement,1>::Construct )
-,		SchemaEntry("ifcreinforcingbar",&STEP::ObjectHelper<IfcReinforcingBar,5>::Construct )
-,		SchemaEntry("ifcelectricheatertype",&STEP::ObjectHelper<IfcElectricHeaterType,1>::Construct )
-,		SchemaEntry("ifctshapeprofiledef",&STEP::ObjectHelper<IfcTShapeProfileDef,10>::Construct )
-,		SchemaEntry("ifcconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcobjective",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralactivity",&STEP::ObjectHelper<IfcStructuralActivity,2>::Construct )
-,		SchemaEntry("ifcstructuralaction",&STEP::ObjectHelper<IfcStructuralAction,2>::Construct )
-,		SchemaEntry("ifctexturecoordinate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmonetaryunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantitytime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctablerow",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclightdistributiondata",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcductfittingtype",&STEP::ObjectHelper<IfcDuctFittingType,1>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator2d",&STEP::ObjectHelper<IfcCartesianTransformationOperator2D,0>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator2dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1>::Construct )
-,		SchemaEntry("ifcclassificationnotationfacet",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdraughtingpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingleforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingleforcewarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurvestylefontandscaling",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcvirtualelement",&STEP::ObjectHelper<IfcVirtualElement,0>::Construct )
-,		SchemaEntry("ifcrightcircularcylinder",&STEP::ObjectHelper<IfcRightCircularCylinder,2>::Construct )
-,		SchemaEntry("ifcoutlettype",&STEP::ObjectHelper<IfcOutletType,1>::Construct )
-,		SchemaEntry("ifcreldecomposes",&STEP::ObjectHelper<IfcRelDecomposes,2>::Construct )
-,		SchemaEntry("ifcrelnests",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccovering",&STEP::ObjectHelper<IfcCovering,1>::Construct )
-,		SchemaEntry("ifcexternallydefinedsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcirregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpolyline",&STEP::ObjectHelper<IfcPolyline,1>::Construct )
-,		SchemaEntry("ifcpath",&STEP::ObjectHelper<IfcPath,1>::Construct )
-,		SchemaEntry("ifcelementcomponent",&STEP::ObjectHelper<IfcElementComponent,0>::Construct )
-,		SchemaEntry("ifcfastener",&STEP::ObjectHelper<IfcFastener,0>::Construct )
-,		SchemaEntry("ifcmappeditem",&STEP::ObjectHelper<IfcMappedItem,2>::Construct )
-,		SchemaEntry("ifcmetric",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdocumentreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsectionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrectangularpyramid",&STEP::ObjectHelper<IfcRectangularPyramid,3>::Construct )
-,		SchemaEntry("ifcrelreferencedinspatialstructure",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccrewresource",&STEP::ObjectHelper<IfcCrewResource,0>::Construct )
-,		SchemaEntry("ifcnamedunit",&STEP::ObjectHelper<IfcNamedUnit,2>::Construct )
-,		SchemaEntry("ifccontextdependentunit",&STEP::ObjectHelper<IfcContextDependentUnit,1>::Construct )
-,		SchemaEntry("ifcunitaryequipmenttype",&STEP::ObjectHelper<IfcUnitaryEquipmentType,1>::Construct )
-,		SchemaEntry("ifcroof",&STEP::ObjectHelper<IfcRoof,1>::Construct )
-,		SchemaEntry("ifcrelassignstasks",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralmember",&STEP::ObjectHelper<IfcStructuralMember,0>::Construct )
-,		SchemaEntry("ifcrelconnectsports",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstylemodel",&STEP::ObjectHelper<IfcStyleModel,0>::Construct )
-,		SchemaEntry("ifcstyledrepresentation",&STEP::ObjectHelper<IfcStyledRepresentation,0>::Construct )
-,		SchemaEntry("ifcspatialstructureelement",&STEP::ObjectHelper<IfcSpatialStructureElement,2>::Construct )
-,		SchemaEntry("ifcbuilding",&STEP::ObjectHelper<IfcBuilding,3>::Construct )
-,		SchemaEntry("ifcconnectedfaceset",&STEP::ObjectHelper<IfcConnectedFaceSet,1>::Construct )
-,		SchemaEntry("ifcopenshell",&STEP::ObjectHelper<IfcOpenShell,0>::Construct )
-,		SchemaEntry("ifcfacetedbrep",&STEP::ObjectHelper<IfcFacetedBrep,0>::Construct )
-,		SchemaEntry("ifclocaltime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmechanicalconcretematerialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconic",&STEP::ObjectHelper<IfcConic,1>::Construct )
-,		SchemaEntry("ifccoveringtype",&STEP::ObjectHelper<IfcCoveringType,1>::Construct )
-,		SchemaEntry("ifcroundedrectangleprofiledef",&STEP::ObjectHelper<IfcRoundedRectangleProfileDef,1>::Construct )
-,		SchemaEntry("ifcairterminaltype",&STEP::ObjectHelper<IfcAirTerminalType,1>::Construct )
-,		SchemaEntry("ifcflowmovingdevicetype",&STEP::ObjectHelper<IfcFlowMovingDeviceType,0>::Construct )
-,		SchemaEntry("ifccompressortype",&STEP::ObjectHelper<IfcCompressorType,1>::Construct )
-,		SchemaEntry("ifcwindowpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedterminatorsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcishapeprofiledef",&STEP::ObjectHelper<IfcIShapeProfileDef,5>::Construct )
-,		SchemaEntry("ifcasymmetricishapeprofiledef",&STEP::ObjectHelper<IfcAsymmetricIShapeProfileDef,4>::Construct )
-,		SchemaEntry("ifccontrollertype",&STEP::ObjectHelper<IfcControllerType,1>::Construct )
-,		SchemaEntry("ifcrailing",&STEP::ObjectHelper<IfcRailing,1>::Construct )
-,		SchemaEntry("ifcgroup",&STEP::ObjectHelper<IfcGroup,0>::Construct )
-,		SchemaEntry("ifcasset",&STEP::ObjectHelper<IfcAsset,9>::Construct )
-,		SchemaEntry("ifcmaterialdefinitionrepresentation",&STEP::ObjectHelper<IfcMaterialDefinitionRepresentation,1>::Construct )
-,		SchemaEntry("ifccurvestylefontpattern",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcapprovalpropertyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrailingtype",&STEP::ObjectHelper<IfcRailingType,1>::Construct )
-,		SchemaEntry("ifcwall",&STEP::ObjectHelper<IfcWall,0>::Construct )
-,		SchemaEntry("ifcclassificationitem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralpointconnection",&STEP::ObjectHelper<IfcStructuralPointConnection,0>::Construct )
-,		SchemaEntry("ifcconnectiongeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectionpointgeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertylistvalue",&STEP::ObjectHelper<IfcPropertyListValue,2>::Construct )
-,		SchemaEntry("ifcfurniturestandard",&STEP::ObjectHelper<IfcFurnitureStandard,0>::Construct )
-,		SchemaEntry("ifcrelschedulescostitems",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelectricgeneratortype",&STEP::ObjectHelper<IfcElectricGeneratorType,1>::Construct )
-,		SchemaEntry("ifcdoor",&STEP::ObjectHelper<IfcDoor,2>::Construct )
-,		SchemaEntry("ifcstyleditem",&STEP::ObjectHelper<IfcStyledItem,3>::Construct )
-,		SchemaEntry("ifcannotationoccurrence",&STEP::ObjectHelper<IfcAnnotationOccurrence,0>::Construct )
-,		SchemaEntry("ifcannotationsymboloccurrence",&STEP::ObjectHelper<IfcAnnotationSymbolOccurrence,0>::Construct )
-,		SchemaEntry("ifcarbitraryclosedprofiledef",&STEP::ObjectHelper<IfcArbitraryClosedProfileDef,1>::Construct )
-,		SchemaEntry("ifcarbitraryprofiledefwithvoids",&STEP::ObjectHelper<IfcArbitraryProfileDefWithVoids,1>::Construct )
-,		SchemaEntry("ifcline",&STEP::ObjectHelper<IfcLine,2>::Construct )
-,		SchemaEntry("ifcmateriallayerset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowsegmenttype",&STEP::ObjectHelper<IfcFlowSegmentType,0>::Construct )
-,		SchemaEntry("ifcairterminalboxtype",&STEP::ObjectHelper<IfcAirTerminalBoxType,1>::Construct )
-,		SchemaEntry("ifcrelconnectsstructuralmember",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertysinglevalue",&STEP::ObjectHelper<IfcPropertySingleValue,2>::Construct )
-,		SchemaEntry("ifcalarmtype",&STEP::ObjectHelper<IfcAlarmType,1>::Construct )
-,		SchemaEntry("ifcellipseprofiledef",&STEP::ObjectHelper<IfcEllipseProfileDef,2>::Construct )
-,		SchemaEntry("ifcstair",&STEP::ObjectHelper<IfcStair,1>::Construct )
-,		SchemaEntry("ifcpredefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctextstylefontmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacestyleshading",&STEP::ObjectHelper<IfcSurfaceStyleShading,1>::Construct )
-,		SchemaEntry("ifcpumptype",&STEP::ObjectHelper<IfcPumpType,1>::Construct )
-,		SchemaEntry("ifcdefinedsymbol",&STEP::ObjectHelper<IfcDefinedSymbol,2>::Construct )
-,		SchemaEntry("ifcclassificationitemrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcgeneralmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelementcomponenttype",&STEP::ObjectHelper<IfcElementComponentType,0>::Construct )
-,		SchemaEntry("ifcfastenertype",&STEP::ObjectHelper<IfcFastenerType,0>::Construct )
-,		SchemaEntry("ifcmechanicalfastenertype",&STEP::ObjectHelper<IfcMechanicalFastenerType,0>::Construct )
-,		SchemaEntry("ifcpermeablecoveringproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowfitting",&STEP::ObjectHelper<IfcFlowFitting,0>::Construct )
-,		SchemaEntry("ifcapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcshapeaspect",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconstraintclassificationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclightsourcedirectional",&STEP::ObjectHelper<IfcLightSourceDirectional,1>::Construct )
-,		SchemaEntry("ifcsurfacestyle",&STEP::ObjectHelper<IfcSurfaceStyle,2>::Construct )
-,		SchemaEntry("ifcrelconnectsstructuralactivity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcannotationsurface",&STEP::ObjectHelper<IfcAnnotationSurface,2>::Construct )
-,		SchemaEntry("ifcfuelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowcontroller",&STEP::ObjectHelper<IfcFlowController,0>::Construct )
-,		SchemaEntry("ifcfailureconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcbuildingstorey",&STEP::ObjectHelper<IfcBuildingStorey,1>::Construct )
-,		SchemaEntry("ifcworkcontrol",&STEP::ObjectHelper<IfcWorkControl,10>::Construct )
-,		SchemaEntry("ifcworkschedule",&STEP::ObjectHelper<IfcWorkSchedule,0>::Construct )
-,		SchemaEntry("ifctable",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcductsegmenttype",&STEP::ObjectHelper<IfcDuctSegmentType,1>::Construct )
-,		SchemaEntry("ifcstructuralsteelprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdraughtingpredefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcface",&STEP::ObjectHelper<IfcFace,1>::Construct )
-,		SchemaEntry("ifcstructuralsurfacemember",&STEP::ObjectHelper<IfcStructuralSurfaceMember,2>::Construct )
-,		SchemaEntry("ifcstructuralsurfacemembervarying",&STEP::ObjectHelper<IfcStructuralSurfaceMemberVarying,2>::Construct )
-,		SchemaEntry("ifcfacesurface",&STEP::ObjectHelper<IfcFaceSurface,2>::Construct )
-,		SchemaEntry("ifcclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmateriallist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccostschedule",&STEP::ObjectHelper<IfcCostSchedule,8>::Construct )
-,		SchemaEntry("ifccoordinateduniversaltimeoffset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcplanarextent",&STEP::ObjectHelper<IfcPlanarExtent,2>::Construct )
-,		SchemaEntry("ifcplanarbox",&STEP::ObjectHelper<IfcPlanarBox,1>::Construct )
-,		SchemaEntry("ifcfillareastyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsectionreinforcementproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccolourspecification",&STEP::ObjectHelper<IfcColourSpecification,1>::Construct )
-,		SchemaEntry("ifcvector",&STEP::ObjectHelper<IfcVector,2>::Construct )
-,		SchemaEntry("ifcbeam",&STEP::ObjectHelper<IfcBeam,0>::Construct )
-,		SchemaEntry("ifccolourrgb",&STEP::ObjectHelper<IfcColourRgb,3>::Construct )
-,		SchemaEntry("ifcstructuralplanaraction",&STEP::ObjectHelper<IfcStructuralPlanarAction,1>::Construct )
-,		SchemaEntry("ifcstructuralplanaractionvarying",&STEP::ObjectHelper<IfcStructuralPlanarActionVarying,2>::Construct )
-,		SchemaEntry("ifcsite",&STEP::ObjectHelper<IfcSite,5>::Construct )
-,		SchemaEntry("ifcdiscreteaccessorytype",&STEP::ObjectHelper<IfcDiscreteAccessoryType,0>::Construct )
-,		SchemaEntry("ifcvibrationisolatortype",&STEP::ObjectHelper<IfcVibrationIsolatorType,1>::Construct )
-,		SchemaEntry("ifcevaporativecoolertype",&STEP::ObjectHelper<IfcEvaporativeCoolerType,1>::Construct )
-,		SchemaEntry("ifcdistributionchamberelementtype",&STEP::ObjectHelper<IfcDistributionChamberElementType,1>::Construct )
-,		SchemaEntry("ifcfeatureelementaddition",&STEP::ObjectHelper<IfcFeatureElementAddition,0>::Construct )
-,		SchemaEntry("ifcrelassignstoresource",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructureddimensioncallout",&STEP::ObjectHelper<IfcStructuredDimensionCallout,0>::Construct )
-,		SchemaEntry("ifccoolingtowertype",&STEP::ObjectHelper<IfcCoolingTowerType,1>::Construct )
-,		SchemaEntry("ifccenterlineprofiledef",&STEP::ObjectHelper<IfcCenterLineProfileDef,1>::Construct )
-,		SchemaEntry("ifctexturevertex",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwindowstyle",&STEP::ObjectHelper<IfcWindowStyle,4>::Construct )
-,		SchemaEntry("ifclightsourcegoniometric",&STEP::ObjectHelper<IfcLightSourceGoniometric,6>::Construct )
-,		SchemaEntry("ifcribplateprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctransformertype",&STEP::ObjectHelper<IfcTransformerType,1>::Construct )
-,		SchemaEntry("ifcmembertype",&STEP::ObjectHelper<IfcMemberType,1>::Construct )
-,		SchemaEntry("ifcsurfaceoflinearextrusion",&STEP::ObjectHelper<IfcSurfaceOfLinearExtrusion,2>::Construct )
-,		SchemaEntry("ifcmotorconnectiontype",&STEP::ObjectHelper<IfcMotorConnectionType,1>::Construct )
-,		SchemaEntry("ifcflowtreatmentdevicetype",&STEP::ObjectHelper<IfcFlowTreatmentDeviceType,0>::Construct )
-,		SchemaEntry("ifcductsilencertype",&STEP::ObjectHelper<IfcDuctSilencerType,1>::Construct )
-,		SchemaEntry("ifcwindowliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfurnishingelementtype",&STEP::ObjectHelper<IfcFurnishingElementType,0>::Construct )
-,		SchemaEntry("ifcsystemfurnitureelementtype",&STEP::ObjectHelper<IfcSystemFurnitureElementType,0>::Construct )
-,		SchemaEntry("ifcconnectionpointeccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwasteterminaltype",&STEP::ObjectHelper<IfcWasteTerminalType,1>::Construct )
-,		SchemaEntry("ifcbsplinecurve",&STEP::ObjectHelper<IfcBSplineCurve,5>::Construct )
-,		SchemaEntry("ifcbeziercurve",&STEP::ObjectHelper<IfcBezierCurve,0>::Construct )
-,		SchemaEntry("ifcdocumentinformationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcactuatortype",&STEP::ObjectHelper<IfcActuatorType,1>::Construct )
-,		SchemaEntry("ifcdistributioncontrolelement",&STEP::ObjectHelper<IfcDistributionControlElement,1>::Construct )
-,		SchemaEntry("ifcannotation",&STEP::ObjectHelper<IfcAnnotation,0>::Construct )
-,		SchemaEntry("ifcrelassociatesdocument",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdoorliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcshellbasedsurfacemodel",&STEP::ObjectHelper<IfcShellBasedSurfaceModel,1>::Construct )
-,		SchemaEntry("ifcactionrequest",&STEP::ObjectHelper<IfcActionRequest,1>::Construct )
-,		SchemaEntry("ifcextrudedareasolid",&STEP::ObjectHelper<IfcExtrudedAreaSolid,2>::Construct )
-,		SchemaEntry("ifcsystem",&STEP::ObjectHelper<IfcSystem,0>::Construct )
-,		SchemaEntry("ifcfillareastylehatching",&STEP::ObjectHelper<IfcFillAreaStyleHatching,5>::Construct )
-,		SchemaEntry("ifcrelvoidselement",&STEP::ObjectHelper<IfcRelVoidsElement,2>::Construct )
-,		SchemaEntry("ifcrelconnectspathelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelspaceboundary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacecurvesweptareasolid",&STEP::ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator3dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2>::Construct )
-,		SchemaEntry("ifcrelinteractionrequirements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurtainwalltype",&STEP::ObjectHelper<IfcCurtainWallType,1>::Construct )
-,		SchemaEntry("ifcquantitylength",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcequipmentstandard",&STEP::ObjectHelper<IfcEquipmentStandard,0>::Construct )
-,		SchemaEntry("ifcflowstoragedevicetype",&STEP::ObjectHelper<IfcFlowStorageDeviceType,0>::Construct )
-,		SchemaEntry("ifcvirtualgridintersection",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdiameterdimension",&STEP::ObjectHelper<IfcDiameterDimension,0>::Construct )
-,		SchemaEntry("ifcswitchingdevicetype",&STEP::ObjectHelper<IfcSwitchingDeviceType,1>::Construct )
-,		SchemaEntry("ifcaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctelecomaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwindow",&STEP::ObjectHelper<IfcWindow,2>::Construct )
-,		SchemaEntry("ifcmechanicalsteelmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowtreatmentdevice",&STEP::ObjectHelper<IfcFlowTreatmentDevice,0>::Construct )
-,		SchemaEntry("ifcrelservicesbuildings",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcchillertype",&STEP::ObjectHelper<IfcChillerType,1>::Construct )
-,		SchemaEntry("ifcrelassignstoproduct",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrectanglehollowprofiledef",&STEP::ObjectHelper<IfcRectangleHollowProfileDef,3>::Construct )
-,		SchemaEntry("ifcenergyproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboxedhalfspace",&STEP::ObjectHelper<IfcBoxedHalfSpace,1>::Construct )
-,		SchemaEntry("ifcaxis2placement2d",&STEP::ObjectHelper<IfcAxis2Placement2D,1>::Construct )
-,		SchemaEntry("ifcspaceprogram",&STEP::ObjectHelper<IfcSpaceProgram,5>::Construct )
-,		SchemaEntry("ifcpoint",&STEP::ObjectHelper<IfcPoint,0>::Construct )
-,		SchemaEntry("ifccartesianpoint",&STEP::ObjectHelper<IfcCartesianPoint,1>::Construct )
-,		SchemaEntry("ifcboundedsurface",&STEP::ObjectHelper<IfcBoundedSurface,0>::Construct )
-,		SchemaEntry("ifcloop",&STEP::ObjectHelper<IfcLoop,0>::Construct )
-,		SchemaEntry("ifcpolyloop",&STEP::ObjectHelper<IfcPolyLoop,1>::Construct )
-,		SchemaEntry("ifcpredefinedpointmarkersymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcterminatorsymbol",&STEP::ObjectHelper<IfcTerminatorSymbol,1>::Construct )
-,		SchemaEntry("ifcdimensioncurveterminator",&STEP::ObjectHelper<IfcDimensionCurveTerminator,1>::Construct )
-,		SchemaEntry("ifcrelprojectselement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctrapeziumprofiledef",&STEP::ObjectHelper<IfcTrapeziumProfileDef,4>::Construct )
-,		SchemaEntry("ifcrepresentationcontext",&STEP::ObjectHelper<IfcRepresentationContext,2>::Construct )
-,		SchemaEntry("ifcgeometricrepresentationcontext",&STEP::ObjectHelper<IfcGeometricRepresentationContext,4>::Construct )
-,		SchemaEntry("ifctextstylewithboxcharacteristics",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurveboundedplane",&STEP::ObjectHelper<IfcCurveBoundedPlane,3>::Construct )
-,		SchemaEntry("ifcquantitycount",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctimeseriesreferencerelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadtemperature",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsiunit",&STEP::ObjectHelper<IfcSIUnit,2>::Construct )
-,		SchemaEntry("ifcstructuralreaction",&STEP::ObjectHelper<IfcStructuralReaction,0>::Construct )
-,		SchemaEntry("ifcstructuralpointreaction",&STEP::ObjectHelper<IfcStructuralPointReaction,0>::Construct )
-,		SchemaEntry("ifcaxis1placement",&STEP::ObjectHelper<IfcAxis1Placement,1>::Construct )
-,		SchemaEntry("ifcreinforcementdefinitionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelectricappliancetype",&STEP::ObjectHelper<IfcElectricApplianceType,1>::Construct )
-,		SchemaEntry("ifcsensortype",&STEP::ObjectHelper<IfcSensorType,1>::Construct )
-,		SchemaEntry("ifcfurnishingelement",&STEP::ObjectHelper<IfcFurnishingElement,0>::Construct )
-,		SchemaEntry("ifcprotectivedevicetype",&STEP::ObjectHelper<IfcProtectiveDeviceType,1>::Construct )
-,		SchemaEntry("ifczshapeprofiledef",&STEP::ObjectHelper<IfcZShapeProfileDef,6>::Construct )
-,		SchemaEntry("ifcscheduletimecontrol",&STEP::ObjectHelper<IfcScheduleTimeControl,18>::Construct )
-,		SchemaEntry("ifcrepresentationmap",&STEP::ObjectHelper<IfcRepresentationMap,2>::Construct )
-,		SchemaEntry("ifcclosedshell",&STEP::ObjectHelper<IfcClosedShell,0>::Construct )
-,		SchemaEntry("ifcbuildingelementpart",&STEP::ObjectHelper<IfcBuildingElementPart,0>::Construct )
-,		SchemaEntry("ifcdraughtingpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpostaladdress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcblock",&STEP::ObjectHelper<IfcBlock,3>::Construct )
-,		SchemaEntry("ifclightfixturetype",&STEP::ObjectHelper<IfcLightFixtureType,1>::Construct )
-,		SchemaEntry("ifcopeningelement",&STEP::ObjectHelper<IfcOpeningElement,0>::Construct )
-,		SchemaEntry("ifclightsourcespot",&STEP::ObjectHelper<IfcLightSourceSpot,4>::Construct )
-,		SchemaEntry("ifctendonanchor",&STEP::ObjectHelper<IfcTendonAnchor,0>::Construct )
-,		SchemaEntry("ifcsurfacestylerefraction",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelectricflowstoragedevicetype",&STEP::ObjectHelper<IfcElectricFlowStorageDeviceType,1>::Construct )
-,		SchemaEntry("ifcfluidflowproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsphere",&STEP::ObjectHelper<IfcSphere,1>::Construct )
-,		SchemaEntry("ifcrelassociatesappliedvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdampertype",&STEP::ObjectHelper<IfcDamperType,1>::Construct )
-,		SchemaEntry("ifcprojectorderrecord",&STEP::ObjectHelper<IfcProjectOrderRecord,2>::Construct )
-,		SchemaEntry("ifcdimensionalexponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreldefinesbytype",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdistributionchamberelement",&STEP::ObjectHelper<IfcDistributionChamberElement,0>::Construct )
-,		SchemaEntry("ifcmechanicalfastener",&STEP::ObjectHelper<IfcMechanicalFastener,2>::Construct )
-,		SchemaEntry("ifcquantityvolume",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrectangulartrimmedsurface",&STEP::ObjectHelper<IfcRectangularTrimmedSurface,7>::Construct )
-,		SchemaEntry("ifcdateandtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifczone",&STEP::ObjectHelper<IfcZone,0>::Construct )
-,		SchemaEntry("ifcfantype",&STEP::ObjectHelper<IfcFanType,1>::Construct )
-,		SchemaEntry("ifcgeometricset",&STEP::ObjectHelper<IfcGeometricSet,1>::Construct )
-,		SchemaEntry("ifcfillareastyletiles",&STEP::ObjectHelper<IfcFillAreaStyleTiles,3>::Construct )
-,		SchemaEntry("ifcpixeltexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccablesegmenttype",&STEP::ObjectHelper<IfcCableSegmentType,1>::Construct )
-,		SchemaEntry("ifcreloverridesproperties",&STEP::ObjectHelper<IfcRelOverridesProperties,1>::Construct )
-,		SchemaEntry("ifcmeasurewithunit",&STEP::ObjectHelper<IfcMeasureWithUnit,2>::Construct )
-,		SchemaEntry("ifcslabtype",&STEP::ObjectHelper<IfcSlabType,1>::Construct )
-,		SchemaEntry("ifcservicelife",&STEP::ObjectHelper<IfcServiceLife,2>::Construct )
-,		SchemaEntry("ifcfurnituretype",&STEP::ObjectHelper<IfcFurnitureType,1>::Construct )
-,		SchemaEntry("ifccostitem",&STEP::ObjectHelper<IfcCostItem,0>::Construct )
-,		SchemaEntry("ifcreinforcingmesh",&STEP::ObjectHelper<IfcReinforcingMesh,8>::Construct )
-,		SchemaEntry("ifcextendedmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcactorrole",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfacetedbrepwithvoids",&STEP::ObjectHelper<IfcFacetedBrepWithVoids,1>::Construct )
-,		SchemaEntry("ifcconstraintaggregationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcgasterminaltype",&STEP::ObjectHelper<IfcGasTerminalType,1>::Construct )
-,		SchemaEntry("ifcrelconnectswitheccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpile",&STEP::ObjectHelper<IfcPile,2>::Construct )
-,		SchemaEntry("ifcfillareastyletilesymbolwithstyle",&STEP::ObjectHelper<IfcFillAreaStyleTileSymbolWithStyle,1>::Construct )
-,		SchemaEntry("ifcelectricalbaseproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconstructionmaterialresource",&STEP::ObjectHelper<IfcConstructionMaterialResource,2>::Construct )
-,		SchemaEntry("ifcannotationcurveoccurrence",&STEP::ObjectHelper<IfcAnnotationCurveOccurrence,0>::Construct )
-,		SchemaEntry("ifcdimensioncurve",&STEP::ObjectHelper<IfcDimensionCurve,0>::Construct )
-,		SchemaEntry("ifcgeometriccurveset",&STEP::ObjectHelper<IfcGeometricCurveSet,0>::Construct )
-,		SchemaEntry("ifcrelaggregates",&STEP::ObjectHelper<IfcRelAggregates,0>::Construct )
-,		SchemaEntry("ifcfacebasedsurfacemodel",&STEP::ObjectHelper<IfcFaceBasedSurfaceModel,1>::Construct )
-,		SchemaEntry("ifcenergyconversiondevice",&STEP::ObjectHelper<IfcEnergyConversionDevice,0>::Construct )
-,		SchemaEntry("ifcrampflight",&STEP::ObjectHelper<IfcRampFlight,0>::Construct )
-,		SchemaEntry("ifcpropertyenumeration",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcvertexloop",&STEP::ObjectHelper<IfcVertexLoop,1>::Construct )
-,		SchemaEntry("ifcplate",&STEP::ObjectHelper<IfcPlate,0>::Construct )
-,		SchemaEntry("ifcushapeprofiledef",&STEP::ObjectHelper<IfcUShapeProfileDef,8>::Construct )
-,		SchemaEntry("ifchygroscopicmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfacebound",&STEP::ObjectHelper<IfcFaceBound,2>::Construct )
-,		SchemaEntry("ifcfaceouterbound",&STEP::ObjectHelper<IfcFaceOuterBound,0>::Construct )
-,		SchemaEntry("ifconedirectionrepeatfactor",&STEP::ObjectHelper<IfcOneDirectionRepeatFactor,1>::Construct )
-,		SchemaEntry("ifcboilertype",&STEP::ObjectHelper<IfcBoilerType,1>::Construct )
-,		SchemaEntry("ifcconstructionequipmentresource",&STEP::ObjectHelper<IfcConstructionEquipmentResource,0>::Construct )
-,		SchemaEntry("ifccomplexproperty",&STEP::ObjectHelper<IfcComplexProperty,2>::Construct )
-,		SchemaEntry("ifcfooting",&STEP::ObjectHelper<IfcFooting,1>::Construct )
-,		SchemaEntry("ifcopticalmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconstructionproductresource",&STEP::ObjectHelper<IfcConstructionProductResource,0>::Construct )
-,		SchemaEntry("ifcboundaryedgecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcderivedprofiledef",&STEP::ObjectHelper<IfcDerivedProfileDef,3>::Construct )
-,		SchemaEntry("ifcpropertytablevalue",&STEP::ObjectHelper<IfcPropertyTableValue,5>::Construct )
-,		SchemaEntry("ifcrelassignstogroup",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcflowmetertype",&STEP::ObjectHelper<IfcFlowMeterType,1>::Construct )
-,		SchemaEntry("ifcdoorstyle",&STEP::ObjectHelper<IfcDoorStyle,4>::Construct )
-,		SchemaEntry("ifcrelconnectsporttoelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcunitassignment",&STEP::ObjectHelper<IfcUnitAssignment,1>::Construct )
-,		SchemaEntry("ifcflowterminal",&STEP::ObjectHelper<IfcFlowTerminal,0>::Construct )
-,		SchemaEntry("ifccranerailfshapeprofiledef",&STEP::ObjectHelper<IfcCraneRailFShapeProfileDef,9>::Construct )
-,		SchemaEntry("ifcflowsegment",&STEP::ObjectHelper<IfcFlowSegment,0>::Construct )
-,		SchemaEntry("ifcelementquantity",&STEP::ObjectHelper<IfcElementQuantity,2>::Construct )
-,		SchemaEntry("ifcboundarynodecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboundarynodeconditionwarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurtainwall",&STEP::ObjectHelper<IfcCurtainWall,0>::Construct )
-,		SchemaEntry("ifcdiscreteaccessory",&STEP::ObjectHelper<IfcDiscreteAccessory,0>::Construct )
-,		SchemaEntry("ifcgrid",&STEP::ObjectHelper<IfcGrid,3>::Construct )
-,		SchemaEntry("ifcsanitaryterminaltype",&STEP::ObjectHelper<IfcSanitaryTerminalType,1>::Construct )
-,		SchemaEntry("ifcsoundproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsubedge",&STEP::ObjectHelper<IfcSubedge,1>::Construct )
-,		SchemaEntry("ifctextstyletextmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfiltertype",&STEP::ObjectHelper<IfcFilterType,1>::Construct )
-,		SchemaEntry("ifcsymbolstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctendon",&STEP::ObjectHelper<IfcTendon,8>::Construct )
-,		SchemaEntry("ifcdimensionpair",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadgroup",&STEP::ObjectHelper<IfcStructuralLoadGroup,5>::Construct )
-,		SchemaEntry("ifcpresentationstyleassignment",&STEP::ObjectHelper<IfcPresentationStyleAssignment,1>::Construct )
-,		SchemaEntry("ifcregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralcurvemember",&STEP::ObjectHelper<IfcStructuralCurveMember,1>::Construct )
-,		SchemaEntry("ifclightsourceambient",&STEP::ObjectHelper<IfcLightSourceAmbient,0>::Construct )
-,		SchemaEntry("ifccondition",&STEP::ObjectHelper<IfcCondition,0>::Construct )
-,		SchemaEntry("ifcport",&STEP::ObjectHelper<IfcPort,0>::Construct )
-,		SchemaEntry("ifcspace",&STEP::ObjectHelper<IfcSpace,2>::Construct )
-,		SchemaEntry("ifcheatexchangertype",&STEP::ObjectHelper<IfcHeatExchangerType,1>::Construct )
-,		SchemaEntry("ifctanktype",&STEP::ObjectHelper<IfcTankType,1>::Construct )
-,		SchemaEntry("ifcinventory",&STEP::ObjectHelper<IfcInventory,6>::Construct )
-,		SchemaEntry("ifctextstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcappliedvaluerelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsoundvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctransportelementtype",&STEP::ObjectHelper<IfcTransportElementType,1>::Construct )
-,		SchemaEntry("ifcairtoairheatrecoverytype",&STEP::ObjectHelper<IfcAirToAirHeatRecoveryType,1>::Construct )
-,		SchemaEntry("ifcstairflight",&STEP::ObjectHelper<IfcStairFlight,4>::Construct )
-,		SchemaEntry("ifcelectricalelement",&STEP::ObjectHelper<IfcElectricalElement,0>::Construct )
-,		SchemaEntry("ifclightintensitydistribution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcclassificationreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacestylewithtextures",&STEP::ObjectHelper<IfcSurfaceStyleWithTextures,1>::Construct )
-,		SchemaEntry("ifcboundingbox",&STEP::ObjectHelper<IfcBoundingBox,4>::Construct )
-,		SchemaEntry("ifcapplication",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwalltype",&STEP::ObjectHelper<IfcWallType,1>::Construct )
-,		SchemaEntry("ifcmove",&STEP::ObjectHelper<IfcMove,3>::Construct )
-,		SchemaEntry("ifccircle",&STEP::ObjectHelper<IfcCircle,1>::Construct )
-,		SchemaEntry("ifcoffsetcurve2d",&STEP::ObjectHelper<IfcOffsetCurve2D,3>::Construct )
-,		SchemaEntry("ifcmateriallayersetusage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpointoncurve",&STEP::ObjectHelper<IfcPointOnCurve,2>::Construct )
-,		SchemaEntry("ifcstructuralresultgroup",&STEP::ObjectHelper<IfcStructuralResultGroup,3>::Construct )
-,		SchemaEntry("ifcsectionedspine",&STEP::ObjectHelper<IfcSectionedSpine,3>::Construct )
-,		SchemaEntry("ifcslab",&STEP::ObjectHelper<IfcSlab,1>::Construct )
-,		SchemaEntry("ifcconnectionportgeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantityweight",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcvertex",&STEP::ObjectHelper<IfcVertex,0>::Construct )
-,		SchemaEntry("ifcvertexpoint",&STEP::ObjectHelper<IfcVertexPoint,1>::Construct )
-,		SchemaEntry("ifcreferencesvaluedocument",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpersonandorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelflowcontrolelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstoprocess",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructurallinearaction",&STEP::ObjectHelper<IfcStructuralLinearAction,1>::Construct )
-,		SchemaEntry("ifcstructurallinearactionvarying",&STEP::ObjectHelper<IfcStructuralLinearActionVarying,2>::Construct )
-,		SchemaEntry("ifcbuildingelementproxytype",&STEP::ObjectHelper<IfcBuildingElementProxyType,1>::Construct )
-,		SchemaEntry("ifcprojectionelement",&STEP::ObjectHelper<IfcProjectionElement,0>::Construct )
-,		SchemaEntry("ifcderivedunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcapprovalactorrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconversionbasedunit",&STEP::ObjectHelper<IfcConversionBasedUnit,2>::Construct )
-,		SchemaEntry("ifcmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcgeometricrepresentationsubcontext",&STEP::ObjectHelper<IfcGeometricRepresentationSubContext,4>::Construct )
-,		SchemaEntry("ifcannotationsurfaceoccurrence",&STEP::ObjectHelper<IfcAnnotationSurfaceOccurrence,0>::Construct )
-,		SchemaEntry("ifcpredefineddimensionsymbol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcroundededgefeature",&STEP::ObjectHelper<IfcRoundedEdgeFeature,1>::Construct )
-,		SchemaEntry("ifcrelcoversbldgelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelectricdistributionpoint",&STEP::ObjectHelper<IfcElectricDistributionPoint,2>::Construct )
-,		SchemaEntry("ifccablecarriersegmenttype",&STEP::ObjectHelper<IfcCableCarrierSegmentType,1>::Construct )
-,		SchemaEntry("ifcstructuralloadlinearforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcgridaxis",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcirregulartimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwallstandardcase",&STEP::ObjectHelper<IfcWallStandardCase,0>::Construct )
-,		SchemaEntry("ifcreloccupiesspaces",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcderivedunitelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccsgsolid",&STEP::ObjectHelper<IfcCsgSolid,1>::Construct )
-,		SchemaEntry("ifcbeamtype",&STEP::ObjectHelper<IfcBeamType,1>::Construct )
-,		SchemaEntry("ifcannotationfillarea",&STEP::ObjectHelper<IfcAnnotationFillArea,2>::Construct )
-,		SchemaEntry("ifcrelaxation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralcurvemembervarying",&STEP::ObjectHelper<IfcStructuralCurveMemberVarying,0>::Construct )
-,		SchemaEntry("ifcpointonsurface",&STEP::ObjectHelper<IfcPointOnSurface,3>::Construct )
-,		SchemaEntry("ifcpropertydependencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcvertexbasedtexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcorderaction",&STEP::ObjectHelper<IfcOrderAction,1>::Construct )
-,		SchemaEntry("ifclibraryreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcedgeloop",&STEP::ObjectHelper<IfcEdgeLoop,1>::Construct )
-,		SchemaEntry("ifcannotationfillareaoccurrence",&STEP::ObjectHelper<IfcAnnotationFillAreaOccurrence,2>::Construct )
-,		SchemaEntry("ifcrelconnectsstructuralelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcworkplan",&STEP::ObjectHelper<IfcWorkPlan,0>::Construct )
-,		SchemaEntry("ifcellipse",&STEP::ObjectHelper<IfcEllipse,2>::Construct )
-,		SchemaEntry("ifcproductdefinitionshape",&STEP::ObjectHelper<IfcProductDefinitionShape,0>::Construct )
-,		SchemaEntry("ifcprojectioncurve",&STEP::ObjectHelper<IfcProjectionCurve,0>::Construct )
-,		SchemaEntry("ifcelectricalcircuit",&STEP::ObjectHelper<IfcElectricalCircuit,0>::Construct )
-,		SchemaEntry("ifcrationalbeziercurve",&STEP::ObjectHelper<IfcRationalBezierCurve,1>::Construct )
-,		SchemaEntry("ifcstructuralpointaction",&STEP::ObjectHelper<IfcStructuralPointAction,0>::Construct )
-,		SchemaEntry("ifcservicelifefactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcthermalmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctexturecoordinategenerator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpipesegmenttype",&STEP::ObjectHelper<IfcPipeSegmentType,1>::Construct )
-,		SchemaEntry("ifctwodirectionrepeatfactor",&STEP::ObjectHelper<IfcTwoDirectionRepeatFactor,1>::Construct )
-,		SchemaEntry("ifcshaperepresentation",&STEP::ObjectHelper<IfcShapeRepresentation,0>::Construct )
-,		SchemaEntry("ifcpropertyset",&STEP::ObjectHelper<IfcPropertySet,1>::Construct )
-,		SchemaEntry("ifcsurfacestylerendering",&STEP::ObjectHelper<IfcSurfaceStyleRendering,8>::Construct )
-,		SchemaEntry("ifcdistributionport",&STEP::ObjectHelper<IfcDistributionPort,1>::Construct )
-,		SchemaEntry("ifcimagetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpipefittingtype",&STEP::ObjectHelper<IfcPipeFittingType,1>::Construct )
-,		SchemaEntry("ifctransportelement",&STEP::ObjectHelper<IfcTransportElement,3>::Construct )
-,		SchemaEntry("ifcannotationtextoccurrence",&STEP::ObjectHelper<IfcAnnotationTextOccurrence,0>::Construct )
-,		SchemaEntry("ifcconnectionsurfacegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralanalysismodel",&STEP::ObjectHelper<IfcStructuralAnalysisModel,4>::Construct )
-,		SchemaEntry("ifcconnectioncurvegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconditioncriterion",&STEP::ObjectHelper<IfcConditionCriterion,2>::Construct )
-,		SchemaEntry("ifcwaterproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmateriallayer",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccostvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-
-	};
-}
-
-// -----------------------------------------------------------------------------------------------------------
-void IFC::Schema_2x3::GetSchema(EXPRESS::ConversionSchema& out) {
-	out = EXPRESS::ConversionSchema(schema_raw_2x3);
-}
-
-namespace STEP {
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<NotImplemented>(const STEP::DB& /*db*/, const LIST& /*params*/, NotImplemented* /*in*/)
-{
-	return 0;
-}
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoot* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); }    do { // convert the 'GlobalId' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->GlobalId, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
-    } while(0);
-    do { // convert the 'OwnerHistory' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->OwnerHistory, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
-    } while(0);
-    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRoot,4>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcObjectDefinition>(const DB& db, const LIST& params, IfcObjectDefinition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcObjectDefinition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTypeObject>(const DB& db, const LIST& params, IfcTypeObject* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTypeProduct>(const DB& db, const LIST& params, IfcTypeProduct* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementType>(const DB& db, const LIST& params, IfcElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionElementType>(const DB& db, const LIST& params, IfcDistributionElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionFlowElementType>(const DB& db, const LIST& params, IfcDistributionFlowElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowControllerType>(const DB& db, const LIST& params, IfcFlowControllerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricTimeControlType>(const DB& db, const LIST& params, IfcElectricTimeControlType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& params, IfcRepresentation* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); }    do { // convert the 'ContextOfItems' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ContextOfItems, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
-    } while(0);
-    do { // convert the 'RepresentationIdentifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'RepresentationType' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Items' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->Items, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShapeModel>(const DB& db, const LIST& params, IfcShapeModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTopologyRepresentation>(const DB& db, const LIST& params, IfcTopologyRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelationship>(const DB& db, const LIST& params, IfcRelationship* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelConnects>(const DB& db, const LIST& params, IfcRelConnects* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelConnects"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowFittingType>(const DB& db, const LIST& params, IfcFlowFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableCarrierFittingType>(const DB& db, const LIST& params, IfcCableCarrierFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEnergyConversionDeviceType>(const DB& db, const LIST& params, IfcEnergyConversionDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoilType>(const DB& db, const LIST& params, IfcCoilType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcObject* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcObject"); }    do { // convert the 'ObjectType' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcObject,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcControl>(const DB& db, const LIST& params, IfcControl* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPerformanceHistory>(const DB& db, const LIST& params, IfcPerformanceHistory* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentationItem>(const DB& /*db*/, const LIST& /*params*/, IfcRepresentationItem* /*in*/)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricRepresentationItem>(const DB& db, const LIST& params, IfcGeometricRepresentationItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTextLiteral>(const DB& db, const LIST& params, IfcTextLiteral* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTextLiteralWithExtent>(const DB& db, const LIST& params, IfcTextLiteralWithExtent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTextLiteral*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIST& params, IfcProductRepresentation* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcProductRepresentation"); }    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
-    } while(0);
-    do { // convert the 'Representations' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->Representations, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, IfcProduct* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcProduct"); }    do { // convert the 'ObjectPlacement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectPlacement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
-    } while(0);
-    do { // convert the 'Representation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProduct,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Representation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, IfcElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcElement"); }    do { // convert the 'Tag' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElement,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Tag, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionElement>(const DB& db, const LIST& params, IfcDistributionElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionFlowElement>(const DB& db, const LIST& params, IfcDistributionFlowElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurve>(const DB& db, const LIST& params, IfcCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundedCurve>(const DB& db, const LIST& params, IfcBoundedCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& params, IfcCompositeCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); }    do { // convert the 'Segments' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Segments, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
-    } while(0);
-    do { // convert the 'SelfIntersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `LOGICAL`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<Ifc2DCompositeCurve>(const DB& db, const LIST& params, Ifc2DCompositeCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db, const LIST& params, IfcCartesianTransformationOperator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCartesianTransformationOperator"); }    do { // convert the 'Axis1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis1, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'Axis2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'LocalOrigin' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->LocalOrigin, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'Scale' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `REAL`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCartesianTransformationOperator3D"); }    do { // convert the 'Axis3' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis3, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, IfcProperty* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); }    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
-    } while(0);
-    do { // convert the 'Description' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProperty,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSimpleProperty>(const DB& db, const LIST& params, IfcSimpleProperty* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSimpleProperty"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyEnumeratedValue>(const DB& db, const LIST& params, IfcPropertyEnumeratedValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementType>(const DB& db, const LIST& params, IfcBuildingElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStairFlightType>(const DB& db, const LIST& params, IfcStairFlightType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurface>(const DB& db, const LIST& params, IfcSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& params, IfcElementarySurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); }    do { // convert the 'Position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlane>(const DB& db, const LIST& params, IfcPlane* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlane"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& params, IfcBooleanResult* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); }    do { // convert the 'Operator' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Operator, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
-    } while(0);
-    do { // convert the 'FirstOperand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->FirstOperand, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
-    } while(0);
-    do { // convert the 'SecondOperand' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->SecondOperand, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBooleanClippingResult>(const DB& db, const LIST& params, IfcBooleanClippingResult* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBooleanResult*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanClippingResult"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSolidModel>(const DB& db, const LIST& params, IfcSolidModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& params, IfcManifoldSolidBrep* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); }    do { // convert the 'Outer' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Outer, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTerminalType>(const DB& db, const LIST& params, IfcFlowTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStackTerminalType>(const DB& db, const LIST& params, IfcStackTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralItem>(const DB& db, const LIST& params, IfcStructuralItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralConnection>(const DB& db, const LIST& params, IfcStructuralConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveConnection>(const DB& db, const LIST& params, IfcStructuralCurveConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcJunctionBoxType>(const DB& db, const LIST& params, IfcJunctionBoxType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyDefinition>(const DB& db, const LIST& params, IfcPropertyDefinition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyDefinition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertySetDefinition>(const DB& db, const LIST& params, IfcPropertySetDefinition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertyDefinition*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySetDefinition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProcess>(const DB& db, const LIST& params, IfcProcess* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTask>(const DB& db, const LIST& params, IfcTask* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelFillsElement>(const DB& db, const LIST& params, IfcRelFillsElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); }    do { // convert the 'RelatingOpeningElement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); }
-    } while(0);
-    do { // convert the 'RelatedBuildingElement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProcedure>(const DB& db, const LIST& params, IfcProcedure* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProxy>(const DB& db, const LIST& params, IfcProxy* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcResource>(const DB& db, const LIST& params, IfcResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionResource>(const DB& db, const LIST& params, IfcConstructionResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSubContractResource>(const DB& db, const LIST& params, IfcSubContractResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db, const LIST& params, IfcRelContainedInSpatialStructure* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); }    do { // convert the 'RelatedElements' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedElements, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); }
-    } while(0);
-    do { // convert the 'RelatingStructure' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingStructure, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialStructureElement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTopologicalRepresentationItem>(const DB& db, const LIST& params, IfcTopologicalRepresentationItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdge>(const DB& db, const LIST& params, IfcEdge* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdgeCurve>(const DB& db, const LIST& params, IfcEdgeCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlateType>(const DB& db, const LIST& params, IfcPlateType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcObjectPlacement>(const DB& /*db*/, const LIST& /*params*/, IfcObjectPlacement* /*in*/)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGridPlacement>(const DB& db, const LIST& params, IfcGridPlacement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectPlacement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFireSuppressionTerminalType>(const DB& db, const LIST& params, IfcFireSuppressionTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowStorageDevice>(const DB& db, const LIST& params, IfcFlowStorageDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptSurface>(const DB& db, const LIST& params, IfcSweptSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceOfRevolution>(const DB& db, const LIST& params, IfcSurfaceOfRevolution* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOrientedEdge>(const DB& db, const LIST& params, IfcOrientedEdge* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDirection>(const DB& db, const LIST& params, IfcDirection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); }    do { // convert the 'DirectionRatios' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->DirectionRatios, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF REAL`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params, IfcProfileDef* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); }    do { // convert the 'ProfileType' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ProfileType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
-    } while(0);
-    do { // convert the 'ProfileName' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ProfileName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const LIST& params, IfcParameterizedProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); }    do { // convert the 'Position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCShapeProfileDef>(const DB& db, const LIST& params, IfcCShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFeatureElement>(const DB& db, const LIST& params, IfcFeatureElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcFeatureElement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFeatureElementSubtraction>(const DB& db, const LIST& params, IfcFeatureElementSubtraction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcFeatureElementSubtraction"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdgeFeature>(const DB& db, const LIST& params, IfcEdgeFeature* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcChamferEdgeFeature>(const DB& db, const LIST& params, IfcChamferEdgeFeature* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdgeFeature*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElement>(const DB& db, const LIST& params, IfcBuildingElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcBuildingElement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColumn>(const DB& db, const LIST& params, IfcColumn* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyReferenceValue>(const DB& db, const LIST& params, IfcPropertyReferenceValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricMotorType>(const DB& db, const LIST& params, IfcElectricMotorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialStructureElementType>(const DB& db, const LIST& params, IfcSpatialStructureElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpaceType>(const DB& db, const LIST& params, IfcSpaceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColumnType>(const DB& db, const LIST& params, IfcColumnType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCraneRailAShapeProfileDef>(const DB& db, const LIST& params, IfcCraneRailAShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCondenserType>(const DB& db, const LIST& params, IfcCondenserType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& params, IfcCircleProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); }    do { // convert the 'Radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Radius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCircleHollowProfileDef>(const DB& db, const LIST& params, IfcCircleHollowProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); }    do { // convert the 'WallThickness' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->WallThickness, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, IfcPlacement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); }    do { // convert the 'Location' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPlacement,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Location, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAxis2Placement3D>(const DB& db, const LIST& params, IfcAxis2Placement3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); }    do { // convert the 'Axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'RefDirection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& params, IfcPresentationStyle* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyle"); }    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEquipmentElement>(const DB& db, const LIST& params, IfcEquipmentElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeCurveSegment>(const DB& db, const LIST& params, IfcCompositeCurveSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); }    do { // convert the 'Transition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Transition, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); }
-    } while(0);
-    do { // convert the 'SameSense' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SameSense, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `BOOLEAN`")); }
-    } while(0);
-    do { // convert the 'ParentCurve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ParentCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST& params, IfcRectangleProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); }    do { // convert the 'XDim' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->XDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'YDim' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->YDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementProxy>(const DB& db, const LIST& params, IfcBuildingElementProxy* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionControlElementType>(const DB& db, const LIST& params, IfcDistributionControlElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowInstrumentType>(const DB& db, const LIST& params, IfcFlowInstrumentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDraughtingCallout>(const DB& db, const LIST& params, IfcDraughtingCallout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDimensionCurveDirectedCallout>(const DB& db, const LIST& params, IfcDimensionCurveDirectedCallout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDraughtingCallout*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLinearDimension>(const DB& db, const LIST& params, IfcLinearDimension* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementAssembly>(const DB& db, const LIST& params, IfcElementAssembly* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCsgPrimitive3D>(const DB& db, const LIST& params, IfcCsgPrimitive3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRightCircularCone>(const DB& db, const LIST& params, IfcRightCircularCone* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectOrder>(const DB& db, const LIST& params, IfcProjectOrder* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLShapeProfileDef>(const DB& db, const LIST& params, IfcLShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAngularDimension>(const DB& db, const LIST& params, IfcAngularDimension* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLocalPlacement>(const DB& db, const LIST& params, IfcLocalPlacement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectPlacement*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); }    do { // convert the 'PlacementRelTo' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PlacementRelTo, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); }
-    } while(0);
-    do { // convert the 'RelativePlacement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelativePlacement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& params, IfcSweptAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); }    do { // convert the 'SweptArea' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SweptArea, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
-    } while(0);
-    do { // convert the 'Position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRevolvedAreaSolid>(const DB& db, const LIST& params, IfcRevolvedAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); }    do { // convert the 'Axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Axis, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); }
-    } while(0);
-    do { // convert the 'Angle' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Angle, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceConnection>(const DB& db, const LIST& params, IfcStructuralSurfaceConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRadiusDimension>(const DB& db, const LIST& params, IfcRadiusDimension* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptDiskSolid>(const DB& db, const LIST& params, IfcSweptDiskSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); }    do { // convert the 'Directrix' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Directrix, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); }
-    } while(0);
-    do { // convert the 'Radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Radius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'InnerRadius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->InnerRadius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'StartParam' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->StartParam, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
-    } while(0);
-    do { // convert the 'EndParam' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->EndParam, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& params, IfcHalfSpaceSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); }    do { // convert the 'BaseSurface' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->BaseSurface, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
-    } while(0);
-    do { // convert the 'AgreementFlag' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->AgreementFlag, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `BOOLEAN`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolygonalBoundedHalfSpace>(const DB& db, const LIST& params, IfcPolygonalBoundedHalfSpace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); }    do { // convert the 'Position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); }
-    } while(0);
-    do { // convert the 'PolygonalBoundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTimeSeriesSchedule>(const DB& db, const LIST& params, IfcTimeSeriesSchedule* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCooledBeamType>(const DB& db, const LIST& params, IfcCooledBeamType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProject>(const DB& db, const LIST& params, IfcProject* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); }    do { // convert the 'LongName' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProject to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Phase' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Phase, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProject to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'RepresentationContexts' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RepresentationContexts, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcProject to be a `SET [1:?] OF IfcRepresentationContext`")); }
-    } while(0);
-    do { // convert the 'UnitsInContext' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UnitsInContext, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcProject to be a `IfcUnitAssignment`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvaporatorType>(const DB& db, const LIST& params, IfcEvaporatorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLaborResource>(const DB& db, const LIST& params, IfcLaborResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyBoundedValue>(const DB& db, const LIST& params, IfcPropertyBoundedValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRampFlightType>(const DB& db, const LIST& params, IfcRampFlightType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMember>(const DB& db, const LIST& params, IfcMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTubeBundleType>(const DB& db, const LIST& params, IfcTubeBundleType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcValveType>(const DB& db, const LIST& params, IfcValveType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTrimmedCurve>(const DB& db, const LIST& params, IfcTrimmedCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); }    do { // convert the 'BasisCurve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->BasisCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); }
-    } while(0);
-    do { // convert the 'Trim1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim1, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
-    } while(0);
-    do { // convert the 'Trim2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
-    } while(0);
-    do { // convert the 'SenseAgreement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SenseAgreement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `BOOLEAN`")); }
-    } while(0);
-    do { // convert the 'MasterRepresentation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MasterRepresentation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params, IfcRelDefines* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRelDefines"); }    do { // convert the 'RelatedObjects' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefines,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefines to be a `SET [1:?] OF IfcObject`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LIST& params, IfcRelDefinesByProperties* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelDefines*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); }    do { // convert the 'RelatingPropertyDefinition' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDefinesByProperties,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinition`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActor>(const DB& db, const LIST& params, IfcActor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOccupant>(const DB& db, const LIST& params, IfcOccupant* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcActor*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHumidifierType>(const DB& db, const LIST& params, IfcHumidifierType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const LIST& params, IfcArbitraryOpenProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); }    do { // convert the 'Curve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Curve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPermit>(const DB& db, const LIST& params, IfcPermit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOffsetCurve3D>(const DB& db, const LIST& params, IfcOffsetCurve3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSource>(const DB& db, const LIST& params, IfcLightSource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourcePositional>(const DB& db, const LIST& params, IfcLightSourcePositional* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeProfileDef>(const DB& db, const LIST& params, IfcCompositeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRamp>(const DB& db, const LIST& params, IfcRamp* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMovingDevice>(const DB& db, const LIST& params, IfcFlowMovingDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpaceHeaterType>(const DB& db, const LIST& params, IfcSpaceHeaterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLampType>(const DB& db, const LIST& params, IfcLampType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementComponent>(const DB& db, const LIST& params, IfcBuildingElementComponent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingElement>(const DB& db, const LIST& params, IfcReinforcingElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingBar>(const DB& db, const LIST& params, IfcReinforcingBar* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricHeaterType>(const DB& db, const LIST& params, IfcElectricHeaterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTShapeProfileDef>(const DB& db, const LIST& params, IfcTShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralActivity>(const DB& db, const LIST& params, IfcStructuralActivity* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralAction>(const DB& db, const LIST& params, IfcStructuralAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctFittingType>(const DB& db, const LIST& params, IfcDuctFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator2D>(const DB& db, const LIST& params, IfcCartesianTransformationOperator2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator2DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator2DnonUniform* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator2D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVirtualElement>(const DB& db, const LIST& params, IfcVirtualElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRightCircularCylinder>(const DB& db, const LIST& params, IfcRightCircularCylinder* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOutletType>(const DB& db, const LIST& params, IfcOutletType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelDecomposes>(const DB& db, const LIST& params, IfcRelDecomposes* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDecomposes"); }    do { // convert the 'RelatingObject' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->RelatingObject, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDecomposes to be a `IfcObjectDefinition`")); }
-    } while(0);
-    do { // convert the 'RelatedObjects' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRelDecomposes,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDecomposes to be a `SET [1:?] OF IfcObjectDefinition`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCovering>(const DB& db, const LIST& params, IfcCovering* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolyline>(const DB& db, const LIST& params, IfcPolyline* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); }    do { // convert the 'Points' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Points, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPath>(const DB& db, const LIST& params, IfcPath* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementComponent>(const DB& db, const LIST& params, IfcElementComponent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFastener>(const DB& db, const LIST& params, IfcFastener* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMappedItem>(const DB& db, const LIST& params, IfcMappedItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); }    do { // convert the 'MappingSource' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingSource, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); }
-    } while(0);
-    do { // convert the 'MappingTarget' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingTarget, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangularPyramid>(const DB& db, const LIST& params, IfcRectangularPyramid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCrewResource>(const DB& db, const LIST& params, IfcCrewResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, IfcNamedUnit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcNamedUnit"); }    do { // convert the 'Dimensions' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-		if (dynamic_cast<const UNSET*>(&*arg)) break;
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Dimensions, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
-    } while(0);
-    do { // convert the 'UnitType' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->UnitType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcContextDependentUnit>(const DB& db, const LIST& params, IfcContextDependentUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitaryEquipmentType>(const DB& db, const LIST& params, IfcUnitaryEquipmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoof>(const DB& db, const LIST& params, IfcRoof* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralMember>(const DB& db, const LIST& params, IfcStructuralMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStyleModel>(const DB& db, const LIST& params, IfcStyleModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStyledRepresentation>(const DB& db, const LIST& params, IfcStyledRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStyleModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const LIST& params, IfcSpatialStructureElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSpatialStructureElement"); }    do { // convert the 'LongName' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialStructureElement to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'CompositionType' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSpatialStructureElement,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->CompositionType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuilding>(const DB& db, const LIST& params, IfcBuilding* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); }    do { // convert the 'ElevationOfRefHeight' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'ElevationOfTerrain' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'BuildingAddress' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->BuildingAddress, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& params, IfcConnectedFaceSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); }    do { // convert the 'CfsFaces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CfsFaces, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOpenShell>(const DB& db, const LIST& params, IfcOpenShell* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFacetedBrep>(const DB& db, const LIST& params, IfcFacetedBrep* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcConic* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); }    do { // convert the 'Position' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcConic,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoveringType>(const DB& db, const LIST& params, IfcCoveringType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoundedRectangleProfileDef>(const DB& db, const LIST& params, IfcRoundedRectangleProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirTerminalType>(const DB& db, const LIST& params, IfcAirTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMovingDeviceType>(const DB& db, const LIST& params, IfcFlowMovingDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompressorType>(const DB& db, const LIST& params, IfcCompressorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& params, IfcIShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcIShapeProfileDef"); }    do { // convert the 'OverallWidth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->OverallWidth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'OverallDepth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->OverallDepth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'WebThickness' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->WebThickness, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'FlangeThickness' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->FlangeThickness, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'FilletRadius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcIShapeProfileDef,5>::aux_is_derived[4]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FilletRadius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAsymmetricIShapeProfileDef>(const DB& db, const LIST& params, IfcAsymmetricIShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcIShapeProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcControllerType>(const DB& db, const LIST& params, IfcControllerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRailing>(const DB& db, const LIST& params, IfcRailing* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGroup>(const DB& db, const LIST& params, IfcGroup* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAsset>(const DB& db, const LIST& params, IfcAsset* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMaterialDefinitionRepresentation>(const DB& db, const LIST& params, IfcMaterialDefinitionRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRailingType>(const DB& db, const LIST& params, IfcRailingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWall>(const DB& db, const LIST& params, IfcWall* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPointConnection>(const DB& db, const LIST& params, IfcStructuralPointConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyListValue>(const DB& db, const LIST& params, IfcPropertyListValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); }    do { // convert the 'ListValues' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ListValues, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); }
-    } while(0);
-    do { // convert the 'Unit' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnitureStandard>(const DB& db, const LIST& params, IfcFurnitureStandard* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricGeneratorType>(const DB& db, const LIST& params, IfcElectricGeneratorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDoor>(const DB& db, const LIST& params, IfcDoor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-	if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcDoor"); }    do { // convert the 'OverallHeight' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallHeight, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'OverallWidth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallWidth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params, IfcStyledItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcStyledItem"); }    do { // convert the 'Item' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Item, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
-    } while(0);
-    do { // convert the 'Styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Styles, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcPresentationStyleAssignment`")); }
-    } while(0);
-    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcStyledItem,3>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationOccurrence>(const DB& db, const LIST& params, IfcAnnotationOccurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStyledItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationSymbolOccurrence>(const DB& db, const LIST& params, IfcAnnotationSymbolOccurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const LIST& params, IfcArbitraryClosedProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); }    do { // convert the 'OuterCurve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->OuterCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcArbitraryProfileDefWithVoids>(const DB& db, const LIST& params, IfcArbitraryProfileDefWithVoids* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcArbitraryClosedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLine>(const DB& db, const LIST& params, IfcLine* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); }    do { // convert the 'Pnt' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Pnt, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'Dir' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Dir, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowSegmentType>(const DB& db, const LIST& params, IfcFlowSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirTerminalBoxType>(const DB& db, const LIST& params, IfcAirTerminalBoxType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertySingleValue>(const DB& db, const LIST& params, IfcPropertySingleValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); }    do { // convert the 'NominalValue' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->NominalValue, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); }
-    } while(0);
-    do { // convert the 'Unit' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAlarmType>(const DB& db, const LIST& params, IfcAlarmType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEllipseProfileDef>(const DB& db, const LIST& params, IfcEllipseProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStair>(const DB& db, const LIST& params, IfcStair* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST& params, IfcSurfaceStyleShading* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleShading"); }    do { // convert the 'SurfaceColour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcSurfaceStyleShading,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SurfaceColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPumpType>(const DB& db, const LIST& params, IfcPumpType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDefinedSymbol>(const DB& db, const LIST& params, IfcDefinedSymbol* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementComponentType>(const DB& db, const LIST& params, IfcElementComponentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFastenerType>(const DB& db, const LIST& params, IfcFastenerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMechanicalFastenerType>(const DB& db, const LIST& params, IfcMechanicalFastenerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFastenerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowFitting>(const DB& db, const LIST& params, IfcFlowFitting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceDirectional>(const DB& db, const LIST& params, IfcLightSourceDirectional* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-
-} // ! STEP
-} // ! Assimp
-
-#if _MSC_VER
-#    pragma warning(pop)
-#endif // _MSC_VER
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
deleted file mode 100644
index 0d70511..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
+++ /dev/null
@@ -1,1927 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-//#include "AssimpPCH.h"
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "IFCReaderGen_2x3.h"
-
-#if _MSC_VER
-#    pragma warning(push)
-#    pragma warning(disable : 4702)
-#endif // _MSC_VER
-
-namespace Assimp {
-using namespace IFC;
-using namespace ::Assimp::IFC::Schema_2x3;
-
-namespace STEP {
-
-template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params, IfcSurfaceStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); }    do { // convert the 'Side' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Side, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
-    } while(0);
-    do { // convert the 'Styles' argument
-        std::shared_ptr<const DataType> arg = params[ base++ ];
-        try { GenericConvert( in->Styles, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationSurface>(const DB& db, const LIST& params, IfcAnnotationSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowController>(const DB& db, const LIST& params, IfcFlowController* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingStorey>(const DB& db, const LIST& params, IfcBuildingStorey* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkControl>(const DB& db, const LIST& params, IfcWorkControl* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkSchedule>(const DB& db, const LIST& params, IfcWorkSchedule* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctSegmentType>(const DB& db, const LIST& params, IfcDuctSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); }    do { // convert the 'Bounds' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFace,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bounds, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceMember>(const DB& db, const LIST& params, IfcStructuralSurfaceMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceMemberVarying>(const DB& db, const LIST& params, IfcStructuralSurfaceMemberVarying* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralSurfaceMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceSurface>(const DB& db, const LIST& params, IfcFaceSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFace*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCostSchedule>(const DB& db, const LIST& params, IfcCostSchedule* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlanarExtent>(const DB& db, const LIST& params, IfcPlanarExtent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlanarBox>(const DB& db, const LIST& params, IfcPlanarBox* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlanarExtent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST& params, IfcColourSpecification* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcColourSpecification"); }    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcVector* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); }    do { // convert the 'Orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Orientation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'Magnitude' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Magnitude, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBeam>(const DB& db, const LIST& params, IfcBeam* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, IfcColourRgb* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); }    do { // convert the 'Red' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Red, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-    do { // convert the 'Green' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Green, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-    do { // convert the 'Blue' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Blue, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPlanarAction>(const DB& db, const LIST& params, IfcStructuralPlanarAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPlanarActionVarying>(const DB& db, const LIST& params, IfcStructuralPlanarActionVarying* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralPlanarAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSite* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-	if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); }    do { // convert the 'RefLatitude' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLatitude, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
-    } while(0);
-    do { // convert the 'RefLongitude' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLongitude, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
-    } while(0);
-    do { // convert the 'RefElevation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefElevation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'LandTitleNumber' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LandTitleNumber, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'SiteAddress' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SiteAddress, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDiscreteAccessoryType>(const DB& db, const LIST& params, IfcDiscreteAccessoryType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVibrationIsolatorType>(const DB& db, const LIST& params, IfcVibrationIsolatorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDiscreteAccessoryType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvaporativeCoolerType>(const DB& db, const LIST& params, IfcEvaporativeCoolerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionChamberElementType>(const DB& db, const LIST& params, IfcDistributionChamberElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFeatureElementAddition>(const DB& db, const LIST& params, IfcFeatureElementAddition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuredDimensionCallout>(const DB& db, const LIST& params, IfcStructuredDimensionCallout* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDraughtingCallout*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoolingTowerType>(const DB& db, const LIST& params, IfcCoolingTowerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCenterLineProfileDef>(const DB& db, const LIST& params, IfcCenterLineProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcArbitraryOpenProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWindowStyle>(const DB& db, const LIST& params, IfcWindowStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceGoniometric>(const DB& db, const LIST& params, IfcLightSourceGoniometric* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransformerType>(const DB& db, const LIST& params, IfcTransformerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMemberType>(const DB& db, const LIST& params, IfcMemberType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceOfLinearExtrusion>(const DB& db, const LIST& params, IfcSurfaceOfLinearExtrusion* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMotorConnectionType>(const DB& db, const LIST& params, IfcMotorConnectionType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTreatmentDeviceType>(const DB& db, const LIST& params, IfcFlowTreatmentDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctSilencerType>(const DB& db, const LIST& params, IfcDuctSilencerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnishingElementType>(const DB& db, const LIST& params, IfcFurnishingElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSystemFurnitureElementType>(const DB& db, const LIST& params, IfcSystemFurnitureElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWasteTerminalType>(const DB& db, const LIST& params, IfcWasteTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params, IfcBSplineCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); }    do { // convert the 'Degree' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Degree, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `INTEGER`")); }
-    } while(0);
-    do { // convert the 'ControlPointsList' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->ControlPointsList, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'CurveForm' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->CurveForm, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
-    } while(0);
-    do { // convert the 'ClosedCurve' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->ClosedCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `LOGICAL`")); }
-    } while(0);
-    do { // convert the 'SelfIntersect' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `LOGICAL`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBezierCurve>(const DB& db, const LIST& params, IfcBezierCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBSplineCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActuatorType>(const DB& db, const LIST& params, IfcActuatorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionControlElement>(const DB& db, const LIST& params, IfcDistributionControlElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotation>(const DB& db, const LIST& params, IfcAnnotation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcAnnotation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LIST& params, IfcShellBasedSurfaceModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); }    do { // convert the 'SbsmBoundary' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SbsmBoundary, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActionRequest>(const DB& db, const LIST& params, IfcActionRequest* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& params, IfcExtrudedAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); }    do { // convert the 'ExtrudedDirection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'Depth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Depth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSystem>(const DB& db, const LIST& params, IfcSystem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFillAreaStyleHatching>(const DB& db, const LIST& params, IfcFillAreaStyleHatching* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& params, IfcRelVoidsElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); }    do { // convert the 'RelatingBuildingElement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
-    } while(0);
-    do { // convert the 'RelatedOpeningElement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceCurveSweptAreaSolid>(const DB& db, const LIST& params, IfcSurfaceCurveSweptAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3DnonUniform* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator3D*>(in));
-	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); }    do { // convert the 'Scale2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
-    } while(0);
-    do { // convert the 'Scale3' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale3, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurtainWallType>(const DB& db, const LIST& params, IfcCurtainWallType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEquipmentStandard>(const DB& db, const LIST& params, IfcEquipmentStandard* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowStorageDeviceType>(const DB& db, const LIST& params, IfcFlowStorageDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDiameterDimension>(const DB& db, const LIST& params, IfcDiameterDimension* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSwitchingDeviceType>(const DB& db, const LIST& params, IfcSwitchingDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWindow>(const DB& db, const LIST& params, IfcWindow* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTreatmentDevice>(const DB& db, const LIST& params, IfcFlowTreatmentDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcChillerType>(const DB& db, const LIST& params, IfcChillerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangleHollowProfileDef>(const DB& db, const LIST& params, IfcRectangleHollowProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoxedHalfSpace>(const DB& db, const LIST& params, IfcBoxedHalfSpace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& params, IfcAxis2Placement2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); }    do { // convert the 'RefDirection' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpaceProgram>(const DB& db, const LIST& params, IfcSpaceProgram* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPoint>(const DB& db, const LIST& params, IfcPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& params, IfcCartesianPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); }    do { // convert the 'Coordinates' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Coordinates, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundedSurface>(const DB& db, const LIST& params, IfcBoundedSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLoop>(const DB& db, const LIST& params, IfcLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, IfcPolyLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); }    do { // convert the 'Polygon' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Polygon, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTerminatorSymbol>(const DB& db, const LIST& params, IfcTerminatorSymbol* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationSymbolOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDimensionCurveTerminator>(const DB& db, const LIST& params, IfcDimensionCurveTerminator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTerminatorSymbol*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTrapeziumProfileDef>(const DB& db, const LIST& params, IfcTrapeziumProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIST& params, IfcRepresentationContext* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationContext"); }    do { // convert the 'ContextIdentifier' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextIdentifier, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'ContextType' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db, const LIST& params, IfcGeometricRepresentationContext* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationContext*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); }    do { // convert the 'CoordinateSpaceDimension' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
-    } while(0);
-    do { // convert the 'Precision' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Precision, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `REAL`")); }
-    } while(0);
-    do { // convert the 'WorldCoordinateSystem' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
-    } while(0);
-    do { // convert the 'TrueNorth' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TrueNorth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurveBoundedPlane>(const DB& db, const LIST& params, IfcCurveBoundedPlane* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcSIUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); }    do { // convert the 'Prefix' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Prefix, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
-    } while(0);
-    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralReaction>(const DB& db, const LIST& params, IfcStructuralReaction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPointReaction>(const DB& db, const LIST& params, IfcStructuralPointReaction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& params, IfcAxis1Placement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); }    do { // convert the 'Axis' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricApplianceType>(const DB& db, const LIST& params, IfcElectricApplianceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSensorType>(const DB& db, const LIST& params, IfcSensorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnishingElement>(const DB& db, const LIST& params, IfcFurnishingElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProtectiveDeviceType>(const DB& db, const LIST& params, IfcProtectiveDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcZShapeProfileDef>(const DB& db, const LIST& params, IfcZShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcScheduleTimeControl>(const DB& db, const LIST& params, IfcScheduleTimeControl* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& params, IfcRepresentationMap* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); }    do { // convert the 'MappingOrigin' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingOrigin, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
-    } while(0);
-    do { // convert the 'MappedRepresentation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappedRepresentation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcClosedShell>(const DB& db, const LIST& params, IfcClosedShell* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcClosedShell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementPart>(const DB& db, const LIST& params, IfcBuildingElementPart* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBlock>(const DB& db, const LIST& params, IfcBlock* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightFixtureType>(const DB& db, const LIST& params, IfcLightFixtureType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOpeningElement>(const DB& db, const LIST& params, IfcOpeningElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcOpeningElement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceSpot>(const DB& db, const LIST& params, IfcLightSourceSpot* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSourcePositional*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTendonAnchor>(const DB& db, const LIST& params, IfcTendonAnchor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricFlowStorageDeviceType>(const DB& db, const LIST& params, IfcElectricFlowStorageDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSphere>(const DB& db, const LIST& params, IfcSphere* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDamperType>(const DB& db, const LIST& params, IfcDamperType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectOrderRecord>(const DB& db, const LIST& params, IfcProjectOrderRecord* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionChamberElement>(const DB& db, const LIST& params, IfcDistributionChamberElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMechanicalFastener>(const DB& db, const LIST& params, IfcMechanicalFastener* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFastener*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangularTrimmedSurface>(const DB& db, const LIST& params, IfcRectangularTrimmedSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcZone>(const DB& db, const LIST& params, IfcZone* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFanType>(const DB& db, const LIST& params, IfcFanType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricSet>(const DB& db, const LIST& params, IfcGeometricSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFillAreaStyleTiles>(const DB& db, const LIST& params, IfcFillAreaStyleTiles* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableSegmentType>(const DB& db, const LIST& params, IfcCableSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelOverridesProperties>(const DB& db, const LIST& params, IfcRelOverridesProperties* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelDefinesByProperties*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& params, IfcMeasureWithUnit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); }    do { // convert the 'ValueComponent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ValueComponent, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
-    } while(0);
-    do { // convert the 'UnitComponent' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UnitComponent, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSlabType>(const DB& db, const LIST& params, IfcSlabType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcServiceLife>(const DB& db, const LIST& params, IfcServiceLife* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnitureType>(const DB& db, const LIST& params, IfcFurnitureType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCostItem>(const DB& db, const LIST& params, IfcCostItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingMesh>(const DB& db, const LIST& params, IfcReinforcingMesh* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFacetedBrepWithVoids>(const DB& db, const LIST& params, IfcFacetedBrepWithVoids* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGasTerminalType>(const DB& db, const LIST& params, IfcGasTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPile>(const DB& db, const LIST& params, IfcPile* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFillAreaStyleTileSymbolWithStyle>(const DB& db, const LIST& params, IfcFillAreaStyleTileSymbolWithStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionMaterialResource>(const DB& db, const LIST& params, IfcConstructionMaterialResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationCurveOccurrence>(const DB& db, const LIST& params, IfcAnnotationCurveOccurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDimensionCurve>(const DB& db, const LIST& params, IfcDimensionCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationCurveOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricCurveSet>(const DB& db, const LIST& params, IfcGeometricCurveSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricSet*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelAggregates>(const DB& db, const LIST& params, IfcRelAggregates* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelAggregates"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIST& params, IfcFaceBasedSurfaceModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); }    do { // convert the 'FbsmFaces' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->FbsmFaces, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEnergyConversionDevice>(const DB& db, const LIST& params, IfcEnergyConversionDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRampFlight>(const DB& db, const LIST& params, IfcRampFlight* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVertexLoop>(const DB& db, const LIST& params, IfcVertexLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlate>(const DB& db, const LIST& params, IfcPlate* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUShapeProfileDef>(const DB& db, const LIST& params, IfcUShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, IfcFaceBound* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); }    do { // convert the 'Bound' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bound, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
-    } while(0);
-    do { // convert the 'Orientation' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::Schema_2x3::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Orientation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `BOOLEAN`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceOuterBound>(const DB& db, const LIST& params, IfcFaceOuterBound* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFaceBound*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceOuterBound"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOneDirectionRepeatFactor>(const DB& db, const LIST& params, IfcOneDirectionRepeatFactor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoilerType>(const DB& db, const LIST& params, IfcBoilerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionEquipmentResource>(const DB& db, const LIST& params, IfcConstructionEquipmentResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& params, IfcComplexProperty* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); }    do { // convert the 'UsageName' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UsageName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
-    } while(0);
-    do { // convert the 'HasProperties' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFooting>(const DB& db, const LIST& params, IfcFooting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionProductResource>(const DB& db, const LIST& params, IfcConstructionProductResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDerivedProfileDef>(const DB& db, const LIST& params, IfcDerivedProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyTableValue>(const DB& db, const LIST& params, IfcPropertyTableValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMeterType>(const DB& db, const LIST& params, IfcFlowMeterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDoorStyle>(const DB& db, const LIST& params, IfcDoorStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& params, IfcUnitAssignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); }    do { // convert the 'Units' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Units, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTerminal>(const DB& db, const LIST& params, IfcFlowTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCraneRailFShapeProfileDef>(const DB& db, const LIST& params, IfcCraneRailFShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowSegment>(const DB& db, const LIST& params, IfcFlowSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& params, IfcElementQuantity* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); }    do { // convert the 'MethodOfMeasurement' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Quantities' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Quantities, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurtainWall>(const DB& db, const LIST& params, IfcCurtainWall* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDiscreteAccessory>(const DB& db, const LIST& params, IfcDiscreteAccessory* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGrid>(const DB& db, const LIST& params, IfcGrid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSanitaryTerminalType>(const DB& db, const LIST& params, IfcSanitaryTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSubedge>(const DB& db, const LIST& params, IfcSubedge* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFilterType>(const DB& db, const LIST& params, IfcFilterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTendon>(const DB& db, const LIST& params, IfcTendon* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralLoadGroup>(const DB& db, const LIST& params, IfcStructuralLoadGroup* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, const LIST& params, IfcPresentationStyleAssignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); }    do { // convert the 'Styles' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveMember>(const DB& db, const LIST& params, IfcStructuralCurveMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceAmbient>(const DB& db, const LIST& params, IfcLightSourceAmbient* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCondition>(const DB& db, const LIST& params, IfcCondition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPort>(const DB& db, const LIST& params, IfcPort* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSpace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-	if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); }    do { // convert the 'InteriorOrExteriorSpace' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcInternalOrExternalEnum`")); }
-    } while(0);
-    do { // convert the 'ElevationWithFlooring' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHeatExchangerType>(const DB& db, const LIST& params, IfcHeatExchangerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTankType>(const DB& db, const LIST& params, IfcTankType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcInventory>(const DB& db, const LIST& params, IfcInventory* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransportElementType>(const DB& db, const LIST& params, IfcTransportElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirToAirHeatRecoveryType>(const DB& db, const LIST& params, IfcAirToAirHeatRecoveryType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStairFlight>(const DB& db, const LIST& params, IfcStairFlight* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricalElement>(const DB& db, const LIST& params, IfcElectricalElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const LIST& params, IfcSurfaceStyleWithTextures* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); }    do { // convert the 'Textures' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Textures, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params, IfcBoundingBox* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); }    do { // convert the 'Corner' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Corner, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'XDim' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->XDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'YDim' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->YDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'ZDim' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ZDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWallType>(const DB& db, const LIST& params, IfcWallType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMove>(const DB& db, const LIST& params, IfcMove* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTask*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcCircle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); }    do { // convert the 'Radius' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Radius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOffsetCurve2D>(const DB& db, const LIST& params, IfcOffsetCurve2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPointOnCurve>(const DB& db, const LIST& params, IfcPointOnCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralResultGroup>(const DB& db, const LIST& params, IfcStructuralResultGroup* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSectionedSpine>(const DB& db, const LIST& params, IfcSectionedSpine* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSlab>(const DB& db, const LIST& params, IfcSlab* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVertex>(const DB& db, const LIST& params, IfcVertex* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVertexPoint>(const DB& db, const LIST& params, IfcVertexPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcVertex*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralLinearAction>(const DB& db, const LIST& params, IfcStructuralLinearAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralLinearActionVarying>(const DB& db, const LIST& params, IfcStructuralLinearActionVarying* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralLinearAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementProxyType>(const DB& db, const LIST& params, IfcBuildingElementProxyType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectionElement>(const DB& db, const LIST& params, IfcProjectionElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementAddition*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST& params, IfcConversionBasedUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); }    do { // convert the 'Name' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'ConversionFactor' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ConversionFactor, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricRepresentationSubContext>(const DB& db, const LIST& params, IfcGeometricRepresentationSubContext* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationContext*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationSurfaceOccurrence>(const DB& db, const LIST& params, IfcAnnotationSurfaceOccurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoundedEdgeFeature>(const DB& db, const LIST& params, IfcRoundedEdgeFeature* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdgeFeature*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricDistributionPoint>(const DB& db, const LIST& params, IfcElectricDistributionPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableCarrierSegmentType>(const DB& db, const LIST& params, IfcCableCarrierSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWallStandardCase>(const DB& db, const LIST& params, IfcWallStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWall*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCsgSolid>(const DB& db, const LIST& params, IfcCsgSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBeamType>(const DB& db, const LIST& params, IfcBeamType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationFillArea>(const DB& db, const LIST& params, IfcAnnotationFillArea* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveMemberVarying>(const DB& db, const LIST& params, IfcStructuralCurveMemberVarying* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralCurveMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPointOnSurface>(const DB& db, const LIST& params, IfcPointOnSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOrderAction>(const DB& db, const LIST& params, IfcOrderAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTask*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdgeLoop>(const DB& db, const LIST& params, IfcEdgeLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationFillAreaOccurrence>(const DB& db, const LIST& params, IfcAnnotationFillAreaOccurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkPlan>(const DB& db, const LIST& params, IfcWorkPlan* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, IfcEllipse* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); }    do { // convert the 'SemiAxis1' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis1, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'SemiAxis2' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProductDefinitionShape>(const DB& db, const LIST& params, IfcProductDefinitionShape* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectionCurve>(const DB& db, const LIST& params, IfcProjectionCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationCurveOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricalCircuit>(const DB& db, const LIST& params, IfcElectricalCircuit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRationalBezierCurve>(const DB& db, const LIST& params, IfcRationalBezierCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBezierCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPointAction>(const DB& db, const LIST& params, IfcStructuralPointAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPipeSegmentType>(const DB& db, const LIST& params, IfcPipeSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTwoDirectionRepeatFactor>(const DB& db, const LIST& params, IfcTwoDirectionRepeatFactor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcOneDirectionRepeatFactor*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShapeRepresentation>(const DB& db, const LIST& params, IfcShapeRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params, IfcPropertySet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); }    do { // convert the 'HasProperties' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIST& params, IfcSurfaceStyleRendering* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurfaceStyleShading*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); }    do { // convert the 'Transparency' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Transparency, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleRendering to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-    do { // convert the 'DiffuseColour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'TransmissionColour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TransmissionColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'DiffuseTransmissionColour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'ReflectionColour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ReflectionColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'SpecularColour' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'SpecularHighlight' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularHighlight, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
-    } while(0);
-    do { // convert the 'ReflectanceMethod' argument
-        std::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionPort>(const DB& db, const LIST& params, IfcDistributionPort* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPort*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPipeFittingType>(const DB& db, const LIST& params, IfcPipeFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransportElement>(const DB& db, const LIST& params, IfcTransportElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationTextOccurrence>(const DB& db, const LIST& params, IfcAnnotationTextOccurrence* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralAnalysisModel>(const DB& db, const LIST& params, IfcStructuralAnalysisModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConditionCriterion>(const DB& db, const LIST& params, IfcConditionCriterion* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-
-} // ! STEP
-} // ! Assimp
-
-#if _MSC_VER
-#    pragma warning(pop)
-#endif // _MSC_VER
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h
deleted file mode 100644
index f87f121..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_2x3.h
+++ /dev/null
@@ -1,4380 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
-
-#ifndef INCLUDED_IFC_READER_GEN_H
-#define INCLUDED_IFC_READER_GEN_H
-
-#include "AssetLib/Step/STEPFile.h"
-
-#ifdef _MSC_VER
-#    pragma warning(push)
-#    pragma warning( disable : 4512 )
-#endif // _MSC_VER
-
-namespace Assimp {
-namespace IFC {
-    namespace Schema_2x3 {
-
-    using namespace STEP;
-    using namespace STEP::EXPRESS;
-
-
-    struct NotImplemented : public ObjectHelper<NotImplemented,0> {
-
-    };
-
-
-    // ******************************************************************************
-    // IFC Custom data types
-    // ******************************************************************************
-
-
-    // C++ wrapper type for IfcAbsorbedDoseMeasure
-    typedef REAL IfcAbsorbedDoseMeasure;
-    // C++ wrapper type for IfcAccelerationMeasure
-    typedef REAL IfcAccelerationMeasure;
-    // C++ wrapper type for IfcAmountOfSubstanceMeasure
-    typedef REAL IfcAmountOfSubstanceMeasure;
-    // C++ wrapper type for IfcAngularVelocityMeasure
-    typedef REAL IfcAngularVelocityMeasure;
-    // C++ wrapper type for IfcAreaMeasure
-    typedef REAL IfcAreaMeasure;
-    // C++ wrapper type for IfcBoolean
-    typedef BOOLEAN IfcBoolean;
-    // C++ wrapper type for IfcBoxAlignment
-    typedef STRING IfcBoxAlignment;
-    // C++ wrapper type for IfcCompoundPlaneAngleMeasure
-    typedef ListOf< INTEGER, 3, 3 > IfcCompoundPlaneAngleMeasure;
-    // C++ wrapper type for IfcContextDependentMeasure
-    typedef REAL IfcContextDependentMeasure;
-    // C++ wrapper type for IfcCountMeasure
-    typedef NUMBER IfcCountMeasure;
-    // C++ wrapper type for IfcCurvatureMeasure
-    typedef REAL IfcCurvatureMeasure;
-    // C++ wrapper type for IfcDayInMonthNumber
-    typedef INTEGER IfcDayInMonthNumber;
-    // C++ wrapper type for IfcDaylightSavingHour
-    typedef INTEGER IfcDaylightSavingHour;
-    // C++ wrapper type for IfcDescriptiveMeasure
-    typedef STRING IfcDescriptiveMeasure;
-    // C++ wrapper type for IfcDimensionCount
-    typedef INTEGER IfcDimensionCount;
-    // C++ wrapper type for IfcDoseEquivalentMeasure
-    typedef REAL IfcDoseEquivalentMeasure;
-    // C++ wrapper type for IfcDynamicViscosityMeasure
-    typedef REAL IfcDynamicViscosityMeasure;
-    // C++ wrapper type for IfcElectricCapacitanceMeasure
-    typedef REAL IfcElectricCapacitanceMeasure;
-    // C++ wrapper type for IfcElectricChargeMeasure
-    typedef REAL IfcElectricChargeMeasure;
-    // C++ wrapper type for IfcElectricConductanceMeasure
-    typedef REAL IfcElectricConductanceMeasure;
-    // C++ wrapper type for IfcElectricCurrentMeasure
-    typedef REAL IfcElectricCurrentMeasure;
-    // C++ wrapper type for IfcElectricResistanceMeasure
-    typedef REAL IfcElectricResistanceMeasure;
-    // C++ wrapper type for IfcElectricVoltageMeasure
-    typedef REAL IfcElectricVoltageMeasure;
-    // C++ wrapper type for IfcEnergyMeasure
-    typedef REAL IfcEnergyMeasure;
-    // C++ wrapper type for IfcFontStyle
-    typedef STRING IfcFontStyle;
-    // C++ wrapper type for IfcFontVariant
-    typedef STRING IfcFontVariant;
-    // C++ wrapper type for IfcFontWeight
-    typedef STRING IfcFontWeight;
-    // C++ wrapper type for IfcForceMeasure
-    typedef REAL IfcForceMeasure;
-    // C++ wrapper type for IfcFrequencyMeasure
-    typedef REAL IfcFrequencyMeasure;
-    // C++ wrapper type for IfcGloballyUniqueId
-    typedef STRING IfcGloballyUniqueId;
-    // C++ wrapper type for IfcHeatFluxDensityMeasure
-    typedef REAL IfcHeatFluxDensityMeasure;
-    // C++ wrapper type for IfcHeatingValueMeasure
-    typedef REAL IfcHeatingValueMeasure;
-    // C++ wrapper type for IfcHourInDay
-    typedef INTEGER IfcHourInDay;
-    // C++ wrapper type for IfcIdentifier
-    typedef STRING IfcIdentifier;
-    // C++ wrapper type for IfcIlluminanceMeasure
-    typedef REAL IfcIlluminanceMeasure;
-    // C++ wrapper type for IfcInductanceMeasure
-    typedef REAL IfcInductanceMeasure;
-    // C++ wrapper type for IfcInteger
-    typedef INTEGER IfcInteger;
-    // C++ wrapper type for IfcIntegerCountRateMeasure
-    typedef INTEGER IfcIntegerCountRateMeasure;
-    // C++ wrapper type for IfcIonConcentrationMeasure
-    typedef REAL IfcIonConcentrationMeasure;
-    // C++ wrapper type for IfcIsothermalMoistureCapacityMeasure
-    typedef REAL IfcIsothermalMoistureCapacityMeasure;
-    // C++ wrapper type for IfcKinematicViscosityMeasure
-    typedef REAL IfcKinematicViscosityMeasure;
-    // C++ wrapper type for IfcLabel
-    typedef STRING IfcLabel;
-    // C++ wrapper type for IfcLengthMeasure
-    typedef REAL IfcLengthMeasure;
-    // C++ wrapper type for IfcLinearForceMeasure
-    typedef REAL IfcLinearForceMeasure;
-    // C++ wrapper type for IfcLinearMomentMeasure
-    typedef REAL IfcLinearMomentMeasure;
-    // C++ wrapper type for IfcLinearStiffnessMeasure
-    typedef REAL IfcLinearStiffnessMeasure;
-    // C++ wrapper type for IfcLinearVelocityMeasure
-    typedef REAL IfcLinearVelocityMeasure;
-    // C++ wrapper type for IfcLogical
-    typedef LOGICAL IfcLogical;
-    // C++ wrapper type for IfcLuminousFluxMeasure
-    typedef REAL IfcLuminousFluxMeasure;
-    // C++ wrapper type for IfcLuminousIntensityDistributionMeasure
-    typedef REAL IfcLuminousIntensityDistributionMeasure;
-    // C++ wrapper type for IfcLuminousIntensityMeasure
-    typedef REAL IfcLuminousIntensityMeasure;
-    // C++ wrapper type for IfcMagneticFluxDensityMeasure
-    typedef REAL IfcMagneticFluxDensityMeasure;
-    // C++ wrapper type for IfcMagneticFluxMeasure
-    typedef REAL IfcMagneticFluxMeasure;
-    // C++ wrapper type for IfcMassDensityMeasure
-    typedef REAL IfcMassDensityMeasure;
-    // C++ wrapper type for IfcMassFlowRateMeasure
-    typedef REAL IfcMassFlowRateMeasure;
-    // C++ wrapper type for IfcMassMeasure
-    typedef REAL IfcMassMeasure;
-    // C++ wrapper type for IfcMassPerLengthMeasure
-    typedef REAL IfcMassPerLengthMeasure;
-    // C++ wrapper type for IfcMinuteInHour
-    typedef INTEGER IfcMinuteInHour;
-    // C++ wrapper type for IfcModulusOfElasticityMeasure
-    typedef REAL IfcModulusOfElasticityMeasure;
-    // C++ wrapper type for IfcModulusOfLinearSubgradeReactionMeasure
-    typedef REAL IfcModulusOfLinearSubgradeReactionMeasure;
-    // C++ wrapper type for IfcModulusOfRotationalSubgradeReactionMeasure
-    typedef REAL IfcModulusOfRotationalSubgradeReactionMeasure;
-    // C++ wrapper type for IfcModulusOfSubgradeReactionMeasure
-    typedef REAL IfcModulusOfSubgradeReactionMeasure;
-    // C++ wrapper type for IfcMoistureDiffusivityMeasure
-    typedef REAL IfcMoistureDiffusivityMeasure;
-    // C++ wrapper type for IfcMolecularWeightMeasure
-    typedef REAL IfcMolecularWeightMeasure;
-    // C++ wrapper type for IfcMomentOfInertiaMeasure
-    typedef REAL IfcMomentOfInertiaMeasure;
-    // C++ wrapper type for IfcMonetaryMeasure
-    typedef REAL IfcMonetaryMeasure;
-    // C++ wrapper type for IfcMonthInYearNumber
-    typedef INTEGER IfcMonthInYearNumber;
-    // C++ wrapper type for IfcNormalisedRatioMeasure
-    typedef REAL IfcNormalisedRatioMeasure;
-    // C++ wrapper type for IfcNumericMeasure
-    typedef NUMBER IfcNumericMeasure;
-    // C++ wrapper type for IfcPHMeasure
-    typedef REAL IfcPHMeasure;
-    // C++ wrapper type for IfcParameterValue
-    typedef REAL IfcParameterValue;
-    // C++ wrapper type for IfcPlanarForceMeasure
-    typedef REAL IfcPlanarForceMeasure;
-    // C++ wrapper type for IfcPlaneAngleMeasure
-    typedef REAL IfcPlaneAngleMeasure;
-    // C++ wrapper type for IfcPositiveLengthMeasure
-    typedef REAL IfcPositiveLengthMeasure;
-    // C++ wrapper type for IfcPositivePlaneAngleMeasure
-    typedef REAL IfcPositivePlaneAngleMeasure;
-    // C++ wrapper type for IfcPositiveRatioMeasure
-    typedef REAL IfcPositiveRatioMeasure;
-    // C++ wrapper type for IfcPowerMeasure
-    typedef REAL IfcPowerMeasure;
-    // C++ wrapper type for IfcPresentableText
-    typedef STRING IfcPresentableText;
-    // C++ wrapper type for IfcPressureMeasure
-    typedef REAL IfcPressureMeasure;
-    // C++ wrapper type for IfcRadioActivityMeasure
-    typedef REAL IfcRadioActivityMeasure;
-    // C++ wrapper type for IfcRatioMeasure
-    typedef REAL IfcRatioMeasure;
-    // C++ wrapper type for IfcReal
-    typedef REAL IfcReal;
-    // C++ wrapper type for IfcRotationalFrequencyMeasure
-    typedef REAL IfcRotationalFrequencyMeasure;
-    // C++ wrapper type for IfcRotationalMassMeasure
-    typedef REAL IfcRotationalMassMeasure;
-    // C++ wrapper type for IfcRotationalStiffnessMeasure
-    typedef REAL IfcRotationalStiffnessMeasure;
-    // C++ wrapper type for IfcSecondInMinute
-    typedef REAL IfcSecondInMinute;
-    // C++ wrapper type for IfcSectionModulusMeasure
-    typedef REAL IfcSectionModulusMeasure;
-    // C++ wrapper type for IfcSectionalAreaIntegralMeasure
-    typedef REAL IfcSectionalAreaIntegralMeasure;
-    // C++ wrapper type for IfcShearModulusMeasure
-    typedef REAL IfcShearModulusMeasure;
-    // C++ wrapper type for IfcSolidAngleMeasure
-    typedef REAL IfcSolidAngleMeasure;
-    // C++ wrapper type for IfcSoundPowerMeasure
-    typedef REAL IfcSoundPowerMeasure;
-    // C++ wrapper type for IfcSoundPressureMeasure
-    typedef REAL IfcSoundPressureMeasure;
-    // C++ wrapper type for IfcSpecificHeatCapacityMeasure
-    typedef REAL IfcSpecificHeatCapacityMeasure;
-    // C++ wrapper type for IfcSpecularExponent
-    typedef REAL IfcSpecularExponent;
-    // C++ wrapper type for IfcSpecularRoughness
-    typedef REAL IfcSpecularRoughness;
-    // C++ wrapper type for IfcTemperatureGradientMeasure
-    typedef REAL IfcTemperatureGradientMeasure;
-    // C++ wrapper type for IfcText
-    typedef STRING IfcText;
-    // C++ wrapper type for IfcTextAlignment
-    typedef STRING IfcTextAlignment;
-    // C++ wrapper type for IfcTextDecoration
-    typedef STRING IfcTextDecoration;
-    // C++ wrapper type for IfcTextFontName
-    typedef STRING IfcTextFontName;
-    // C++ wrapper type for IfcTextTransformation
-    typedef STRING IfcTextTransformation;
-    // C++ wrapper type for IfcThermalAdmittanceMeasure
-    typedef REAL IfcThermalAdmittanceMeasure;
-    // C++ wrapper type for IfcThermalConductivityMeasure
-    typedef REAL IfcThermalConductivityMeasure;
-    // C++ wrapper type for IfcThermalExpansionCoefficientMeasure
-    typedef REAL IfcThermalExpansionCoefficientMeasure;
-    // C++ wrapper type for IfcThermalResistanceMeasure
-    typedef REAL IfcThermalResistanceMeasure;
-    // C++ wrapper type for IfcThermalTransmittanceMeasure
-    typedef REAL IfcThermalTransmittanceMeasure;
-    // C++ wrapper type for IfcThermodynamicTemperatureMeasure
-    typedef REAL IfcThermodynamicTemperatureMeasure;
-    // C++ wrapper type for IfcTimeMeasure
-    typedef REAL IfcTimeMeasure;
-    // C++ wrapper type for IfcTimeStamp
-    typedef INTEGER IfcTimeStamp;
-    // C++ wrapper type for IfcTorqueMeasure
-    typedef REAL IfcTorqueMeasure;
-    // C++ wrapper type for IfcVaporPermeabilityMeasure
-    typedef REAL IfcVaporPermeabilityMeasure;
-    // C++ wrapper type for IfcVolumeMeasure
-    typedef REAL IfcVolumeMeasure;
-    // C++ wrapper type for IfcVolumetricFlowRateMeasure
-    typedef REAL IfcVolumetricFlowRateMeasure;
-    // C++ wrapper type for IfcWarpingConstantMeasure
-    typedef REAL IfcWarpingConstantMeasure;
-    // C++ wrapper type for IfcWarpingMomentMeasure
-    typedef REAL IfcWarpingMomentMeasure;
-    // C++ wrapper type for IfcYearNumber
-    typedef INTEGER IfcYearNumber;
-    // C++ wrapper type for IfcActionSourceTypeEnum
-    typedef ENUMERATION IfcActionSourceTypeEnum;
-    // C++ wrapper type for IfcActionTypeEnum
-    typedef ENUMERATION IfcActionTypeEnum;
-    // C++ wrapper type for IfcActuatorTypeEnum
-    typedef ENUMERATION IfcActuatorTypeEnum;
-    // C++ wrapper type for IfcAddressTypeEnum
-    typedef ENUMERATION IfcAddressTypeEnum;
-    // C++ wrapper type for IfcAheadOrBehind
-    typedef ENUMERATION IfcAheadOrBehind;
-    // C++ wrapper type for IfcAirTerminalBoxTypeEnum
-    typedef ENUMERATION IfcAirTerminalBoxTypeEnum;
-    // C++ wrapper type for IfcAirTerminalTypeEnum
-    typedef ENUMERATION IfcAirTerminalTypeEnum;
-    // C++ wrapper type for IfcAirToAirHeatRecoveryTypeEnum
-    typedef ENUMERATION IfcAirToAirHeatRecoveryTypeEnum;
-    // C++ wrapper type for IfcAlarmTypeEnum
-    typedef ENUMERATION IfcAlarmTypeEnum;
-    // C++ wrapper type for IfcAnalysisModelTypeEnum
-    typedef ENUMERATION IfcAnalysisModelTypeEnum;
-    // C++ wrapper type for IfcAnalysisTheoryTypeEnum
-    typedef ENUMERATION IfcAnalysisTheoryTypeEnum;
-    // C++ wrapper type for IfcArithmeticOperatorEnum
-    typedef ENUMERATION IfcArithmeticOperatorEnum;
-    // C++ wrapper type for IfcAssemblyPlaceEnum
-    typedef ENUMERATION IfcAssemblyPlaceEnum;
-    // C++ wrapper type for IfcBSplineCurveForm
-    typedef ENUMERATION IfcBSplineCurveForm;
-    // C++ wrapper type for IfcBeamTypeEnum
-    typedef ENUMERATION IfcBeamTypeEnum;
-    // C++ wrapper type for IfcBenchmarkEnum
-    typedef ENUMERATION IfcBenchmarkEnum;
-    // C++ wrapper type for IfcBoilerTypeEnum
-    typedef ENUMERATION IfcBoilerTypeEnum;
-    // C++ wrapper type for IfcBooleanOperator
-    typedef ENUMERATION IfcBooleanOperator;
-    // C++ wrapper type for IfcBuildingElementProxyTypeEnum
-    typedef ENUMERATION IfcBuildingElementProxyTypeEnum;
-    // C++ wrapper type for IfcCableCarrierFittingTypeEnum
-    typedef ENUMERATION IfcCableCarrierFittingTypeEnum;
-    // C++ wrapper type for IfcCableCarrierSegmentTypeEnum
-    typedef ENUMERATION IfcCableCarrierSegmentTypeEnum;
-    // C++ wrapper type for IfcCableSegmentTypeEnum
-    typedef ENUMERATION IfcCableSegmentTypeEnum;
-    // C++ wrapper type for IfcChangeActionEnum
-    typedef ENUMERATION IfcChangeActionEnum;
-    // C++ wrapper type for IfcChillerTypeEnum
-    typedef ENUMERATION IfcChillerTypeEnum;
-    // C++ wrapper type for IfcCoilTypeEnum
-    typedef ENUMERATION IfcCoilTypeEnum;
-    // C++ wrapper type for IfcColumnTypeEnum
-    typedef ENUMERATION IfcColumnTypeEnum;
-    // C++ wrapper type for IfcCompressorTypeEnum
-    typedef ENUMERATION IfcCompressorTypeEnum;
-    // C++ wrapper type for IfcCondenserTypeEnum
-    typedef ENUMERATION IfcCondenserTypeEnum;
-    // C++ wrapper type for IfcConnectionTypeEnum
-    typedef ENUMERATION IfcConnectionTypeEnum;
-    // C++ wrapper type for IfcConstraintEnum
-    typedef ENUMERATION IfcConstraintEnum;
-    // C++ wrapper type for IfcControllerTypeEnum
-    typedef ENUMERATION IfcControllerTypeEnum;
-    // C++ wrapper type for IfcCooledBeamTypeEnum
-    typedef ENUMERATION IfcCooledBeamTypeEnum;
-    // C++ wrapper type for IfcCoolingTowerTypeEnum
-    typedef ENUMERATION IfcCoolingTowerTypeEnum;
-    // C++ wrapper type for IfcCostScheduleTypeEnum
-    typedef ENUMERATION IfcCostScheduleTypeEnum;
-    // C++ wrapper type for IfcCoveringTypeEnum
-    typedef ENUMERATION IfcCoveringTypeEnum;
-    // C++ wrapper type for IfcCurrencyEnum
-    typedef ENUMERATION IfcCurrencyEnum;
-    // C++ wrapper type for IfcCurtainWallTypeEnum
-    typedef ENUMERATION IfcCurtainWallTypeEnum;
-    // C++ wrapper type for IfcDamperTypeEnum
-    typedef ENUMERATION IfcDamperTypeEnum;
-    // C++ wrapper type for IfcDataOriginEnum
-    typedef ENUMERATION IfcDataOriginEnum;
-    // C++ wrapper type for IfcDerivedUnitEnum
-    typedef ENUMERATION IfcDerivedUnitEnum;
-    // C++ wrapper type for IfcDimensionExtentUsage
-    typedef ENUMERATION IfcDimensionExtentUsage;
-    // C++ wrapper type for IfcDirectionSenseEnum
-    typedef ENUMERATION IfcDirectionSenseEnum;
-    // C++ wrapper type for IfcDistributionChamberElementTypeEnum
-    typedef ENUMERATION IfcDistributionChamberElementTypeEnum;
-    // C++ wrapper type for IfcDocumentConfidentialityEnum
-    typedef ENUMERATION IfcDocumentConfidentialityEnum;
-    // C++ wrapper type for IfcDocumentStatusEnum
-    typedef ENUMERATION IfcDocumentStatusEnum;
-    // C++ wrapper type for IfcDoorPanelOperationEnum
-    typedef ENUMERATION IfcDoorPanelOperationEnum;
-    // C++ wrapper type for IfcDoorPanelPositionEnum
-    typedef ENUMERATION IfcDoorPanelPositionEnum;
-    // C++ wrapper type for IfcDoorStyleConstructionEnum
-    typedef ENUMERATION IfcDoorStyleConstructionEnum;
-    // C++ wrapper type for IfcDoorStyleOperationEnum
-    typedef ENUMERATION IfcDoorStyleOperationEnum;
-    // C++ wrapper type for IfcDuctFittingTypeEnum
-    typedef ENUMERATION IfcDuctFittingTypeEnum;
-    // C++ wrapper type for IfcDuctSegmentTypeEnum
-    typedef ENUMERATION IfcDuctSegmentTypeEnum;
-    // C++ wrapper type for IfcDuctSilencerTypeEnum
-    typedef ENUMERATION IfcDuctSilencerTypeEnum;
-    // C++ wrapper type for IfcElectricApplianceTypeEnum
-    typedef ENUMERATION IfcElectricApplianceTypeEnum;
-    // C++ wrapper type for IfcElectricCurrentEnum
-    typedef ENUMERATION IfcElectricCurrentEnum;
-    // C++ wrapper type for IfcElectricDistributionPointFunctionEnum
-    typedef ENUMERATION IfcElectricDistributionPointFunctionEnum;
-    // C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum
-    typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum;
-    // C++ wrapper type for IfcElectricGeneratorTypeEnum
-    typedef ENUMERATION IfcElectricGeneratorTypeEnum;
-    // C++ wrapper type for IfcElectricHeaterTypeEnum
-    typedef ENUMERATION IfcElectricHeaterTypeEnum;
-    // C++ wrapper type for IfcElectricMotorTypeEnum
-    typedef ENUMERATION IfcElectricMotorTypeEnum;
-    // C++ wrapper type for IfcElectricTimeControlTypeEnum
-    typedef ENUMERATION IfcElectricTimeControlTypeEnum;
-    // C++ wrapper type for IfcElementAssemblyTypeEnum
-    typedef ENUMERATION IfcElementAssemblyTypeEnum;
-    // C++ wrapper type for IfcElementCompositionEnum
-    typedef ENUMERATION IfcElementCompositionEnum;
-    // C++ wrapper type for IfcEnergySequenceEnum
-    typedef ENUMERATION IfcEnergySequenceEnum;
-    // C++ wrapper type for IfcEnvironmentalImpactCategoryEnum
-    typedef ENUMERATION IfcEnvironmentalImpactCategoryEnum;
-    // C++ wrapper type for IfcEvaporativeCoolerTypeEnum
-    typedef ENUMERATION IfcEvaporativeCoolerTypeEnum;
-    // C++ wrapper type for IfcEvaporatorTypeEnum
-    typedef ENUMERATION IfcEvaporatorTypeEnum;
-    // C++ wrapper type for IfcFanTypeEnum
-    typedef ENUMERATION IfcFanTypeEnum;
-    // C++ wrapper type for IfcFilterTypeEnum
-    typedef ENUMERATION IfcFilterTypeEnum;
-    // C++ wrapper type for IfcFireSuppressionTerminalTypeEnum
-    typedef ENUMERATION IfcFireSuppressionTerminalTypeEnum;
-    // C++ wrapper type for IfcFlowDirectionEnum
-    typedef ENUMERATION IfcFlowDirectionEnum;
-    // C++ wrapper type for IfcFlowInstrumentTypeEnum
-    typedef ENUMERATION IfcFlowInstrumentTypeEnum;
-    // C++ wrapper type for IfcFlowMeterTypeEnum
-    typedef ENUMERATION IfcFlowMeterTypeEnum;
-    // C++ wrapper type for IfcFootingTypeEnum
-    typedef ENUMERATION IfcFootingTypeEnum;
-    // C++ wrapper type for IfcGasTerminalTypeEnum
-    typedef ENUMERATION IfcGasTerminalTypeEnum;
-    // C++ wrapper type for IfcGeometricProjectionEnum
-    typedef ENUMERATION IfcGeometricProjectionEnum;
-    // C++ wrapper type for IfcGlobalOrLocalEnum
-    typedef ENUMERATION IfcGlobalOrLocalEnum;
-    // C++ wrapper type for IfcHeatExchangerTypeEnum
-    typedef ENUMERATION IfcHeatExchangerTypeEnum;
-    // C++ wrapper type for IfcHumidifierTypeEnum
-    typedef ENUMERATION IfcHumidifierTypeEnum;
-    // C++ wrapper type for IfcInternalOrExternalEnum
-    typedef ENUMERATION IfcInternalOrExternalEnum;
-    // C++ wrapper type for IfcInventoryTypeEnum
-    typedef ENUMERATION IfcInventoryTypeEnum;
-    // C++ wrapper type for IfcJunctionBoxTypeEnum
-    typedef ENUMERATION IfcJunctionBoxTypeEnum;
-    // C++ wrapper type for IfcLampTypeEnum
-    typedef ENUMERATION IfcLampTypeEnum;
-    // C++ wrapper type for IfcLayerSetDirectionEnum
-    typedef ENUMERATION IfcLayerSetDirectionEnum;
-    // C++ wrapper type for IfcLightDistributionCurveEnum
-    typedef ENUMERATION IfcLightDistributionCurveEnum;
-    // C++ wrapper type for IfcLightEmissionSourceEnum
-    typedef ENUMERATION IfcLightEmissionSourceEnum;
-    // C++ wrapper type for IfcLightFixtureTypeEnum
-    typedef ENUMERATION IfcLightFixtureTypeEnum;
-    // C++ wrapper type for IfcLoadGroupTypeEnum
-    typedef ENUMERATION IfcLoadGroupTypeEnum;
-    // C++ wrapper type for IfcLogicalOperatorEnum
-    typedef ENUMERATION IfcLogicalOperatorEnum;
-    // C++ wrapper type for IfcMemberTypeEnum
-    typedef ENUMERATION IfcMemberTypeEnum;
-    // C++ wrapper type for IfcMotorConnectionTypeEnum
-    typedef ENUMERATION IfcMotorConnectionTypeEnum;
-    // C++ wrapper type for IfcNullStyle
-    typedef ENUMERATION IfcNullStyle;
-    // C++ wrapper type for IfcObjectTypeEnum
-    typedef ENUMERATION IfcObjectTypeEnum;
-    // C++ wrapper type for IfcObjectiveEnum
-    typedef ENUMERATION IfcObjectiveEnum;
-    // C++ wrapper type for IfcOccupantTypeEnum
-    typedef ENUMERATION IfcOccupantTypeEnum;
-    // C++ wrapper type for IfcOutletTypeEnum
-    typedef ENUMERATION IfcOutletTypeEnum;
-    // C++ wrapper type for IfcPermeableCoveringOperationEnum
-    typedef ENUMERATION IfcPermeableCoveringOperationEnum;
-    // C++ wrapper type for IfcPhysicalOrVirtualEnum
-    typedef ENUMERATION IfcPhysicalOrVirtualEnum;
-    // C++ wrapper type for IfcPileConstructionEnum
-    typedef ENUMERATION IfcPileConstructionEnum;
-    // C++ wrapper type for IfcPileTypeEnum
-    typedef ENUMERATION IfcPileTypeEnum;
-    // C++ wrapper type for IfcPipeFittingTypeEnum
-    typedef ENUMERATION IfcPipeFittingTypeEnum;
-    // C++ wrapper type for IfcPipeSegmentTypeEnum
-    typedef ENUMERATION IfcPipeSegmentTypeEnum;
-    // C++ wrapper type for IfcPlateTypeEnum
-    typedef ENUMERATION IfcPlateTypeEnum;
-    // C++ wrapper type for IfcProcedureTypeEnum
-    typedef ENUMERATION IfcProcedureTypeEnum;
-    // C++ wrapper type for IfcProfileTypeEnum
-    typedef ENUMERATION IfcProfileTypeEnum;
-    // C++ wrapper type for IfcProjectOrderRecordTypeEnum
-    typedef ENUMERATION IfcProjectOrderRecordTypeEnum;
-    // C++ wrapper type for IfcProjectOrderTypeEnum
-    typedef ENUMERATION IfcProjectOrderTypeEnum;
-    // C++ wrapper type for IfcProjectedOrTrueLengthEnum
-    typedef ENUMERATION IfcProjectedOrTrueLengthEnum;
-    // C++ wrapper type for IfcPropertySourceEnum
-    typedef ENUMERATION IfcPropertySourceEnum;
-    // C++ wrapper type for IfcProtectiveDeviceTypeEnum
-    typedef ENUMERATION IfcProtectiveDeviceTypeEnum;
-    // C++ wrapper type for IfcPumpTypeEnum
-    typedef ENUMERATION IfcPumpTypeEnum;
-    // C++ wrapper type for IfcRailingTypeEnum
-    typedef ENUMERATION IfcRailingTypeEnum;
-    // C++ wrapper type for IfcRampFlightTypeEnum
-    typedef ENUMERATION IfcRampFlightTypeEnum;
-    // C++ wrapper type for IfcRampTypeEnum
-    typedef ENUMERATION IfcRampTypeEnum;
-    // C++ wrapper type for IfcReflectanceMethodEnum
-    typedef ENUMERATION IfcReflectanceMethodEnum;
-    // C++ wrapper type for IfcReinforcingBarRoleEnum
-    typedef ENUMERATION IfcReinforcingBarRoleEnum;
-    // C++ wrapper type for IfcReinforcingBarSurfaceEnum
-    typedef ENUMERATION IfcReinforcingBarSurfaceEnum;
-    // C++ wrapper type for IfcResourceConsumptionEnum
-    typedef ENUMERATION IfcResourceConsumptionEnum;
-    // C++ wrapper type for IfcRibPlateDirectionEnum
-    typedef ENUMERATION IfcRibPlateDirectionEnum;
-    // C++ wrapper type for IfcRoleEnum
-    typedef ENUMERATION IfcRoleEnum;
-    // C++ wrapper type for IfcRoofTypeEnum
-    typedef ENUMERATION IfcRoofTypeEnum;
-    // C++ wrapper type for IfcSIPrefix
-    typedef ENUMERATION IfcSIPrefix;
-    // C++ wrapper type for IfcSIUnitName
-    typedef ENUMERATION IfcSIUnitName;
-    // C++ wrapper type for IfcSanitaryTerminalTypeEnum
-    typedef ENUMERATION IfcSanitaryTerminalTypeEnum;
-    // C++ wrapper type for IfcSectionTypeEnum
-    typedef ENUMERATION IfcSectionTypeEnum;
-    // C++ wrapper type for IfcSensorTypeEnum
-    typedef ENUMERATION IfcSensorTypeEnum;
-    // C++ wrapper type for IfcSequenceEnum
-    typedef ENUMERATION IfcSequenceEnum;
-    // C++ wrapper type for IfcServiceLifeFactorTypeEnum
-    typedef ENUMERATION IfcServiceLifeFactorTypeEnum;
-    // C++ wrapper type for IfcServiceLifeTypeEnum
-    typedef ENUMERATION IfcServiceLifeTypeEnum;
-    // C++ wrapper type for IfcSlabTypeEnum
-    typedef ENUMERATION IfcSlabTypeEnum;
-    // C++ wrapper type for IfcSoundScaleEnum
-    typedef ENUMERATION IfcSoundScaleEnum;
-    // C++ wrapper type for IfcSpaceHeaterTypeEnum
-    typedef ENUMERATION IfcSpaceHeaterTypeEnum;
-    // C++ wrapper type for IfcSpaceTypeEnum
-    typedef ENUMERATION IfcSpaceTypeEnum;
-    // C++ wrapper type for IfcStackTerminalTypeEnum
-    typedef ENUMERATION IfcStackTerminalTypeEnum;
-    // C++ wrapper type for IfcStairFlightTypeEnum
-    typedef ENUMERATION IfcStairFlightTypeEnum;
-    // C++ wrapper type for IfcStairTypeEnum
-    typedef ENUMERATION IfcStairTypeEnum;
-    // C++ wrapper type for IfcStateEnum
-    typedef ENUMERATION IfcStateEnum;
-    // C++ wrapper type for IfcStructuralCurveTypeEnum
-    typedef ENUMERATION IfcStructuralCurveTypeEnum;
-    // C++ wrapper type for IfcStructuralSurfaceTypeEnum
-    typedef ENUMERATION IfcStructuralSurfaceTypeEnum;
-    // C++ wrapper type for IfcSurfaceSide
-    typedef ENUMERATION IfcSurfaceSide;
-    // C++ wrapper type for IfcSurfaceTextureEnum
-    typedef ENUMERATION IfcSurfaceTextureEnum;
-    // C++ wrapper type for IfcSwitchingDeviceTypeEnum
-    typedef ENUMERATION IfcSwitchingDeviceTypeEnum;
-    // C++ wrapper type for IfcTankTypeEnum
-    typedef ENUMERATION IfcTankTypeEnum;
-    // C++ wrapper type for IfcTendonTypeEnum
-    typedef ENUMERATION IfcTendonTypeEnum;
-    // C++ wrapper type for IfcTextPath
-    typedef ENUMERATION IfcTextPath;
-    // C++ wrapper type for IfcThermalLoadSourceEnum
-    typedef ENUMERATION IfcThermalLoadSourceEnum;
-    // C++ wrapper type for IfcThermalLoadTypeEnum
-    typedef ENUMERATION IfcThermalLoadTypeEnum;
-    // C++ wrapper type for IfcTimeSeriesDataTypeEnum
-    typedef ENUMERATION IfcTimeSeriesDataTypeEnum;
-    // C++ wrapper type for IfcTimeSeriesScheduleTypeEnum
-    typedef ENUMERATION IfcTimeSeriesScheduleTypeEnum;
-    // C++ wrapper type for IfcTransformerTypeEnum
-    typedef ENUMERATION IfcTransformerTypeEnum;
-    // C++ wrapper type for IfcTransitionCode
-    typedef ENUMERATION IfcTransitionCode;
-    // C++ wrapper type for IfcTransportElementTypeEnum
-    typedef ENUMERATION IfcTransportElementTypeEnum;
-    // C++ wrapper type for IfcTrimmingPreference
-    typedef ENUMERATION IfcTrimmingPreference;
-    // C++ wrapper type for IfcTubeBundleTypeEnum
-    typedef ENUMERATION IfcTubeBundleTypeEnum;
-    // C++ wrapper type for IfcUnitEnum
-    typedef ENUMERATION IfcUnitEnum;
-    // C++ wrapper type for IfcUnitaryEquipmentTypeEnum
-    typedef ENUMERATION IfcUnitaryEquipmentTypeEnum;
-    // C++ wrapper type for IfcValveTypeEnum
-    typedef ENUMERATION IfcValveTypeEnum;
-    // C++ wrapper type for IfcVibrationIsolatorTypeEnum
-    typedef ENUMERATION IfcVibrationIsolatorTypeEnum;
-    // C++ wrapper type for IfcWallTypeEnum
-    typedef ENUMERATION IfcWallTypeEnum;
-    // C++ wrapper type for IfcWasteTerminalTypeEnum
-    typedef ENUMERATION IfcWasteTerminalTypeEnum;
-    // C++ wrapper type for IfcWindowPanelOperationEnum
-    typedef ENUMERATION IfcWindowPanelOperationEnum;
-    // C++ wrapper type for IfcWindowPanelPositionEnum
-    typedef ENUMERATION IfcWindowPanelPositionEnum;
-    // C++ wrapper type for IfcWindowStyleConstructionEnum
-    typedef ENUMERATION IfcWindowStyleConstructionEnum;
-    // C++ wrapper type for IfcWindowStyleOperationEnum
-    typedef ENUMERATION IfcWindowStyleOperationEnum;
-    // C++ wrapper type for IfcWorkControlTypeEnum
-    typedef ENUMERATION IfcWorkControlTypeEnum;
-    // C++ wrapper type for IfcActorSelect
-    typedef SELECT IfcActorSelect;
-    // C++ wrapper type for IfcAppliedValueSelect
-    typedef SELECT IfcAppliedValueSelect;
-    // C++ wrapper type for IfcAxis2Placement
-    typedef SELECT IfcAxis2Placement;
-    // C++ wrapper type for IfcBooleanOperand
-    typedef SELECT IfcBooleanOperand;
-    // C++ wrapper type for IfcCharacterStyleSelect
-    typedef SELECT IfcCharacterStyleSelect;
-    // C++ wrapper type for IfcClassificationNotationSelect
-    typedef SELECT IfcClassificationNotationSelect;
-    // C++ wrapper type for IfcColour
-    typedef SELECT IfcColour;
-    // C++ wrapper type for IfcColourOrFactor
-    typedef SELECT IfcColourOrFactor;
-    // C++ wrapper type for IfcConditionCriterionSelect
-    typedef SELECT IfcConditionCriterionSelect;
-    // C++ wrapper type for IfcCsgSelect
-    typedef SELECT IfcCsgSelect;
-    // C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect
-    typedef SELECT IfcCurveFontOrScaledCurveFontSelect;
-    // C++ wrapper type for IfcCurveOrEdgeCurve
-    typedef SELECT IfcCurveOrEdgeCurve;
-    // C++ wrapper type for IfcCurveStyleFontSelect
-    typedef SELECT IfcCurveStyleFontSelect;
-    // C++ wrapper type for IfcDateTimeSelect
-    typedef SELECT IfcDateTimeSelect;
-    // C++ wrapper type for IfcDefinedSymbolSelect
-    typedef SELECT IfcDefinedSymbolSelect;
-    // C++ wrapper type for IfcDerivedMeasureValue
-    typedef SELECT IfcDerivedMeasureValue;
-    // C++ wrapper type for IfcDocumentSelect
-    typedef SELECT IfcDocumentSelect;
-    // C++ wrapper type for IfcDraughtingCalloutElement
-    typedef SELECT IfcDraughtingCalloutElement;
-    // C++ wrapper type for IfcFillAreaStyleTileShapeSelect
-    typedef SELECT IfcFillAreaStyleTileShapeSelect;
-    // C++ wrapper type for IfcFillStyleSelect
-    typedef SELECT IfcFillStyleSelect;
-    // C++ wrapper type for IfcGeometricSetSelect
-    typedef SELECT IfcGeometricSetSelect;
-    // C++ wrapper type for IfcHatchLineDistanceSelect
-    typedef SELECT IfcHatchLineDistanceSelect;
-    // C++ wrapper type for IfcLayeredItem
-    typedef SELECT IfcLayeredItem;
-    // C++ wrapper type for IfcLibrarySelect
-    typedef SELECT IfcLibrarySelect;
-    // C++ wrapper type for IfcLightDistributionDataSourceSelect
-    typedef SELECT IfcLightDistributionDataSourceSelect;
-    // C++ wrapper type for IfcMaterialSelect
-    typedef SELECT IfcMaterialSelect;
-    // C++ wrapper type for IfcMeasureValue
-    typedef SELECT IfcMeasureValue;
-    // C++ wrapper type for IfcMetricValueSelect
-    typedef SELECT IfcMetricValueSelect;
-    // C++ wrapper type for IfcObjectReferenceSelect
-    typedef SELECT IfcObjectReferenceSelect;
-    // C++ wrapper type for IfcOrientationSelect
-    typedef SELECT IfcOrientationSelect;
-    // C++ wrapper type for IfcPointOrVertexPoint
-    typedef SELECT IfcPointOrVertexPoint;
-    // C++ wrapper type for IfcPresentationStyleSelect
-    typedef SELECT IfcPresentationStyleSelect;
-    // C++ wrapper type for IfcShell
-    typedef SELECT IfcShell;
-    // C++ wrapper type for IfcSimpleValue
-    typedef SELECT IfcSimpleValue;
-    // C++ wrapper type for IfcSizeSelect
-    typedef SELECT IfcSizeSelect;
-    // C++ wrapper type for IfcSpecularHighlightSelect
-    typedef SELECT IfcSpecularHighlightSelect;
-    // C++ wrapper type for IfcStructuralActivityAssignmentSelect
-    typedef SELECT IfcStructuralActivityAssignmentSelect;
-    // C++ wrapper type for IfcSurfaceOrFaceSurface
-    typedef SELECT IfcSurfaceOrFaceSurface;
-    // C++ wrapper type for IfcSurfaceStyleElementSelect
-    typedef SELECT IfcSurfaceStyleElementSelect;
-    // C++ wrapper type for IfcSymbolStyleSelect
-    typedef SELECT IfcSymbolStyleSelect;
-    // C++ wrapper type for IfcTextFontSelect
-    typedef SELECT IfcTextFontSelect;
-    // C++ wrapper type for IfcTextStyleSelect
-    typedef SELECT IfcTextStyleSelect;
-    // C++ wrapper type for IfcTrimmingSelect
-    typedef SELECT IfcTrimmingSelect;
-    // C++ wrapper type for IfcUnit
-    typedef SELECT IfcUnit;
-    // C++ wrapper type for IfcValue
-    typedef SELECT IfcValue;
-    // C++ wrapper type for IfcVectorOrDirection
-    typedef SELECT IfcVectorOrDirection;
-
-
-    // ******************************************************************************
-    // IFC Entities
-    // ******************************************************************************
-
-    struct IfcRepresentationItem;
-    struct IfcGeometricRepresentationItem;
-    struct IfcCurve;
-    struct IfcBoundedCurve;
-    struct IfcCompositeCurve;
-    struct Ifc2DCompositeCurve;
-    struct IfcRoot;
-    struct IfcObjectDefinition;
-    struct IfcObject;
-    struct IfcControl;
-    struct IfcActionRequest;
-    struct IfcActor;
-    typedef NotImplemented IfcActorRole; // (not currently used by Assimp)
-    struct IfcTypeObject;
-    struct IfcTypeProduct;
-    struct IfcElementType;
-    struct IfcDistributionElementType;
-    struct IfcDistributionControlElementType;
-    struct IfcActuatorType;
-    typedef NotImplemented IfcAddress; // (not currently used by Assimp)
-    struct IfcDistributionFlowElementType;
-    struct IfcFlowControllerType;
-    struct IfcAirTerminalBoxType;
-    struct IfcFlowTerminalType;
-    struct IfcAirTerminalType;
-    struct IfcEnergyConversionDeviceType;
-    struct IfcAirToAirHeatRecoveryType;
-    struct IfcAlarmType;
-    struct IfcDraughtingCallout;
-    struct IfcDimensionCurveDirectedCallout;
-    struct IfcAngularDimension;
-    struct IfcProduct;
-    struct IfcAnnotation;
-    struct IfcStyledItem;
-    struct IfcAnnotationOccurrence;
-    struct IfcAnnotationCurveOccurrence;
-    struct IfcAnnotationFillArea;
-    struct IfcAnnotationFillAreaOccurrence;
-    struct IfcAnnotationSurface;
-    struct IfcAnnotationSurfaceOccurrence;
-    struct IfcAnnotationSymbolOccurrence;
-    struct IfcAnnotationTextOccurrence;
-    typedef NotImplemented IfcApplication; // (not currently used by Assimp)
-    typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp)
-    typedef NotImplemented IfcAppliedValueRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcApproval; // (not currently used by Assimp)
-    typedef NotImplemented IfcApprovalActorRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcApprovalPropertyRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcApprovalRelationship; // (not currently used by Assimp)
-    struct IfcProfileDef;
-    struct IfcArbitraryClosedProfileDef;
-    struct IfcArbitraryOpenProfileDef;
-    struct IfcArbitraryProfileDefWithVoids;
-    struct IfcGroup;
-    struct IfcAsset;
-    struct IfcParameterizedProfileDef;
-    struct IfcIShapeProfileDef;
-    struct IfcAsymmetricIShapeProfileDef;
-    struct IfcPlacement;
-    struct IfcAxis1Placement;
-    struct IfcAxis2Placement2D;
-    struct IfcAxis2Placement3D;
-    struct IfcBSplineCurve;
-    struct IfcElement;
-    struct IfcBuildingElement;
-    struct IfcBeam;
-    struct IfcBuildingElementType;
-    struct IfcBeamType;
-    struct IfcBezierCurve;
-    typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp)
-    typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp)
-    struct IfcCsgPrimitive3D;
-    struct IfcBlock;
-    struct IfcBoilerType;
-    struct IfcBooleanResult;
-    struct IfcBooleanClippingResult;
-    typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp)
-    typedef NotImplemented IfcBoundaryEdgeCondition; // (not currently used by Assimp)
-    typedef NotImplemented IfcBoundaryFaceCondition; // (not currently used by Assimp)
-    typedef NotImplemented IfcBoundaryNodeCondition; // (not currently used by Assimp)
-    typedef NotImplemented IfcBoundaryNodeConditionWarping; // (not currently used by Assimp)
-    struct IfcSurface;
-    struct IfcBoundedSurface;
-    struct IfcBoundingBox;
-    struct IfcHalfSpaceSolid;
-    struct IfcBoxedHalfSpace;
-    struct IfcSpatialStructureElement;
-    struct IfcBuilding;
-    struct IfcBuildingElementComponent;
-    struct IfcBuildingElementPart;
-    struct IfcBuildingElementProxy;
-    struct IfcBuildingElementProxyType;
-    struct IfcBuildingStorey;
-    struct IfcCShapeProfileDef;
-    struct IfcFlowFittingType;
-    struct IfcCableCarrierFittingType;
-    struct IfcFlowSegmentType;
-    struct IfcCableCarrierSegmentType;
-    struct IfcCableSegmentType;
-    typedef NotImplemented IfcCalendarDate; // (not currently used by Assimp)
-    struct IfcPoint;
-    struct IfcCartesianPoint;
-    struct IfcCartesianTransformationOperator;
-    struct IfcCartesianTransformationOperator2D;
-    struct IfcCartesianTransformationOperator2DnonUniform;
-    struct IfcCartesianTransformationOperator3D;
-    struct IfcCartesianTransformationOperator3DnonUniform;
-    struct IfcCenterLineProfileDef;
-    struct IfcFeatureElement;
-    struct IfcFeatureElementSubtraction;
-    struct IfcEdgeFeature;
-    struct IfcChamferEdgeFeature;
-    struct IfcChillerType;
-    struct IfcConic;
-    struct IfcCircle;
-    struct IfcCircleProfileDef;
-    struct IfcCircleHollowProfileDef;
-    typedef NotImplemented IfcClassification; // (not currently used by Assimp)
-    typedef NotImplemented IfcClassificationItem; // (not currently used by Assimp)
-    typedef NotImplemented IfcClassificationItemRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcClassificationNotation; // (not currently used by Assimp)
-    typedef NotImplemented IfcClassificationNotationFacet; // (not currently used by Assimp)
-    typedef NotImplemented IfcExternalReference; // (not currently used by Assimp)
-    typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp)
-    struct IfcTopologicalRepresentationItem;
-    struct IfcConnectedFaceSet;
-    struct IfcClosedShell;
-    struct IfcCoilType;
-    struct IfcColourSpecification;
-    struct IfcColourRgb;
-    struct IfcColumn;
-    struct IfcColumnType;
-    struct IfcProperty;
-    struct IfcComplexProperty;
-    struct IfcCompositeCurveSegment;
-    struct IfcCompositeProfileDef;
-    struct IfcFlowMovingDeviceType;
-    struct IfcCompressorType;
-    struct IfcCondenserType;
-    struct IfcCondition;
-    struct IfcConditionCriterion;
-    typedef NotImplemented IfcConnectionGeometry; // (not currently used by Assimp)
-    typedef NotImplemented IfcConnectionCurveGeometry; // (not currently used by Assimp)
-    typedef NotImplemented IfcConnectionPointGeometry; // (not currently used by Assimp)
-    typedef NotImplemented IfcConnectionPointEccentricity; // (not currently used by Assimp)
-    typedef NotImplemented IfcConnectionPortGeometry; // (not currently used by Assimp)
-    typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp)
-    typedef NotImplemented IfcConstraint; // (not currently used by Assimp)
-    typedef NotImplemented IfcConstraintAggregationRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcConstraintClassificationRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcConstraintRelationship; // (not currently used by Assimp)
-    struct IfcResource;
-    struct IfcConstructionResource;
-    struct IfcConstructionEquipmentResource;
-    struct IfcConstructionMaterialResource;
-    struct IfcConstructionProductResource;
-    struct IfcNamedUnit;
-    struct IfcContextDependentUnit;
-    struct IfcControllerType;
-    struct IfcConversionBasedUnit;
-    struct IfcCooledBeamType;
-    struct IfcCoolingTowerType;
-    typedef NotImplemented IfcCoordinatedUniversalTimeOffset; // (not currently used by Assimp)
-    struct IfcCostItem;
-    struct IfcCostSchedule;
-    typedef NotImplemented IfcCostValue; // (not currently used by Assimp)
-    struct IfcCovering;
-    struct IfcCoveringType;
-    struct IfcCraneRailAShapeProfileDef;
-    struct IfcCraneRailFShapeProfileDef;
-    struct IfcCrewResource;
-    struct IfcSolidModel;
-    struct IfcCsgSolid;
-    typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp)
-    struct IfcCurtainWall;
-    struct IfcCurtainWallType;
-    struct IfcCurveBoundedPlane;
-    struct IfcPresentationStyle;
-    typedef NotImplemented IfcCurveStyle; // (not currently used by Assimp)
-    typedef NotImplemented IfcCurveStyleFont; // (not currently used by Assimp)
-    typedef NotImplemented IfcCurveStyleFontAndScaling; // (not currently used by Assimp)
-    typedef NotImplemented IfcCurveStyleFontPattern; // (not currently used by Assimp)
-    struct IfcDamperType;
-    typedef NotImplemented IfcDateAndTime; // (not currently used by Assimp)
-    struct IfcDefinedSymbol;
-    struct IfcDerivedProfileDef;
-    typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp)
-    typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp)
-    struct IfcDiameterDimension;
-    typedef NotImplemented IfcDraughtingCalloutRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcDimensionCalloutRelationship; // (not currently used by Assimp)
-    struct IfcDimensionCurve;
-    struct IfcTerminatorSymbol;
-    struct IfcDimensionCurveTerminator;
-    typedef NotImplemented IfcDimensionPair; // (not currently used by Assimp)
-    typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp)
-    struct IfcDirection;
-    struct IfcElementComponent;
-    struct IfcDiscreteAccessory;
-    struct IfcElementComponentType;
-    struct IfcDiscreteAccessoryType;
-    struct IfcDistributionElement;
-    struct IfcDistributionFlowElement;
-    struct IfcDistributionChamberElement;
-    struct IfcDistributionChamberElementType;
-    struct IfcDistributionControlElement;
-    struct IfcPort;
-    struct IfcDistributionPort;
-    typedef NotImplemented IfcDocumentElectronicFormat; // (not currently used by Assimp)
-    typedef NotImplemented IfcDocumentInformation; // (not currently used by Assimp)
-    typedef NotImplemented IfcDocumentInformationRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcDocumentReference; // (not currently used by Assimp)
-    struct IfcDoor;
-    struct IfcPropertyDefinition;
-    struct IfcPropertySetDefinition;
-    typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp)
-    struct IfcDoorStyle;
-    typedef NotImplemented IfcPreDefinedItem; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedColour; // (not currently used by Assimp)
-    typedef NotImplemented IfcDraughtingPreDefinedColour; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedCurveFont; // (not currently used by Assimp)
-    typedef NotImplemented IfcDraughtingPreDefinedCurveFont; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp)
-    typedef NotImplemented IfcDraughtingPreDefinedTextFont; // (not currently used by Assimp)
-    struct IfcDuctFittingType;
-    struct IfcDuctSegmentType;
-    struct IfcFlowTreatmentDeviceType;
-    struct IfcDuctSilencerType;
-    struct IfcEdge;
-    struct IfcEdgeCurve;
-    struct IfcLoop;
-    struct IfcEdgeLoop;
-    struct IfcElectricApplianceType;
-    struct IfcFlowController;
-    struct IfcElectricDistributionPoint;
-    struct IfcFlowStorageDeviceType;
-    struct IfcElectricFlowStorageDeviceType;
-    struct IfcElectricGeneratorType;
-    struct IfcElectricHeaterType;
-    struct IfcElectricMotorType;
-    struct IfcElectricTimeControlType;
-    typedef NotImplemented IfcEnergyProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcElectricalBaseProperties; // (not currently used by Assimp)
-    struct IfcSystem;
-    struct IfcElectricalCircuit;
-    struct IfcElectricalElement;
-    struct IfcElementAssembly;
-    struct IfcElementQuantity;
-    struct IfcElementarySurface;
-    struct IfcEllipse;
-    struct IfcEllipseProfileDef;
-    struct IfcEnergyConversionDevice;
-    typedef NotImplemented IfcEnvironmentalImpactValue; // (not currently used by Assimp)
-    struct IfcEquipmentElement;
-    struct IfcEquipmentStandard;
-    struct IfcEvaporativeCoolerType;
-    struct IfcEvaporatorType;
-    typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcExtendedMaterialProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp)
-    typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp)
-    typedef NotImplemented IfcExternallyDefinedSymbol; // (not currently used by Assimp)
-    typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp)
-    struct IfcSweptAreaSolid;
-    struct IfcExtrudedAreaSolid;
-    struct IfcFace;
-    struct IfcFaceBasedSurfaceModel;
-    struct IfcFaceBound;
-    struct IfcFaceOuterBound;
-    struct IfcFaceSurface;
-    struct IfcManifoldSolidBrep;
-    struct IfcFacetedBrep;
-    struct IfcFacetedBrepWithVoids;
-    typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp)
-    typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp)
-    struct IfcFanType;
-    struct IfcFastener;
-    struct IfcFastenerType;
-    struct IfcFeatureElementAddition;
-    typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp)
-    struct IfcFillAreaStyleHatching;
-    struct IfcFillAreaStyleTileSymbolWithStyle;
-    struct IfcFillAreaStyleTiles;
-    struct IfcFilterType;
-    struct IfcFireSuppressionTerminalType;
-    struct IfcFlowFitting;
-    struct IfcFlowInstrumentType;
-    struct IfcFlowMeterType;
-    struct IfcFlowMovingDevice;
-    struct IfcFlowSegment;
-    struct IfcFlowStorageDevice;
-    struct IfcFlowTerminal;
-    struct IfcFlowTreatmentDevice;
-    typedef NotImplemented IfcFluidFlowProperties; // (not currently used by Assimp)
-    struct IfcFooting;
-    typedef NotImplemented IfcFuelProperties; // (not currently used by Assimp)
-    struct IfcFurnishingElement;
-    struct IfcFurnishingElementType;
-    struct IfcFurnitureStandard;
-    struct IfcFurnitureType;
-    struct IfcGasTerminalType;
-    typedef NotImplemented IfcGeneralMaterialProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcGeneralProfileProperties; // (not currently used by Assimp)
-    struct IfcGeometricSet;
-    struct IfcGeometricCurveSet;
-    struct IfcRepresentationContext;
-    struct IfcGeometricRepresentationContext;
-    struct IfcGeometricRepresentationSubContext;
-    struct IfcGrid;
-    typedef NotImplemented IfcGridAxis; // (not currently used by Assimp)
-    struct IfcObjectPlacement;
-    struct IfcGridPlacement;
-    struct IfcHeatExchangerType;
-    struct IfcHumidifierType;
-    typedef NotImplemented IfcHygroscopicMaterialProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcImageTexture; // (not currently used by Assimp)
-    struct IfcInventory;
-    typedef NotImplemented IfcTimeSeries; // (not currently used by Assimp)
-    typedef NotImplemented IfcIrregularTimeSeries; // (not currently used by Assimp)
-    typedef NotImplemented IfcIrregularTimeSeriesValue; // (not currently used by Assimp)
-    struct IfcJunctionBoxType;
-    struct IfcLShapeProfileDef;
-    struct IfcLaborResource;
-    struct IfcLampType;
-    typedef NotImplemented IfcLibraryInformation; // (not currently used by Assimp)
-    typedef NotImplemented IfcLibraryReference; // (not currently used by Assimp)
-    typedef NotImplemented IfcLightDistributionData; // (not currently used by Assimp)
-    struct IfcLightFixtureType;
-    typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp)
-    struct IfcLightSource;
-    struct IfcLightSourceAmbient;
-    struct IfcLightSourceDirectional;
-    struct IfcLightSourceGoniometric;
-    struct IfcLightSourcePositional;
-    struct IfcLightSourceSpot;
-    struct IfcLine;
-    struct IfcLinearDimension;
-    struct IfcLocalPlacement;
-    typedef NotImplemented IfcLocalTime; // (not currently used by Assimp)
-    struct IfcMappedItem;
-    typedef NotImplemented IfcMaterial; // (not currently used by Assimp)
-    typedef NotImplemented IfcMaterialClassificationRelationship; // (not currently used by Assimp)
-    struct IfcProductRepresentation;
-    struct IfcMaterialDefinitionRepresentation;
-    typedef NotImplemented IfcMaterialLayer; // (not currently used by Assimp)
-    typedef NotImplemented IfcMaterialLayerSet; // (not currently used by Assimp)
-    typedef NotImplemented IfcMaterialLayerSetUsage; // (not currently used by Assimp)
-    typedef NotImplemented IfcMaterialList; // (not currently used by Assimp)
-    struct IfcMeasureWithUnit;
-    typedef NotImplemented IfcMechanicalMaterialProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcMechanicalConcreteMaterialProperties; // (not currently used by Assimp)
-    struct IfcMechanicalFastener;
-    struct IfcMechanicalFastenerType;
-    typedef NotImplemented IfcMechanicalSteelMaterialProperties; // (not currently used by Assimp)
-    struct IfcMember;
-    struct IfcMemberType;
-    typedef NotImplemented IfcMetric; // (not currently used by Assimp)
-    typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp)
-    struct IfcMotorConnectionType;
-    struct IfcProcess;
-    struct IfcTask;
-    struct IfcMove;
-    typedef NotImplemented IfcObjective; // (not currently used by Assimp)
-    struct IfcOccupant;
-    struct IfcOffsetCurve2D;
-    struct IfcOffsetCurve3D;
-    struct IfcOneDirectionRepeatFactor;
-    struct IfcOpenShell;
-    struct IfcOpeningElement;
-    typedef NotImplemented IfcOpticalMaterialProperties; // (not currently used by Assimp)
-    struct IfcOrderAction;
-    typedef NotImplemented IfcOrganization; // (not currently used by Assimp)
-    typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp)
-    struct IfcOrientedEdge;
-    struct IfcOutletType;
-    typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp)
-    struct IfcPath;
-    struct IfcPerformanceHistory;
-    typedef NotImplemented IfcPermeableCoveringProperties; // (not currently used by Assimp)
-    struct IfcPermit;
-    typedef NotImplemented IfcPerson; // (not currently used by Assimp)
-    typedef NotImplemented IfcPersonAndOrganization; // (not currently used by Assimp)
-    typedef NotImplemented IfcPhysicalQuantity; // (not currently used by Assimp)
-    typedef NotImplemented IfcPhysicalComplexQuantity; // (not currently used by Assimp)
-    typedef NotImplemented IfcPhysicalSimpleQuantity; // (not currently used by Assimp)
-    struct IfcPile;
-    struct IfcPipeFittingType;
-    struct IfcPipeSegmentType;
-    typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp)
-    struct IfcPlanarExtent;
-    struct IfcPlanarBox;
-    struct IfcPlane;
-    struct IfcPlate;
-    struct IfcPlateType;
-    struct IfcPointOnCurve;
-    struct IfcPointOnSurface;
-    struct IfcPolyLoop;
-    struct IfcPolygonalBoundedHalfSpace;
-    struct IfcPolyline;
-    typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedSymbol; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedDimensionSymbol; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedPointMarkerSymbol; // (not currently used by Assimp)
-    typedef NotImplemented IfcPreDefinedTerminatorSymbol; // (not currently used by Assimp)
-    typedef NotImplemented IfcPresentationLayerAssignment; // (not currently used by Assimp)
-    typedef NotImplemented IfcPresentationLayerWithStyle; // (not currently used by Assimp)
-    struct IfcPresentationStyleAssignment;
-    struct IfcProcedure;
-    struct IfcProductDefinitionShape;
-    typedef NotImplemented IfcProductsOfCombustionProperties; // (not currently used by Assimp)
-    struct IfcProject;
-    struct IfcProjectOrder;
-    struct IfcProjectOrderRecord;
-    struct IfcProjectionCurve;
-    struct IfcProjectionElement;
-    struct IfcSimpleProperty;
-    struct IfcPropertyBoundedValue;
-    typedef NotImplemented IfcPropertyConstraintRelationship; // (not currently used by Assimp)
-    typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp)
-    struct IfcPropertyEnumeratedValue;
-    typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp)
-    struct IfcPropertyListValue;
-    struct IfcPropertyReferenceValue;
-    struct IfcPropertySet;
-    struct IfcPropertySingleValue;
-    struct IfcPropertyTableValue;
-    struct IfcProtectiveDeviceType;
-    struct IfcProxy;
-    struct IfcPumpType;
-    typedef NotImplemented IfcQuantityArea; // (not currently used by Assimp)
-    typedef NotImplemented IfcQuantityCount; // (not currently used by Assimp)
-    typedef NotImplemented IfcQuantityLength; // (not currently used by Assimp)
-    typedef NotImplemented IfcQuantityTime; // (not currently used by Assimp)
-    typedef NotImplemented IfcQuantityVolume; // (not currently used by Assimp)
-    typedef NotImplemented IfcQuantityWeight; // (not currently used by Assimp)
-    struct IfcRadiusDimension;
-    struct IfcRailing;
-    struct IfcRailingType;
-    struct IfcRamp;
-    struct IfcRampFlight;
-    struct IfcRampFlightType;
-    struct IfcRationalBezierCurve;
-    struct IfcRectangleProfileDef;
-    struct IfcRectangleHollowProfileDef;
-    struct IfcRectangularPyramid;
-    struct IfcRectangularTrimmedSurface;
-    typedef NotImplemented IfcReferencesValueDocument; // (not currently used by Assimp)
-    typedef NotImplemented IfcRegularTimeSeries; // (not currently used by Assimp)
-    typedef NotImplemented IfcReinforcementBarProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcReinforcementDefinitionProperties; // (not currently used by Assimp)
-    struct IfcReinforcingElement;
-    struct IfcReinforcingBar;
-    struct IfcReinforcingMesh;
-    struct IfcRelationship;
-    struct IfcRelDecomposes;
-    struct IfcRelAggregates;
-    typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsTasks; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToProjectOrder; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesAppliedValue; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesApproval; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesClassification; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesConstraint; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesDocument; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesLibrary; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesMaterial; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelAssociatesProfileProperties; // (not currently used by Assimp)
-    struct IfcRelConnects;
-    typedef NotImplemented IfcRelConnectsElements; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsPathElements; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsPortToElement; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsPorts; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsStructuralActivity; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsStructuralElement; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsStructuralMember; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsWithEccentricity; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelConnectsWithRealizingElements; // (not currently used by Assimp)
-    struct IfcRelContainedInSpatialStructure;
-    typedef NotImplemented IfcRelCoversBldgElements; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelCoversSpaces; // (not currently used by Assimp)
-    struct IfcRelDefines;
-    struct IfcRelDefinesByProperties;
-    typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp)
-    struct IfcRelFillsElement;
-    typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelInteractionRequirements; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelNests; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelOccupiesSpaces; // (not currently used by Assimp)
-    struct IfcRelOverridesProperties;
-    typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelSchedulesCostItems; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelSequence; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelServicesBuildings; // (not currently used by Assimp)
-    typedef NotImplemented IfcRelSpaceBoundary; // (not currently used by Assimp)
-    struct IfcRelVoidsElement;
-    typedef NotImplemented IfcRelaxation; // (not currently used by Assimp)
-    struct IfcRepresentation;
-    struct IfcRepresentationMap;
-    struct IfcRevolvedAreaSolid;
-    typedef NotImplemented IfcRibPlateProfileProperties; // (not currently used by Assimp)
-    struct IfcRightCircularCone;
-    struct IfcRightCircularCylinder;
-    struct IfcRoof;
-    struct IfcRoundedEdgeFeature;
-    struct IfcRoundedRectangleProfileDef;
-    struct IfcSIUnit;
-    struct IfcSanitaryTerminalType;
-    struct IfcScheduleTimeControl;
-    typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp)
-    struct IfcSectionedSpine;
-    struct IfcSensorType;
-    struct IfcServiceLife;
-    typedef NotImplemented IfcServiceLifeFactor; // (not currently used by Assimp)
-    typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp)
-    struct IfcShapeModel;
-    struct IfcShapeRepresentation;
-    struct IfcShellBasedSurfaceModel;
-    struct IfcSite;
-    struct IfcSlab;
-    struct IfcSlabType;
-    typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp)
-    typedef NotImplemented IfcSoundProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcSoundValue; // (not currently used by Assimp)
-    struct IfcSpace;
-    struct IfcSpaceHeaterType;
-    struct IfcSpaceProgram;
-    typedef NotImplemented IfcSpaceThermalLoadProperties; // (not currently used by Assimp)
-    struct IfcSpatialStructureElementType;
-    struct IfcSpaceType;
-    struct IfcSphere;
-    struct IfcStackTerminalType;
-    struct IfcStair;
-    struct IfcStairFlight;
-    struct IfcStairFlightType;
-    struct IfcStructuralActivity;
-    struct IfcStructuralAction;
-    struct IfcStructuralAnalysisModel;
-    struct IfcStructuralItem;
-    struct IfcStructuralConnection;
-    struct IfcStructuralCurveConnection;
-    struct IfcStructuralMember;
-    struct IfcStructuralCurveMember;
-    struct IfcStructuralCurveMemberVarying;
-    struct IfcStructuralLinearAction;
-    struct IfcStructuralLinearActionVarying;
-    typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp)
-    struct IfcStructuralLoadGroup;
-    typedef NotImplemented IfcStructuralLoadStatic; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadLinearForce; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadPlanarForce; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadSingleDisplacement; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadSingleDisplacementDistortion; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadSingleForce; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadSingleForceWarping; // (not currently used by Assimp)
-    typedef NotImplemented IfcStructuralLoadTemperature; // (not currently used by Assimp)
-    struct IfcStructuralPlanarAction;
-    struct IfcStructuralPlanarActionVarying;
-    struct IfcStructuralPointAction;
-    struct IfcStructuralPointConnection;
-    struct IfcStructuralReaction;
-    struct IfcStructuralPointReaction;
-    typedef NotImplemented IfcStructuralProfileProperties; // (not currently used by Assimp)
-    struct IfcStructuralResultGroup;
-    typedef NotImplemented IfcStructuralSteelProfileProperties; // (not currently used by Assimp)
-    struct IfcStructuralSurfaceConnection;
-    struct IfcStructuralSurfaceMember;
-    struct IfcStructuralSurfaceMemberVarying;
-    struct IfcStructuredDimensionCallout;
-    struct IfcStyleModel;
-    struct IfcStyledRepresentation;
-    struct IfcSubContractResource;
-    struct IfcSubedge;
-    struct IfcSurfaceCurveSweptAreaSolid;
-    struct IfcSweptSurface;
-    struct IfcSurfaceOfLinearExtrusion;
-    struct IfcSurfaceOfRevolution;
-    struct IfcSurfaceStyle;
-    typedef NotImplemented IfcSurfaceStyleLighting; // (not currently used by Assimp)
-    typedef NotImplemented IfcSurfaceStyleRefraction; // (not currently used by Assimp)
-    struct IfcSurfaceStyleShading;
-    struct IfcSurfaceStyleRendering;
-    struct IfcSurfaceStyleWithTextures;
-    struct IfcSweptDiskSolid;
-    struct IfcSwitchingDeviceType;
-    typedef NotImplemented IfcSymbolStyle; // (not currently used by Assimp)
-    struct IfcSystemFurnitureElementType;
-    struct IfcTShapeProfileDef;
-    typedef NotImplemented IfcTable; // (not currently used by Assimp)
-    typedef NotImplemented IfcTableRow; // (not currently used by Assimp)
-    struct IfcTankType;
-    typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp)
-    struct IfcTendon;
-    struct IfcTendonAnchor;
-    struct IfcTextLiteral;
-    struct IfcTextLiteralWithExtent;
-    typedef NotImplemented IfcTextStyle; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextStyleFontModel; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextStyleForDefinedFont; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextStyleTextModel; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextStyleWithBoxCharacteristics; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextureCoordinate; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextureCoordinateGenerator; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextureMap; // (not currently used by Assimp)
-    typedef NotImplemented IfcTextureVertex; // (not currently used by Assimp)
-    typedef NotImplemented IfcThermalMaterialProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcTimeSeriesReferenceRelationship; // (not currently used by Assimp)
-    struct IfcTimeSeriesSchedule;
-    typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp)
-    struct IfcTopologyRepresentation;
-    struct IfcTransformerType;
-    struct IfcTransportElement;
-    struct IfcTransportElementType;
-    struct IfcTrapeziumProfileDef;
-    struct IfcTrimmedCurve;
-    struct IfcTubeBundleType;
-    struct IfcTwoDirectionRepeatFactor;
-    struct IfcUShapeProfileDef;
-    struct IfcUnitAssignment;
-    struct IfcUnitaryEquipmentType;
-    struct IfcValveType;
-    struct IfcVector;
-    struct IfcVertex;
-    typedef NotImplemented IfcVertexBasedTextureMap; // (not currently used by Assimp)
-    struct IfcVertexLoop;
-    struct IfcVertexPoint;
-    struct IfcVibrationIsolatorType;
-    struct IfcVirtualElement;
-    typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp)
-    struct IfcWall;
-    struct IfcWallStandardCase;
-    struct IfcWallType;
-    struct IfcWasteTerminalType;
-    typedef NotImplemented IfcWaterProperties; // (not currently used by Assimp)
-    struct IfcWindow;
-    typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp)
-    typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp)
-    struct IfcWindowStyle;
-    struct IfcWorkControl;
-    struct IfcWorkPlan;
-    struct IfcWorkSchedule;
-    struct IfcZShapeProfileDef;
-    struct IfcZone;
-
-
-
-    // C++ wrapper for IfcRepresentationItem
-    struct IfcRepresentationItem :  ObjectHelper<IfcRepresentationItem,0> { IfcRepresentationItem() : Object("IfcRepresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcGeometricRepresentationItem
-    struct IfcGeometricRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcGeometricRepresentationItem,0> { IfcGeometricRepresentationItem() : Object("IfcGeometricRepresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcCurve
-    struct IfcCurve : IfcGeometricRepresentationItem, ObjectHelper<IfcCurve,0> { IfcCurve() : Object("IfcCurve") {}
-
-    };
-
-    // C++ wrapper for IfcBoundedCurve
-    struct IfcBoundedCurve : IfcCurve, ObjectHelper<IfcBoundedCurve,0> { IfcBoundedCurve() : Object("IfcBoundedCurve") {}
-
-    };
-
-    // C++ wrapper for IfcCompositeCurve
-    struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {}
-        ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments;
-        LOGICAL::Out SelfIntersect;
-    };
-
-    // C++ wrapper for Ifc2DCompositeCurve
-    struct Ifc2DCompositeCurve : IfcCompositeCurve, ObjectHelper<Ifc2DCompositeCurve,0> { Ifc2DCompositeCurve() : Object("Ifc2DCompositeCurve") {}
-
-    };
-
-    // C++ wrapper for IfcRoot
-    struct IfcRoot :  ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {}
-        IfcGloballyUniqueId::Out GlobalId;
-        Lazy< NotImplemented > OwnerHistory;
-        Maybe< IfcLabel::Out > Name;
-        Maybe< IfcText::Out > Description;
-    };
-
-    // C++ wrapper for IfcObjectDefinition
-    struct IfcObjectDefinition : IfcRoot, ObjectHelper<IfcObjectDefinition,0> { IfcObjectDefinition() : Object("IfcObjectDefinition") {}
-
-    };
-
-    // C++ wrapper for IfcObject
-    struct IfcObject : IfcObjectDefinition, ObjectHelper<IfcObject,1> { IfcObject() : Object("IfcObject") {}
-        Maybe< IfcLabel::Out > ObjectType;
-    };
-
-    // C++ wrapper for IfcControl
-    struct IfcControl : IfcObject, ObjectHelper<IfcControl,0> { IfcControl() : Object("IfcControl") {}
-
-    };
-
-    // C++ wrapper for IfcActionRequest
-    struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,1> { IfcActionRequest() : Object("IfcActionRequest") {}
-        IfcIdentifier::Out RequestID;
-    };
-
-    // C++ wrapper for IfcActor
-    struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {}
-        IfcActorSelect::Out TheActor;
-    };
-
-    // C++ wrapper for IfcTypeObject
-    struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {}
-        Maybe< IfcLabel::Out > ApplicableOccurrence;
-        Maybe< ListOf< Lazy< IfcPropertySetDefinition >, 1, 0 > > HasPropertySets;
-    };
-
-    // C++ wrapper for IfcTypeProduct
-    struct IfcTypeProduct : IfcTypeObject, ObjectHelper<IfcTypeProduct,2> { IfcTypeProduct() : Object("IfcTypeProduct") {}
-        Maybe< ListOf< Lazy< IfcRepresentationMap >, 1, 0 > > RepresentationMaps;
-        Maybe< IfcLabel::Out > Tag;
-    };
-
-    // C++ wrapper for IfcElementType
-    struct IfcElementType : IfcTypeProduct, ObjectHelper<IfcElementType,1> { IfcElementType() : Object("IfcElementType") {}
-        Maybe< IfcLabel::Out > ElementType;
-    };
-
-    // C++ wrapper for IfcDistributionElementType
-    struct IfcDistributionElementType : IfcElementType, ObjectHelper<IfcDistributionElementType,0> { IfcDistributionElementType() : Object("IfcDistributionElementType") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionControlElementType
-    struct IfcDistributionControlElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionControlElementType,0> { IfcDistributionControlElementType() : Object("IfcDistributionControlElementType") {}
-
-    };
-
-    // C++ wrapper for IfcActuatorType
-    struct IfcActuatorType : IfcDistributionControlElementType, ObjectHelper<IfcActuatorType,1> { IfcActuatorType() : Object("IfcActuatorType") {}
-        IfcActuatorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionFlowElementType
-    struct IfcDistributionFlowElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionFlowElementType,0> { IfcDistributionFlowElementType() : Object("IfcDistributionFlowElementType") {}
-
-    };
-
-    // C++ wrapper for IfcFlowControllerType
-    struct IfcFlowControllerType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowControllerType,0> { IfcFlowControllerType() : Object("IfcFlowControllerType") {}
-
-    };
-
-    // C++ wrapper for IfcAirTerminalBoxType
-    struct IfcAirTerminalBoxType : IfcFlowControllerType, ObjectHelper<IfcAirTerminalBoxType,1> { IfcAirTerminalBoxType() : Object("IfcAirTerminalBoxType") {}
-        IfcAirTerminalBoxTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowTerminalType
-    struct IfcFlowTerminalType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTerminalType,0> { IfcFlowTerminalType() : Object("IfcFlowTerminalType") {}
-
-    };
-
-    // C++ wrapper for IfcAirTerminalType
-    struct IfcAirTerminalType : IfcFlowTerminalType, ObjectHelper<IfcAirTerminalType,1> { IfcAirTerminalType() : Object("IfcAirTerminalType") {}
-        IfcAirTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEnergyConversionDeviceType
-    struct IfcEnergyConversionDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcEnergyConversionDeviceType,0> { IfcEnergyConversionDeviceType() : Object("IfcEnergyConversionDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcAirToAirHeatRecoveryType
-    struct IfcAirToAirHeatRecoveryType : IfcEnergyConversionDeviceType, ObjectHelper<IfcAirToAirHeatRecoveryType,1> { IfcAirToAirHeatRecoveryType() : Object("IfcAirToAirHeatRecoveryType") {}
-        IfcAirToAirHeatRecoveryTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcAlarmType
-    struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {}
-        IfcAlarmTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDraughtingCallout
-    struct IfcDraughtingCallout : IfcGeometricRepresentationItem, ObjectHelper<IfcDraughtingCallout,1> { IfcDraughtingCallout() : Object("IfcDraughtingCallout") {}
-        ListOf< IfcDraughtingCalloutElement, 1, 0 >::Out Contents;
-    };
-
-    // C++ wrapper for IfcDimensionCurveDirectedCallout
-    struct IfcDimensionCurveDirectedCallout : IfcDraughtingCallout, ObjectHelper<IfcDimensionCurveDirectedCallout,0> { IfcDimensionCurveDirectedCallout() : Object("IfcDimensionCurveDirectedCallout") {}
-
-    };
-
-    // C++ wrapper for IfcAngularDimension
-    struct IfcAngularDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcAngularDimension,0> { IfcAngularDimension() : Object("IfcAngularDimension") {}
-
-    };
-
-    // C++ wrapper for IfcProduct
-    struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {}
-        Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement;
-        Maybe< Lazy< IfcProductRepresentation > > Representation;
-    };
-
-    // C++ wrapper for IfcAnnotation
-    struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {}
-
-    };
-
-    // C++ wrapper for IfcStyledItem
-    struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {}
-        Maybe< Lazy< IfcRepresentationItem > > Item;
-        ListOf< Lazy< IfcPresentationStyleAssignment >, 1, 0 > Styles;
-        Maybe< IfcLabel::Out > Name;
-    };
-
-    // C++ wrapper for IfcAnnotationOccurrence
-    struct IfcAnnotationOccurrence : IfcStyledItem, ObjectHelper<IfcAnnotationOccurrence,0> { IfcAnnotationOccurrence() : Object("IfcAnnotationOccurrence") {}
-
-    };
-
-    // C++ wrapper for IfcAnnotationCurveOccurrence
-    struct IfcAnnotationCurveOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationCurveOccurrence,0> { IfcAnnotationCurveOccurrence() : Object("IfcAnnotationCurveOccurrence") {}
-
-    };
-
-    // C++ wrapper for IfcAnnotationFillArea
-    struct IfcAnnotationFillArea : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationFillArea,2> { IfcAnnotationFillArea() : Object("IfcAnnotationFillArea") {}
-        Lazy< IfcCurve > OuterBoundary;
-        Maybe< ListOf< Lazy< IfcCurve >, 1, 0 > > InnerBoundaries;
-    };
-
-    // C++ wrapper for IfcAnnotationFillAreaOccurrence
-    struct IfcAnnotationFillAreaOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationFillAreaOccurrence,2> { IfcAnnotationFillAreaOccurrence() : Object("IfcAnnotationFillAreaOccurrence") {}
-        Maybe< Lazy< IfcPoint > > FillStyleTarget;
-        Maybe< IfcGlobalOrLocalEnum::Out > GlobalOrLocal;
-    };
-
-    // C++ wrapper for IfcAnnotationSurface
-    struct IfcAnnotationSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationSurface,2> { IfcAnnotationSurface() : Object("IfcAnnotationSurface") {}
-        Lazy< IfcGeometricRepresentationItem > Item;
-        Maybe< Lazy< NotImplemented > > TextureCoordinates;
-    };
-
-    // C++ wrapper for IfcAnnotationSurfaceOccurrence
-    struct IfcAnnotationSurfaceOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSurfaceOccurrence,0> { IfcAnnotationSurfaceOccurrence() : Object("IfcAnnotationSurfaceOccurrence") {}
-
-    };
-
-    // C++ wrapper for IfcAnnotationSymbolOccurrence
-    struct IfcAnnotationSymbolOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationSymbolOccurrence,0> { IfcAnnotationSymbolOccurrence() : Object("IfcAnnotationSymbolOccurrence") {}
-
-    };
-
-    // C++ wrapper for IfcAnnotationTextOccurrence
-    struct IfcAnnotationTextOccurrence : IfcAnnotationOccurrence, ObjectHelper<IfcAnnotationTextOccurrence,0> { IfcAnnotationTextOccurrence() : Object("IfcAnnotationTextOccurrence") {}
-
-    };
-
-    // C++ wrapper for IfcProfileDef
-    struct IfcProfileDef :  ObjectHelper<IfcProfileDef,2> { IfcProfileDef() : Object("IfcProfileDef") {}
-        IfcProfileTypeEnum::Out ProfileType;
-        Maybe< IfcLabel::Out > ProfileName;
-    };
-
-    // C++ wrapper for IfcArbitraryClosedProfileDef
-    struct IfcArbitraryClosedProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryClosedProfileDef,1> { IfcArbitraryClosedProfileDef() : Object("IfcArbitraryClosedProfileDef") {}
-        Lazy< IfcCurve > OuterCurve;
-    };
-
-    // C++ wrapper for IfcArbitraryOpenProfileDef
-    struct IfcArbitraryOpenProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryOpenProfileDef,1> { IfcArbitraryOpenProfileDef() : Object("IfcArbitraryOpenProfileDef") {}
-        Lazy< IfcBoundedCurve > Curve;
-    };
-
-    // C++ wrapper for IfcArbitraryProfileDefWithVoids
-    struct IfcArbitraryProfileDefWithVoids : IfcArbitraryClosedProfileDef, ObjectHelper<IfcArbitraryProfileDefWithVoids,1> { IfcArbitraryProfileDefWithVoids() : Object("IfcArbitraryProfileDefWithVoids") {}
-        ListOf< Lazy< IfcCurve >, 1, 0 > InnerCurves;
-    };
-
-    // C++ wrapper for IfcGroup
-    struct IfcGroup : IfcObject, ObjectHelper<IfcGroup,0> { IfcGroup() : Object("IfcGroup") {}
-
-    };
-
-    // C++ wrapper for IfcAsset
-    struct IfcAsset : IfcGroup, ObjectHelper<IfcAsset,9> { IfcAsset() : Object("IfcAsset") {}
-        IfcIdentifier::Out AssetID;
-        Lazy< NotImplemented > OriginalValue;
-        Lazy< NotImplemented > CurrentValue;
-        Lazy< NotImplemented > TotalReplacementCost;
-        IfcActorSelect::Out Owner;
-        IfcActorSelect::Out User;
-        Lazy< NotImplemented > ResponsiblePerson;
-        Lazy< NotImplemented > IncorporationDate;
-        Lazy< NotImplemented > DepreciatedValue;
-    };
-
-    // C++ wrapper for IfcParameterizedProfileDef
-    struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {}
-        Lazy< IfcAxis2Placement2D > Position;
-    };
-
-    // C++ wrapper for IfcIShapeProfileDef
-    struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,5> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out OverallWidth;
-        IfcPositiveLengthMeasure::Out OverallDepth;
-        IfcPositiveLengthMeasure::Out WebThickness;
-        IfcPositiveLengthMeasure::Out FlangeThickness;
-        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
-    };
-
-    // C++ wrapper for IfcAsymmetricIShapeProfileDef
-    struct IfcAsymmetricIShapeProfileDef : IfcIShapeProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,4> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out TopFlangeWidth;
-        Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness;
-        Maybe< IfcPositiveLengthMeasure::Out > TopFlangeFilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
-    };
-
-    // C++ wrapper for IfcPlacement
-    struct IfcPlacement : IfcGeometricRepresentationItem, ObjectHelper<IfcPlacement,1> { IfcPlacement() : Object("IfcPlacement") {}
-        Lazy< IfcCartesianPoint > Location;
-    };
-
-    // C++ wrapper for IfcAxis1Placement
-    struct IfcAxis1Placement : IfcPlacement, ObjectHelper<IfcAxis1Placement,1> { IfcAxis1Placement() : Object("IfcAxis1Placement") {}
-        Maybe< Lazy< IfcDirection > > Axis;
-    };
-
-    // C++ wrapper for IfcAxis2Placement2D
-    struct IfcAxis2Placement2D : IfcPlacement, ObjectHelper<IfcAxis2Placement2D,1> { IfcAxis2Placement2D() : Object("IfcAxis2Placement2D") {}
-        Maybe< Lazy< IfcDirection > > RefDirection;
-    };
-
-    // C++ wrapper for IfcAxis2Placement3D
-    struct IfcAxis2Placement3D : IfcPlacement, ObjectHelper<IfcAxis2Placement3D,2> { IfcAxis2Placement3D() : Object("IfcAxis2Placement3D") {}
-        Maybe< Lazy< IfcDirection > > Axis;
-        Maybe< Lazy< IfcDirection > > RefDirection;
-    };
-
-    // C++ wrapper for IfcBSplineCurve
-    struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {}
-        INTEGER::Out Degree;
-        ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList;
-        IfcBSplineCurveForm::Out CurveForm;
-        LOGICAL::Out ClosedCurve;
-        LOGICAL::Out SelfIntersect;
-    };
-
-    // C++ wrapper for IfcElement
-    struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {}
-        Maybe< IfcIdentifier::Out > Tag;
-    };
-
-    // C++ wrapper for IfcBuildingElement
-    struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {}
-
-    };
-
-    // C++ wrapper for IfcBeam
-    struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,0> { IfcBeam() : Object("IfcBeam") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingElementType
-    struct IfcBuildingElementType : IfcElementType, ObjectHelper<IfcBuildingElementType,0> { IfcBuildingElementType() : Object("IfcBuildingElementType") {}
-
-    };
-
-    // C++ wrapper for IfcBeamType
-    struct IfcBeamType : IfcBuildingElementType, ObjectHelper<IfcBeamType,1> { IfcBeamType() : Object("IfcBeamType") {}
-        IfcBeamTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcBezierCurve
-    struct IfcBezierCurve : IfcBSplineCurve, ObjectHelper<IfcBezierCurve,0> { IfcBezierCurve() : Object("IfcBezierCurve") {}
-
-    };
-
-    // C++ wrapper for IfcCsgPrimitive3D
-    struct IfcCsgPrimitive3D : IfcGeometricRepresentationItem, ObjectHelper<IfcCsgPrimitive3D,1> { IfcCsgPrimitive3D() : Object("IfcCsgPrimitive3D") {}
-        Lazy< IfcAxis2Placement3D > Position;
-    };
-
-    // C++ wrapper for IfcBlock
-    struct IfcBlock : IfcCsgPrimitive3D, ObjectHelper<IfcBlock,3> { IfcBlock() : Object("IfcBlock") {}
-        IfcPositiveLengthMeasure::Out XLength;
-        IfcPositiveLengthMeasure::Out YLength;
-        IfcPositiveLengthMeasure::Out ZLength;
-    };
-
-    // C++ wrapper for IfcBoilerType
-    struct IfcBoilerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBoilerType,1> { IfcBoilerType() : Object("IfcBoilerType") {}
-        IfcBoilerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcBooleanResult
-    struct IfcBooleanResult : IfcGeometricRepresentationItem, ObjectHelper<IfcBooleanResult,3> { IfcBooleanResult() : Object("IfcBooleanResult") {}
-        IfcBooleanOperator::Out Operator;
-        IfcBooleanOperand::Out FirstOperand;
-        IfcBooleanOperand::Out SecondOperand;
-    };
-
-    // C++ wrapper for IfcBooleanClippingResult
-    struct IfcBooleanClippingResult : IfcBooleanResult, ObjectHelper<IfcBooleanClippingResult,0> { IfcBooleanClippingResult() : Object("IfcBooleanClippingResult") {}
-
-    };
-
-    // C++ wrapper for IfcSurface
-    struct IfcSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcSurface,0> { IfcSurface() : Object("IfcSurface") {}
-
-    };
-
-    // C++ wrapper for IfcBoundedSurface
-    struct IfcBoundedSurface : IfcSurface, ObjectHelper<IfcBoundedSurface,0> { IfcBoundedSurface() : Object("IfcBoundedSurface") {}
-
-    };
-
-    // C++ wrapper for IfcBoundingBox
-    struct IfcBoundingBox : IfcGeometricRepresentationItem, ObjectHelper<IfcBoundingBox,4> { IfcBoundingBox() : Object("IfcBoundingBox") {}
-        Lazy< IfcCartesianPoint > Corner;
-        IfcPositiveLengthMeasure::Out XDim;
-        IfcPositiveLengthMeasure::Out YDim;
-        IfcPositiveLengthMeasure::Out ZDim;
-    };
-
-    // C++ wrapper for IfcHalfSpaceSolid
-    struct IfcHalfSpaceSolid : IfcGeometricRepresentationItem, ObjectHelper<IfcHalfSpaceSolid,2> { IfcHalfSpaceSolid() : Object("IfcHalfSpaceSolid") {}
-        Lazy< IfcSurface > BaseSurface;
-        BOOLEAN::Out AgreementFlag;
-    };
-
-    // C++ wrapper for IfcBoxedHalfSpace
-    struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {}
-        Lazy< IfcBoundingBox > Enclosure;
-    };
-
-    // C++ wrapper for IfcSpatialStructureElement
-    struct IfcSpatialStructureElement : IfcProduct, ObjectHelper<IfcSpatialStructureElement,2> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {}
-        Maybe< IfcLabel::Out > LongName;
-        IfcElementCompositionEnum::Out CompositionType;
-    };
-
-    // C++ wrapper for IfcBuilding
-    struct IfcBuilding : IfcSpatialStructureElement, ObjectHelper<IfcBuilding,3> { IfcBuilding() : Object("IfcBuilding") {}
-        Maybe< IfcLengthMeasure::Out > ElevationOfRefHeight;
-        Maybe< IfcLengthMeasure::Out > ElevationOfTerrain;
-        Maybe< Lazy< NotImplemented > > BuildingAddress;
-    };
-
-    // C++ wrapper for IfcBuildingElementComponent
-    struct IfcBuildingElementComponent : IfcBuildingElement, ObjectHelper<IfcBuildingElementComponent,0> { IfcBuildingElementComponent() : Object("IfcBuildingElementComponent") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingElementPart
-    struct IfcBuildingElementPart : IfcBuildingElementComponent, ObjectHelper<IfcBuildingElementPart,0> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingElementProxy
-    struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {}
-        Maybe< IfcElementCompositionEnum::Out > CompositionType;
-    };
-
-    // C++ wrapper for IfcBuildingElementProxyType
-    struct IfcBuildingElementProxyType : IfcBuildingElementType, ObjectHelper<IfcBuildingElementProxyType,1> { IfcBuildingElementProxyType() : Object("IfcBuildingElementProxyType") {}
-        IfcBuildingElementProxyTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcBuildingStorey
-    struct IfcBuildingStorey : IfcSpatialStructureElement, ObjectHelper<IfcBuildingStorey,1> { IfcBuildingStorey() : Object("IfcBuildingStorey") {}
-        Maybe< IfcLengthMeasure::Out > Elevation;
-    };
-
-    // C++ wrapper for IfcCShapeProfileDef
-    struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,6> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out Depth;
-        IfcPositiveLengthMeasure::Out Width;
-        IfcPositiveLengthMeasure::Out WallThickness;
-        IfcPositiveLengthMeasure::Out Girth;
-        Maybe< IfcPositiveLengthMeasure::Out > InternalFilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
-    };
-
-    // C++ wrapper for IfcFlowFittingType
-    struct IfcFlowFittingType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowFittingType,0> { IfcFlowFittingType() : Object("IfcFlowFittingType") {}
-
-    };
-
-    // C++ wrapper for IfcCableCarrierFittingType
-    struct IfcCableCarrierFittingType : IfcFlowFittingType, ObjectHelper<IfcCableCarrierFittingType,1> { IfcCableCarrierFittingType() : Object("IfcCableCarrierFittingType") {}
-        IfcCableCarrierFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowSegmentType
-    struct IfcFlowSegmentType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowSegmentType,0> { IfcFlowSegmentType() : Object("IfcFlowSegmentType") {}
-
-    };
-
-    // C++ wrapper for IfcCableCarrierSegmentType
-    struct IfcCableCarrierSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableCarrierSegmentType,1> { IfcCableCarrierSegmentType() : Object("IfcCableCarrierSegmentType") {}
-        IfcCableCarrierSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCableSegmentType
-    struct IfcCableSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableSegmentType,1> { IfcCableSegmentType() : Object("IfcCableSegmentType") {}
-        IfcCableSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPoint
-    struct IfcPoint : IfcGeometricRepresentationItem, ObjectHelper<IfcPoint,0> { IfcPoint() : Object("IfcPoint") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianPoint
-    struct IfcCartesianPoint : IfcPoint, ObjectHelper<IfcCartesianPoint,1> { IfcCartesianPoint() : Object("IfcCartesianPoint") {}
-        ListOf< IfcLengthMeasure, 1, 3 >::Out Coordinates;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator
-    struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {}
-        Maybe< Lazy< IfcDirection > > Axis1;
-        Maybe< Lazy< IfcDirection > > Axis2;
-        Lazy< IfcCartesianPoint > LocalOrigin;
-        Maybe< REAL::Out > Scale;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator2D
-    struct IfcCartesianTransformationOperator2D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator2D,0> { IfcCartesianTransformationOperator2D() : Object("IfcCartesianTransformationOperator2D") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator2DnonUniform
-    struct IfcCartesianTransformationOperator2DnonUniform : IfcCartesianTransformationOperator2D, ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1> { IfcCartesianTransformationOperator2DnonUniform() : Object("IfcCartesianTransformationOperator2DnonUniform") {}
-        Maybe< REAL::Out > Scale2;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator3D
-    struct IfcCartesianTransformationOperator3D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator3D,1> { IfcCartesianTransformationOperator3D() : Object("IfcCartesianTransformationOperator3D") {}
-        Maybe< Lazy< IfcDirection > > Axis3;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator3DnonUniform
-    struct IfcCartesianTransformationOperator3DnonUniform : IfcCartesianTransformationOperator3D, ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2> { IfcCartesianTransformationOperator3DnonUniform() : Object("IfcCartesianTransformationOperator3DnonUniform") {}
-        Maybe< REAL::Out > Scale2;
-        Maybe< REAL::Out > Scale3;
-    };
-
-    // C++ wrapper for IfcCenterLineProfileDef
-    struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {}
-        IfcPositiveLengthMeasure::Out Thickness;
-    };
-
-    // C++ wrapper for IfcFeatureElement
-    struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {}
-
-    };
-
-    // C++ wrapper for IfcFeatureElementSubtraction
-    struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {}
-
-    };
-
-    // C++ wrapper for IfcEdgeFeature
-    struct IfcEdgeFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcEdgeFeature,1> { IfcEdgeFeature() : Object("IfcEdgeFeature") {}
-        Maybe< IfcPositiveLengthMeasure::Out > FeatureLength;
-    };
-
-    // C++ wrapper for IfcChamferEdgeFeature
-    struct IfcChamferEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcChamferEdgeFeature,2> { IfcChamferEdgeFeature() : Object("IfcChamferEdgeFeature") {}
-        Maybe< IfcPositiveLengthMeasure::Out > Width;
-        Maybe< IfcPositiveLengthMeasure::Out > Height;
-    };
-
-    // C++ wrapper for IfcChillerType
-    struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {}
-        IfcChillerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcConic
-    struct IfcConic : IfcCurve, ObjectHelper<IfcConic,1> { IfcConic() : Object("IfcConic") {}
-        IfcAxis2Placement::Out Position;
-    };
-
-    // C++ wrapper for IfcCircle
-    struct IfcCircle : IfcConic, ObjectHelper<IfcCircle,1> { IfcCircle() : Object("IfcCircle") {}
-        IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcCircleProfileDef
-    struct IfcCircleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCircleProfileDef,1> { IfcCircleProfileDef() : Object("IfcCircleProfileDef") {}
-        IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcCircleHollowProfileDef
-    struct IfcCircleHollowProfileDef : IfcCircleProfileDef, ObjectHelper<IfcCircleHollowProfileDef,1> { IfcCircleHollowProfileDef() : Object("IfcCircleHollowProfileDef") {}
-        IfcPositiveLengthMeasure::Out WallThickness;
-    };
-
-    // C++ wrapper for IfcTopologicalRepresentationItem
-    struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcConnectedFaceSet
-    struct IfcConnectedFaceSet : IfcTopologicalRepresentationItem, ObjectHelper<IfcConnectedFaceSet,1> { IfcConnectedFaceSet() : Object("IfcConnectedFaceSet") {}
-        ListOf< Lazy< IfcFace >, 1, 0 > CfsFaces;
-    };
-
-    // C++ wrapper for IfcClosedShell
-    struct IfcClosedShell : IfcConnectedFaceSet, ObjectHelper<IfcClosedShell,0> { IfcClosedShell() : Object("IfcClosedShell") {}
-
-    };
-
-    // C++ wrapper for IfcCoilType
-    struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {}
-        IfcCoilTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcColourSpecification
-    struct IfcColourSpecification :  ObjectHelper<IfcColourSpecification,1> { IfcColourSpecification() : Object("IfcColourSpecification") {}
-        Maybe< IfcLabel::Out > Name;
-    };
-
-    // C++ wrapper for IfcColourRgb
-    struct IfcColourRgb : IfcColourSpecification, ObjectHelper<IfcColourRgb,3> { IfcColourRgb() : Object("IfcColourRgb") {}
-        IfcNormalisedRatioMeasure::Out Red;
-        IfcNormalisedRatioMeasure::Out Green;
-        IfcNormalisedRatioMeasure::Out Blue;
-    };
-
-    // C++ wrapper for IfcColumn
-    struct IfcColumn : IfcBuildingElement, ObjectHelper<IfcColumn,0> { IfcColumn() : Object("IfcColumn") {}
-
-    };
-
-    // C++ wrapper for IfcColumnType
-    struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {}
-        IfcColumnTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProperty
-    struct IfcProperty :  ObjectHelper<IfcProperty,2> { IfcProperty() : Object("IfcProperty") {}
-        IfcIdentifier::Out Name;
-        Maybe< IfcText::Out > Description;
-    };
-
-    // C++ wrapper for IfcComplexProperty
-    struct IfcComplexProperty : IfcProperty, ObjectHelper<IfcComplexProperty,2> { IfcComplexProperty() : Object("IfcComplexProperty") {}
-        IfcIdentifier::Out UsageName;
-        ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
-    };
-
-    // C++ wrapper for IfcCompositeCurveSegment
-    struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {}
-        IfcTransitionCode::Out Transition;
-        BOOLEAN::Out SameSense;
-        Lazy< IfcCurve > ParentCurve;
-    };
-
-    // C++ wrapper for IfcCompositeProfileDef
-    struct IfcCompositeProfileDef : IfcProfileDef, ObjectHelper<IfcCompositeProfileDef,2> { IfcCompositeProfileDef() : Object("IfcCompositeProfileDef") {}
-        ListOf< Lazy< IfcProfileDef >, 2, 0 > Profiles;
-        Maybe< IfcLabel::Out > Label;
-    };
-
-    // C++ wrapper for IfcFlowMovingDeviceType
-    struct IfcFlowMovingDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowMovingDeviceType,0> { IfcFlowMovingDeviceType() : Object("IfcFlowMovingDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcCompressorType
-    struct IfcCompressorType : IfcFlowMovingDeviceType, ObjectHelper<IfcCompressorType,1> { IfcCompressorType() : Object("IfcCompressorType") {}
-        IfcCompressorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCondenserType
-    struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {}
-        IfcCondenserTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCondition
-    struct IfcCondition : IfcGroup, ObjectHelper<IfcCondition,0> { IfcCondition() : Object("IfcCondition") {}
-
-    };
-
-    // C++ wrapper for IfcConditionCriterion
-    struct IfcConditionCriterion : IfcControl, ObjectHelper<IfcConditionCriterion,2> { IfcConditionCriterion() : Object("IfcConditionCriterion") {}
-        IfcConditionCriterionSelect::Out Criterion;
-        IfcDateTimeSelect::Out CriterionDateTime;
-    };
-
-    // C++ wrapper for IfcResource
-    struct IfcResource : IfcObject, ObjectHelper<IfcResource,0> { IfcResource() : Object("IfcResource") {}
-
-    };
-
-    // C++ wrapper for IfcConstructionResource
-    struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,4> { IfcConstructionResource() : Object("IfcConstructionResource") {}
-        Maybe< IfcIdentifier::Out > ResourceIdentifier;
-        Maybe< IfcLabel::Out > ResourceGroup;
-        Maybe< IfcResourceConsumptionEnum::Out > ResourceConsumption;
-        Maybe< Lazy< IfcMeasureWithUnit > > BaseQuantity;
-    };
-
-    // C++ wrapper for IfcConstructionEquipmentResource
-    struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,0> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {}
-
-    };
-
-    // C++ wrapper for IfcConstructionMaterialResource
-    struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,2> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {}
-        Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > Suppliers;
-        Maybe< IfcRatioMeasure::Out > UsageRatio;
-    };
-
-    // C++ wrapper for IfcConstructionProductResource
-    struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,0> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {}
-
-    };
-
-    // C++ wrapper for IfcNamedUnit
-    struct IfcNamedUnit :  ObjectHelper<IfcNamedUnit,2> { IfcNamedUnit() : Object("IfcNamedUnit") {}
-        Lazy< NotImplemented > Dimensions;
-        IfcUnitEnum::Out UnitType;
-    };
-
-    // C++ wrapper for IfcContextDependentUnit
-    struct IfcContextDependentUnit : IfcNamedUnit, ObjectHelper<IfcContextDependentUnit,1> { IfcContextDependentUnit() : Object("IfcContextDependentUnit") {}
-        IfcLabel::Out Name;
-    };
-
-    // C++ wrapper for IfcControllerType
-    struct IfcControllerType : IfcDistributionControlElementType, ObjectHelper<IfcControllerType,1> { IfcControllerType() : Object("IfcControllerType") {}
-        IfcControllerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcConversionBasedUnit
-    struct IfcConversionBasedUnit : IfcNamedUnit, ObjectHelper<IfcConversionBasedUnit,2> { IfcConversionBasedUnit() : Object("IfcConversionBasedUnit") {}
-        IfcLabel::Out Name;
-        Lazy< IfcMeasureWithUnit > ConversionFactor;
-    };
-
-    // C++ wrapper for IfcCooledBeamType
-    struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {}
-        IfcCooledBeamTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCoolingTowerType
-    struct IfcCoolingTowerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoolingTowerType,1> { IfcCoolingTowerType() : Object("IfcCoolingTowerType") {}
-        IfcCoolingTowerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCostItem
-    struct IfcCostItem : IfcControl, ObjectHelper<IfcCostItem,0> { IfcCostItem() : Object("IfcCostItem") {}
-
-    };
-
-    // C++ wrapper for IfcCostSchedule
-    struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,8> { IfcCostSchedule() : Object("IfcCostSchedule") {}
-        Maybe< IfcActorSelect::Out > SubmittedBy;
-        Maybe< IfcActorSelect::Out > PreparedBy;
-        Maybe< IfcDateTimeSelect::Out > SubmittedOn;
-        Maybe< IfcLabel::Out > Status;
-        Maybe< ListOf< IfcActorSelect, 1, 0 >::Out > TargetUsers;
-        Maybe< IfcDateTimeSelect::Out > UpdateDate;
-        IfcIdentifier::Out ID;
-        IfcCostScheduleTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCovering
-    struct IfcCovering : IfcBuildingElement, ObjectHelper<IfcCovering,1> { IfcCovering() : Object("IfcCovering") {}
-        Maybe< IfcCoveringTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCoveringType
-    struct IfcCoveringType : IfcBuildingElementType, ObjectHelper<IfcCoveringType,1> { IfcCoveringType() : Object("IfcCoveringType") {}
-        IfcCoveringTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCraneRailAShapeProfileDef
-    struct IfcCraneRailAShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailAShapeProfileDef,12> { IfcCraneRailAShapeProfileDef() : Object("IfcCraneRailAShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out OverallHeight;
-        IfcPositiveLengthMeasure::Out BaseWidth2;
-        Maybe< IfcPositiveLengthMeasure::Out > Radius;
-        IfcPositiveLengthMeasure::Out HeadWidth;
-        IfcPositiveLengthMeasure::Out HeadDepth2;
-        IfcPositiveLengthMeasure::Out HeadDepth3;
-        IfcPositiveLengthMeasure::Out WebThickness;
-        IfcPositiveLengthMeasure::Out BaseWidth4;
-        IfcPositiveLengthMeasure::Out BaseDepth1;
-        IfcPositiveLengthMeasure::Out BaseDepth2;
-        IfcPositiveLengthMeasure::Out BaseDepth3;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
-    };
-
-    // C++ wrapper for IfcCraneRailFShapeProfileDef
-    struct IfcCraneRailFShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCraneRailFShapeProfileDef,9> { IfcCraneRailFShapeProfileDef() : Object("IfcCraneRailFShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out OverallHeight;
-        IfcPositiveLengthMeasure::Out HeadWidth;
-        Maybe< IfcPositiveLengthMeasure::Out > Radius;
-        IfcPositiveLengthMeasure::Out HeadDepth2;
-        IfcPositiveLengthMeasure::Out HeadDepth3;
-        IfcPositiveLengthMeasure::Out WebThickness;
-        IfcPositiveLengthMeasure::Out BaseDepth1;
-        IfcPositiveLengthMeasure::Out BaseDepth2;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
-    };
-
-    // C++ wrapper for IfcCrewResource
-    struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,0> { IfcCrewResource() : Object("IfcCrewResource") {}
-
-    };
-
-    // C++ wrapper for IfcSolidModel
-    struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {}
-
-    };
-
-    // C++ wrapper for IfcCsgSolid
-    struct IfcCsgSolid : IfcSolidModel, ObjectHelper<IfcCsgSolid,1> { IfcCsgSolid() : Object("IfcCsgSolid") {}
-        IfcCsgSelect::Out TreeRootExpression;
-    };
-
-    // C++ wrapper for IfcCurtainWall
-    struct IfcCurtainWall : IfcBuildingElement, ObjectHelper<IfcCurtainWall,0> { IfcCurtainWall() : Object("IfcCurtainWall") {}
-
-    };
-
-    // C++ wrapper for IfcCurtainWallType
-    struct IfcCurtainWallType : IfcBuildingElementType, ObjectHelper<IfcCurtainWallType,1> { IfcCurtainWallType() : Object("IfcCurtainWallType") {}
-        IfcCurtainWallTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCurveBoundedPlane
-    struct IfcCurveBoundedPlane : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedPlane,3> { IfcCurveBoundedPlane() : Object("IfcCurveBoundedPlane") {}
-        Lazy< IfcPlane > BasisSurface;
-        Lazy< IfcCurve > OuterBoundary;
-        ListOf< Lazy< IfcCurve >, 0, 0 > InnerBoundaries;
-    };
-
-    // C++ wrapper for IfcPresentationStyle
-    struct IfcPresentationStyle :  ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {}
-        Maybe< IfcLabel::Out > Name;
-    };
-
-    // C++ wrapper for IfcDamperType
-    struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {}
-        IfcDamperTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDefinedSymbol
-    struct IfcDefinedSymbol : IfcGeometricRepresentationItem, ObjectHelper<IfcDefinedSymbol,2> { IfcDefinedSymbol() : Object("IfcDefinedSymbol") {}
-        IfcDefinedSymbolSelect::Out Definition;
-        Lazy< IfcCartesianTransformationOperator2D > Target;
-    };
-
-    // C++ wrapper for IfcDerivedProfileDef
-    struct IfcDerivedProfileDef : IfcProfileDef, ObjectHelper<IfcDerivedProfileDef,3> { IfcDerivedProfileDef() : Object("IfcDerivedProfileDef") {}
-        Lazy< IfcProfileDef > ParentProfile;
-        Lazy< IfcCartesianTransformationOperator2D > Operator;
-        Maybe< IfcLabel::Out > Label;
-    };
-
-    // C++ wrapper for IfcDiameterDimension
-    struct IfcDiameterDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcDiameterDimension,0> { IfcDiameterDimension() : Object("IfcDiameterDimension") {}
-
-    };
-
-    // C++ wrapper for IfcDimensionCurve
-    struct IfcDimensionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcDimensionCurve,0> { IfcDimensionCurve() : Object("IfcDimensionCurve") {}
-
-    };
-
-    // C++ wrapper for IfcTerminatorSymbol
-    struct IfcTerminatorSymbol : IfcAnnotationSymbolOccurrence, ObjectHelper<IfcTerminatorSymbol,1> { IfcTerminatorSymbol() : Object("IfcTerminatorSymbol") {}
-        Lazy< IfcAnnotationCurveOccurrence > AnnotatedCurve;
-    };
-
-    // C++ wrapper for IfcDimensionCurveTerminator
-    struct IfcDimensionCurveTerminator : IfcTerminatorSymbol, ObjectHelper<IfcDimensionCurveTerminator,1> { IfcDimensionCurveTerminator() : Object("IfcDimensionCurveTerminator") {}
-        IfcDimensionExtentUsage::Out Role;
-    };
-
-    // C++ wrapper for IfcDirection
-    struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {}
-        ListOf< REAL, 2, 3 >::Out DirectionRatios;
-    };
-
-    // C++ wrapper for IfcElementComponent
-    struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {}
-
-    };
-
-    // C++ wrapper for IfcDiscreteAccessory
-    struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,0> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {}
-
-    };
-
-    // C++ wrapper for IfcElementComponentType
-    struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {}
-
-    };
-
-    // C++ wrapper for IfcDiscreteAccessoryType
-    struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,0> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionElement
-    struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionFlowElement
-    struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionChamberElement
-    struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,0> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionChamberElementType
-    struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {}
-        IfcDistributionChamberElementTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionControlElement
-    struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,1> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {}
-        Maybe< IfcIdentifier::Out > ControlElementId;
-    };
-
-    // C++ wrapper for IfcPort
-    struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionPort
-    struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,1> { IfcDistributionPort() : Object("IfcDistributionPort") {}
-        Maybe< IfcFlowDirectionEnum::Out > FlowDirection;
-    };
-
-    // C++ wrapper for IfcDoor
-    struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,2> { IfcDoor() : Object("IfcDoor") {}
-        Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
-        Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
-    };
-
-    // C++ wrapper for IfcPropertyDefinition
-    struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {}
-
-    };
-
-    // C++ wrapper for IfcPropertySetDefinition
-    struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {}
-
-    };
-
-    // C++ wrapper for IfcDoorStyle
-    struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {}
-        IfcDoorStyleOperationEnum::Out OperationType;
-        IfcDoorStyleConstructionEnum::Out ConstructionType;
-        BOOLEAN::Out ParameterTakesPrecedence;
-        BOOLEAN::Out Sizeable;
-    };
-
-    // C++ wrapper for IfcDuctFittingType
-    struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {}
-        IfcDuctFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDuctSegmentType
-    struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {}
-        IfcDuctSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowTreatmentDeviceType
-    struct IfcFlowTreatmentDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTreatmentDeviceType,0> { IfcFlowTreatmentDeviceType() : Object("IfcFlowTreatmentDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcDuctSilencerType
-    struct IfcDuctSilencerType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcDuctSilencerType,1> { IfcDuctSilencerType() : Object("IfcDuctSilencerType") {}
-        IfcDuctSilencerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEdge
-    struct IfcEdge : IfcTopologicalRepresentationItem, ObjectHelper<IfcEdge,2> { IfcEdge() : Object("IfcEdge") {}
-        Lazy< IfcVertex > EdgeStart;
-        Lazy< IfcVertex > EdgeEnd;
-    };
-
-    // C++ wrapper for IfcEdgeCurve
-    struct IfcEdgeCurve : IfcEdge, ObjectHelper<IfcEdgeCurve,2> { IfcEdgeCurve() : Object("IfcEdgeCurve") {}
-        Lazy< IfcCurve > EdgeGeometry;
-        BOOLEAN::Out SameSense;
-    };
-
-    // C++ wrapper for IfcLoop
-    struct IfcLoop : IfcTopologicalRepresentationItem, ObjectHelper<IfcLoop,0> { IfcLoop() : Object("IfcLoop") {}
-
-    };
-
-    // C++ wrapper for IfcEdgeLoop
-    struct IfcEdgeLoop : IfcLoop, ObjectHelper<IfcEdgeLoop,1> { IfcEdgeLoop() : Object("IfcEdgeLoop") {}
-        ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
-    };
-
-    // C++ wrapper for IfcElectricApplianceType
-    struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {}
-        IfcElectricApplianceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowController
-    struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {}
-
-    };
-
-    // C++ wrapper for IfcElectricDistributionPoint
-    struct IfcElectricDistributionPoint : IfcFlowController, ObjectHelper<IfcElectricDistributionPoint,2> { IfcElectricDistributionPoint() : Object("IfcElectricDistributionPoint") {}
-        IfcElectricDistributionPointFunctionEnum::Out DistributionPointFunction;
-        Maybe< IfcLabel::Out > UserDefinedFunction;
-    };
-
-    // C++ wrapper for IfcFlowStorageDeviceType
-    struct IfcFlowStorageDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowStorageDeviceType,0> { IfcFlowStorageDeviceType() : Object("IfcFlowStorageDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcElectricFlowStorageDeviceType
-    struct IfcElectricFlowStorageDeviceType : IfcFlowStorageDeviceType, ObjectHelper<IfcElectricFlowStorageDeviceType,1> { IfcElectricFlowStorageDeviceType() : Object("IfcElectricFlowStorageDeviceType") {}
-        IfcElectricFlowStorageDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricGeneratorType
-    struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {}
-        IfcElectricGeneratorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricHeaterType
-    struct IfcElectricHeaterType : IfcFlowTerminalType, ObjectHelper<IfcElectricHeaterType,1> { IfcElectricHeaterType() : Object("IfcElectricHeaterType") {}
-        IfcElectricHeaterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricMotorType
-    struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {}
-        IfcElectricMotorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricTimeControlType
-    struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {}
-        IfcElectricTimeControlTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSystem
-    struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {}
-
-    };
-
-    // C++ wrapper for IfcElectricalCircuit
-    struct IfcElectricalCircuit : IfcSystem, ObjectHelper<IfcElectricalCircuit,0> { IfcElectricalCircuit() : Object("IfcElectricalCircuit") {}
-
-    };
-
-    // C++ wrapper for IfcElectricalElement
-    struct IfcElectricalElement : IfcElement, ObjectHelper<IfcElectricalElement,0> { IfcElectricalElement() : Object("IfcElectricalElement") {}
-
-    };
-
-    // C++ wrapper for IfcElementAssembly
-    struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {}
-        Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace;
-        IfcElementAssemblyTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElementQuantity
-    struct IfcElementQuantity : IfcPropertySetDefinition, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {}
-        Maybe< IfcLabel::Out > MethodOfMeasurement;
-        ListOf< Lazy< NotImplemented >, 1, 0 > Quantities;
-    };
-
-    // C++ wrapper for IfcElementarySurface
-    struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {}
-        Lazy< IfcAxis2Placement3D > Position;
-    };
-
-    // C++ wrapper for IfcEllipse
-    struct IfcEllipse : IfcConic, ObjectHelper<IfcEllipse,2> { IfcEllipse() : Object("IfcEllipse") {}
-        IfcPositiveLengthMeasure::Out SemiAxis1;
-        IfcPositiveLengthMeasure::Out SemiAxis2;
-    };
-
-    // C++ wrapper for IfcEllipseProfileDef
-    struct IfcEllipseProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcEllipseProfileDef,2> { IfcEllipseProfileDef() : Object("IfcEllipseProfileDef") {}
-        IfcPositiveLengthMeasure::Out SemiAxis1;
-        IfcPositiveLengthMeasure::Out SemiAxis2;
-    };
-
-    // C++ wrapper for IfcEnergyConversionDevice
-    struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {}
-
-    };
-
-    // C++ wrapper for IfcEquipmentElement
-    struct IfcEquipmentElement : IfcElement, ObjectHelper<IfcEquipmentElement,0> { IfcEquipmentElement() : Object("IfcEquipmentElement") {}
-
-    };
-
-    // C++ wrapper for IfcEquipmentStandard
-    struct IfcEquipmentStandard : IfcControl, ObjectHelper<IfcEquipmentStandard,0> { IfcEquipmentStandard() : Object("IfcEquipmentStandard") {}
-
-    };
-
-    // C++ wrapper for IfcEvaporativeCoolerType
-    struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {}
-        IfcEvaporativeCoolerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEvaporatorType
-    struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {}
-        IfcEvaporatorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSweptAreaSolid
-    struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {}
-        Lazy< IfcProfileDef > SweptArea;
-        Lazy< IfcAxis2Placement3D > Position;
-    };
-
-    // C++ wrapper for IfcExtrudedAreaSolid
-    struct IfcExtrudedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcExtrudedAreaSolid,2> { IfcExtrudedAreaSolid() : Object("IfcExtrudedAreaSolid") {}
-        Lazy< IfcDirection > ExtrudedDirection;
-        IfcPositiveLengthMeasure::Out Depth;
-    };
-
-    // C++ wrapper for IfcFace
-    struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {}
-        ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds;
-    };
-
-    // C++ wrapper for IfcFaceBasedSurfaceModel
-    struct IfcFaceBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcFaceBasedSurfaceModel,1> { IfcFaceBasedSurfaceModel() : Object("IfcFaceBasedSurfaceModel") {}
-        ListOf< Lazy< IfcConnectedFaceSet >, 1, 0 > FbsmFaces;
-    };
-
-    // C++ wrapper for IfcFaceBound
-    struct IfcFaceBound : IfcTopologicalRepresentationItem, ObjectHelper<IfcFaceBound,2> { IfcFaceBound() : Object("IfcFaceBound") {}
-        Lazy< IfcLoop > Bound;
-        BOOLEAN::Out Orientation;
-    };
-
-    // C++ wrapper for IfcFaceOuterBound
-    struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {}
-
-    };
-
-    // C++ wrapper for IfcFaceSurface
-    struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {}
-        Lazy< IfcSurface > FaceSurface;
-        BOOLEAN::Out SameSense;
-    };
-
-    // C++ wrapper for IfcManifoldSolidBrep
-    struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {}
-        Lazy< IfcClosedShell > Outer;
-    };
-
-    // C++ wrapper for IfcFacetedBrep
-    struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {}
-
-    };
-
-    // C++ wrapper for IfcFacetedBrepWithVoids
-    struct IfcFacetedBrepWithVoids : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {}
-        ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
-    };
-
-    // C++ wrapper for IfcFanType
-    struct IfcFanType : IfcFlowMovingDeviceType, ObjectHelper<IfcFanType,1> { IfcFanType() : Object("IfcFanType") {}
-        IfcFanTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFastener
-    struct IfcFastener : IfcElementComponent, ObjectHelper<IfcFastener,0> { IfcFastener() : Object("IfcFastener") {}
-
-    };
-
-    // C++ wrapper for IfcFastenerType
-    struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,0> { IfcFastenerType() : Object("IfcFastenerType") {}
-
-    };
-
-    // C++ wrapper for IfcFeatureElementAddition
-    struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {}
-
-    };
-
-    // C++ wrapper for IfcFillAreaStyleHatching
-    struct IfcFillAreaStyleHatching : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleHatching,5> { IfcFillAreaStyleHatching() : Object("IfcFillAreaStyleHatching") {}
-        Lazy< NotImplemented > HatchLineAppearance;
-        IfcHatchLineDistanceSelect::Out StartOfNextHatchLine;
-        Maybe< Lazy< IfcCartesianPoint > > PointOfReferenceHatchLine;
-        Maybe< Lazy< IfcCartesianPoint > > PatternStart;
-        IfcPlaneAngleMeasure::Out HatchLineAngle;
-    };
-
-    // C++ wrapper for IfcFillAreaStyleTileSymbolWithStyle
-    struct IfcFillAreaStyleTileSymbolWithStyle : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTileSymbolWithStyle,1> { IfcFillAreaStyleTileSymbolWithStyle() : Object("IfcFillAreaStyleTileSymbolWithStyle") {}
-        Lazy< IfcAnnotationSymbolOccurrence > Symbol;
-    };
-
-    // C++ wrapper for IfcFillAreaStyleTiles
-    struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {}
-        Lazy< IfcOneDirectionRepeatFactor > TilingPattern;
-        ListOf< IfcFillAreaStyleTileShapeSelect, 1, 0 >::Out Tiles;
-        IfcPositiveRatioMeasure::Out TilingScale;
-    };
-
-    // C++ wrapper for IfcFilterType
-    struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {}
-        IfcFilterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFireSuppressionTerminalType
-    struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {}
-        IfcFireSuppressionTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowFitting
-    struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {}
-
-    };
-
-    // C++ wrapper for IfcFlowInstrumentType
-    struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {}
-        IfcFlowInstrumentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowMeterType
-    struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {}
-        IfcFlowMeterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowMovingDevice
-    struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {}
-
-    };
-
-    // C++ wrapper for IfcFlowSegment
-    struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {}
-
-    };
-
-    // C++ wrapper for IfcFlowStorageDevice
-    struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {}
-
-    };
-
-    // C++ wrapper for IfcFlowTerminal
-    struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {}
-
-    };
-
-    // C++ wrapper for IfcFlowTreatmentDevice
-    struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {}
-
-    };
-
-    // C++ wrapper for IfcFooting
-    struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {}
-        IfcFootingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFurnishingElement
-    struct IfcFurnishingElement : IfcElement, ObjectHelper<IfcFurnishingElement,0> { IfcFurnishingElement() : Object("IfcFurnishingElement") {}
-
-    };
-
-    // C++ wrapper for IfcFurnishingElementType
-    struct IfcFurnishingElementType : IfcElementType, ObjectHelper<IfcFurnishingElementType,0> { IfcFurnishingElementType() : Object("IfcFurnishingElementType") {}
-
-    };
-
-    // C++ wrapper for IfcFurnitureStandard
-    struct IfcFurnitureStandard : IfcControl, ObjectHelper<IfcFurnitureStandard,0> { IfcFurnitureStandard() : Object("IfcFurnitureStandard") {}
-
-    };
-
-    // C++ wrapper for IfcFurnitureType
-    struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,1> { IfcFurnitureType() : Object("IfcFurnitureType") {}
-        IfcAssemblyPlaceEnum::Out AssemblyPlace;
-    };
-
-    // C++ wrapper for IfcGasTerminalType
-    struct IfcGasTerminalType : IfcFlowTerminalType, ObjectHelper<IfcGasTerminalType,1> { IfcGasTerminalType() : Object("IfcGasTerminalType") {}
-        IfcGasTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcGeometricSet
-    struct IfcGeometricSet : IfcGeometricRepresentationItem, ObjectHelper<IfcGeometricSet,1> { IfcGeometricSet() : Object("IfcGeometricSet") {}
-        ListOf< IfcGeometricSetSelect, 1, 0 >::Out Elements;
-    };
-
-    // C++ wrapper for IfcGeometricCurveSet
-    struct IfcGeometricCurveSet : IfcGeometricSet, ObjectHelper<IfcGeometricCurveSet,0> { IfcGeometricCurveSet() : Object("IfcGeometricCurveSet") {}
-
-    };
-
-    // C++ wrapper for IfcRepresentationContext
-    struct IfcRepresentationContext :  ObjectHelper<IfcRepresentationContext,2> { IfcRepresentationContext() : Object("IfcRepresentationContext") {}
-        Maybe< IfcLabel::Out > ContextIdentifier;
-        Maybe< IfcLabel::Out > ContextType;
-    };
-
-    // C++ wrapper for IfcGeometricRepresentationContext
-    struct IfcGeometricRepresentationContext : IfcRepresentationContext, ObjectHelper<IfcGeometricRepresentationContext,4> { IfcGeometricRepresentationContext() : Object("IfcGeometricRepresentationContext") {}
-        IfcDimensionCount::Out CoordinateSpaceDimension;
-        Maybe< REAL::Out > Precision;
-        IfcAxis2Placement::Out WorldCoordinateSystem;
-        Maybe< Lazy< IfcDirection > > TrueNorth;
-    };
-
-    // C++ wrapper for IfcGeometricRepresentationSubContext
-    struct IfcGeometricRepresentationSubContext : IfcGeometricRepresentationContext, ObjectHelper<IfcGeometricRepresentationSubContext,4> { IfcGeometricRepresentationSubContext() : Object("IfcGeometricRepresentationSubContext") {}
-        Lazy< IfcGeometricRepresentationContext > ParentContext;
-        Maybe< IfcPositiveRatioMeasure::Out > TargetScale;
-        IfcGeometricProjectionEnum::Out TargetView;
-        Maybe< IfcLabel::Out > UserDefinedTargetView;
-    };
-
-    // C++ wrapper for IfcGrid
-    struct IfcGrid : IfcProduct, ObjectHelper<IfcGrid,3> { IfcGrid() : Object("IfcGrid") {}
-        ListOf< Lazy< NotImplemented >, 1, 0 > UAxes;
-        ListOf< Lazy< NotImplemented >, 1, 0 > VAxes;
-        Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes;
-    };
-
-    // C++ wrapper for IfcObjectPlacement
-    struct IfcObjectPlacement :  ObjectHelper<IfcObjectPlacement,0> { IfcObjectPlacement() : Object("IfcObjectPlacement") {}
-
-    };
-
-    // C++ wrapper for IfcGridPlacement
-    struct IfcGridPlacement : IfcObjectPlacement, ObjectHelper<IfcGridPlacement,2> { IfcGridPlacement() : Object("IfcGridPlacement") {}
-        Lazy< NotImplemented > PlacementLocation;
-        Maybe< Lazy< NotImplemented > > PlacementRefDirection;
-    };
-
-    // C++ wrapper for IfcHeatExchangerType
-    struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {}
-        IfcHeatExchangerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcHumidifierType
-    struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {}
-        IfcHumidifierTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcInventory
-    struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {}
-        IfcInventoryTypeEnum::Out InventoryType;
-        IfcActorSelect::Out Jurisdiction;
-        ListOf< Lazy< NotImplemented >, 1, 0 > ResponsiblePersons;
-        Lazy< NotImplemented > LastUpdateDate;
-        Maybe< Lazy< NotImplemented > > CurrentValue;
-        Maybe< Lazy< NotImplemented > > OriginalValue;
-    };
-
-    // C++ wrapper for IfcJunctionBoxType
-    struct IfcJunctionBoxType : IfcFlowFittingType, ObjectHelper<IfcJunctionBoxType,1> { IfcJunctionBoxType() : Object("IfcJunctionBoxType") {}
-        IfcJunctionBoxTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLShapeProfileDef
-    struct IfcLShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcLShapeProfileDef,8> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out Depth;
-        Maybe< IfcPositiveLengthMeasure::Out > Width;
-        IfcPositiveLengthMeasure::Out Thickness;
-        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
-        Maybe< IfcPlaneAngleMeasure::Out > LegSlope;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
-    };
-
-    // C++ wrapper for IfcLaborResource
-    struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {}
-        Maybe< IfcText::Out > SkillSet;
-    };
-
-    // C++ wrapper for IfcLampType
-    struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {}
-        IfcLampTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLightFixtureType
-    struct IfcLightFixtureType : IfcFlowTerminalType, ObjectHelper<IfcLightFixtureType,1> { IfcLightFixtureType() : Object("IfcLightFixtureType") {}
-        IfcLightFixtureTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLightSource
-    struct IfcLightSource : IfcGeometricRepresentationItem, ObjectHelper<IfcLightSource,4> { IfcLightSource() : Object("IfcLightSource") {}
-        Maybe< IfcLabel::Out > Name;
-        Lazy< IfcColourRgb > LightColour;
-        Maybe< IfcNormalisedRatioMeasure::Out > AmbientIntensity;
-        Maybe< IfcNormalisedRatioMeasure::Out > Intensity;
-    };
-
-    // C++ wrapper for IfcLightSourceAmbient
-    struct IfcLightSourceAmbient : IfcLightSource, ObjectHelper<IfcLightSourceAmbient,0> { IfcLightSourceAmbient() : Object("IfcLightSourceAmbient") {}
-
-    };
-
-    // C++ wrapper for IfcLightSourceDirectional
-    struct IfcLightSourceDirectional : IfcLightSource, ObjectHelper<IfcLightSourceDirectional,1> { IfcLightSourceDirectional() : Object("IfcLightSourceDirectional") {}
-        Lazy< IfcDirection > Orientation;
-    };
-
-    // C++ wrapper for IfcLightSourceGoniometric
-    struct IfcLightSourceGoniometric : IfcLightSource, ObjectHelper<IfcLightSourceGoniometric,6> { IfcLightSourceGoniometric() : Object("IfcLightSourceGoniometric") {}
-        Lazy< IfcAxis2Placement3D > Position;
-        Maybe< Lazy< IfcColourRgb > > ColourAppearance;
-        IfcThermodynamicTemperatureMeasure::Out ColourTemperature;
-        IfcLuminousFluxMeasure::Out LuminousFlux;
-        IfcLightEmissionSourceEnum::Out LightEmissionSource;
-        IfcLightDistributionDataSourceSelect::Out LightDistributionDataSource;
-    };
-
-    // C++ wrapper for IfcLightSourcePositional
-    struct IfcLightSourcePositional : IfcLightSource, ObjectHelper<IfcLightSourcePositional,5> { IfcLightSourcePositional() : Object("IfcLightSourcePositional") {}
-        Lazy< IfcCartesianPoint > Position;
-        IfcPositiveLengthMeasure::Out Radius;
-        IfcReal::Out ConstantAttenuation;
-        IfcReal::Out DistanceAttenuation;
-        IfcReal::Out QuadricAttenuation;
-    };
-
-    // C++ wrapper for IfcLightSourceSpot
-    struct IfcLightSourceSpot : IfcLightSourcePositional, ObjectHelper<IfcLightSourceSpot,4> { IfcLightSourceSpot() : Object("IfcLightSourceSpot") {}
-        Lazy< IfcDirection > Orientation;
-        Maybe< IfcReal::Out > ConcentrationExponent;
-        IfcPositivePlaneAngleMeasure::Out SpreadAngle;
-        IfcPositivePlaneAngleMeasure::Out BeamWidthAngle;
-    };
-
-    // C++ wrapper for IfcLine
-    struct IfcLine : IfcCurve, ObjectHelper<IfcLine,2> { IfcLine() : Object("IfcLine") {}
-        Lazy< IfcCartesianPoint > Pnt;
-        Lazy< IfcVector > Dir;
-    };
-
-    // C++ wrapper for IfcLinearDimension
-    struct IfcLinearDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcLinearDimension,0> { IfcLinearDimension() : Object("IfcLinearDimension") {}
-
-    };
-
-    // C++ wrapper for IfcLocalPlacement
-    struct IfcLocalPlacement : IfcObjectPlacement, ObjectHelper<IfcLocalPlacement,2> { IfcLocalPlacement() : Object("IfcLocalPlacement") {}
-        Maybe< Lazy< IfcObjectPlacement > > PlacementRelTo;
-        IfcAxis2Placement::Out RelativePlacement;
-    };
-
-    // C++ wrapper for IfcMappedItem
-    struct IfcMappedItem : IfcRepresentationItem, ObjectHelper<IfcMappedItem,2> { IfcMappedItem() : Object("IfcMappedItem") {}
-        Lazy< IfcRepresentationMap > MappingSource;
-        Lazy< IfcCartesianTransformationOperator > MappingTarget;
-    };
-
-    // C++ wrapper for IfcProductRepresentation
-    struct IfcProductRepresentation :  ObjectHelper<IfcProductRepresentation,3> { IfcProductRepresentation() : Object("IfcProductRepresentation") {}
-        Maybe< IfcLabel::Out > Name;
-        Maybe< IfcText::Out > Description;
-        ListOf< Lazy< IfcRepresentation >, 1, 0 > Representations;
-    };
-
-    // C++ wrapper for IfcMaterialDefinitionRepresentation
-    struct IfcMaterialDefinitionRepresentation : IfcProductRepresentation, ObjectHelper<IfcMaterialDefinitionRepresentation,1> { IfcMaterialDefinitionRepresentation() : Object("IfcMaterialDefinitionRepresentation") {}
-        Lazy< NotImplemented > RepresentedMaterial;
-    };
-
-    // C++ wrapper for IfcMeasureWithUnit
-    struct IfcMeasureWithUnit :  ObjectHelper<IfcMeasureWithUnit,2> { IfcMeasureWithUnit() : Object("IfcMeasureWithUnit") {}
-        IfcValue::Out ValueComponent;
-        IfcUnit::Out UnitComponent;
-    };
-
-    // C++ wrapper for IfcMechanicalFastener
-    struct IfcMechanicalFastener : IfcFastener, ObjectHelper<IfcMechanicalFastener,2> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {}
-        Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-        Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
-    };
-
-    // C++ wrapper for IfcMechanicalFastenerType
-    struct IfcMechanicalFastenerType : IfcFastenerType, ObjectHelper<IfcMechanicalFastenerType,0> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {}
-
-    };
-
-    // C++ wrapper for IfcMember
-    struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,0> { IfcMember() : Object("IfcMember") {}
-
-    };
-
-    // C++ wrapper for IfcMemberType
-    struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {}
-        IfcMemberTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcMotorConnectionType
-    struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {}
-        IfcMotorConnectionTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProcess
-    struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,0> { IfcProcess() : Object("IfcProcess") {}
-
-    };
-
-    // C++ wrapper for IfcTask
-    struct IfcTask : IfcProcess, ObjectHelper<IfcTask,5> { IfcTask() : Object("IfcTask") {}
-        IfcIdentifier::Out TaskId;
-        Maybe< IfcLabel::Out > Status;
-        Maybe< IfcLabel::Out > WorkMethod;
-        BOOLEAN::Out IsMilestone;
-        Maybe< INTEGER::Out > Priority;
-    };
-
-    // C++ wrapper for IfcMove
-    struct IfcMove : IfcTask, ObjectHelper<IfcMove,3> { IfcMove() : Object("IfcMove") {}
-        Lazy< IfcSpatialStructureElement > MoveFrom;
-        Lazy< IfcSpatialStructureElement > MoveTo;
-        Maybe< ListOf< IfcText, 1, 0 >::Out > PunchList;
-    };
-
-    // C++ wrapper for IfcOccupant
-    struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {}
-        IfcOccupantTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcOffsetCurve2D
-    struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {}
-        Lazy< IfcCurve > BasisCurve;
-        IfcLengthMeasure::Out Distance;
-        LOGICAL::Out SelfIntersect;
-    };
-
-    // C++ wrapper for IfcOffsetCurve3D
-    struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {}
-        Lazy< IfcCurve > BasisCurve;
-        IfcLengthMeasure::Out Distance;
-        LOGICAL::Out SelfIntersect;
-        Lazy< IfcDirection > RefDirection;
-    };
-
-    // C++ wrapper for IfcOneDirectionRepeatFactor
-    struct IfcOneDirectionRepeatFactor : IfcGeometricRepresentationItem, ObjectHelper<IfcOneDirectionRepeatFactor,1> { IfcOneDirectionRepeatFactor() : Object("IfcOneDirectionRepeatFactor") {}
-        Lazy< IfcVector > RepeatFactor;
-    };
-
-    // C++ wrapper for IfcOpenShell
-    struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {}
-
-    };
-
-    // C++ wrapper for IfcOpeningElement
-    struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,0> { IfcOpeningElement() : Object("IfcOpeningElement") {}
-
-    };
-
-    // C++ wrapper for IfcOrderAction
-    struct IfcOrderAction : IfcTask, ObjectHelper<IfcOrderAction,1> { IfcOrderAction() : Object("IfcOrderAction") {}
-        IfcIdentifier::Out ActionID;
-    };
-
-    // C++ wrapper for IfcOrientedEdge
-    struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {}
-        Lazy< IfcEdge > EdgeElement;
-        BOOLEAN::Out Orientation;
-    };
-
-    // C++ wrapper for IfcOutletType
-    struct IfcOutletType : IfcFlowTerminalType, ObjectHelper<IfcOutletType,1> { IfcOutletType() : Object("IfcOutletType") {}
-        IfcOutletTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPath
-    struct IfcPath : IfcTopologicalRepresentationItem, ObjectHelper<IfcPath,1> { IfcPath() : Object("IfcPath") {}
-        ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
-    };
-
-    // C++ wrapper for IfcPerformanceHistory
-    struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,1> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {}
-        IfcLabel::Out LifeCyclePhase;
-    };
-
-    // C++ wrapper for IfcPermit
-    struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,1> { IfcPermit() : Object("IfcPermit") {}
-        IfcIdentifier::Out PermitID;
-    };
-
-    // C++ wrapper for IfcPile
-    struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {}
-        IfcPileTypeEnum::Out PredefinedType;
-        Maybe< IfcPileConstructionEnum::Out > ConstructionType;
-    };
-
-    // C++ wrapper for IfcPipeFittingType
-    struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {}
-        IfcPipeFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPipeSegmentType
-    struct IfcPipeSegmentType : IfcFlowSegmentType, ObjectHelper<IfcPipeSegmentType,1> { IfcPipeSegmentType() : Object("IfcPipeSegmentType") {}
-        IfcPipeSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPlanarExtent
-    struct IfcPlanarExtent : IfcGeometricRepresentationItem, ObjectHelper<IfcPlanarExtent,2> { IfcPlanarExtent() : Object("IfcPlanarExtent") {}
-        IfcLengthMeasure::Out SizeInX;
-        IfcLengthMeasure::Out SizeInY;
-    };
-
-    // C++ wrapper for IfcPlanarBox
-    struct IfcPlanarBox : IfcPlanarExtent, ObjectHelper<IfcPlanarBox,1> { IfcPlanarBox() : Object("IfcPlanarBox") {}
-        IfcAxis2Placement::Out Placement;
-    };
-
-    // C++ wrapper for IfcPlane
-    struct IfcPlane : IfcElementarySurface, ObjectHelper<IfcPlane,0> { IfcPlane() : Object("IfcPlane") {}
-
-    };
-
-    // C++ wrapper for IfcPlate
-    struct IfcPlate : IfcBuildingElement, ObjectHelper<IfcPlate,0> { IfcPlate() : Object("IfcPlate") {}
-
-    };
-
-    // C++ wrapper for IfcPlateType
-    struct IfcPlateType : IfcBuildingElementType, ObjectHelper<IfcPlateType,1> { IfcPlateType() : Object("IfcPlateType") {}
-        IfcPlateTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPointOnCurve
-    struct IfcPointOnCurve : IfcPoint, ObjectHelper<IfcPointOnCurve,2> { IfcPointOnCurve() : Object("IfcPointOnCurve") {}
-        Lazy< IfcCurve > BasisCurve;
-        IfcParameterValue::Out PointParameter;
-    };
-
-    // C++ wrapper for IfcPointOnSurface
-    struct IfcPointOnSurface : IfcPoint, ObjectHelper<IfcPointOnSurface,3> { IfcPointOnSurface() : Object("IfcPointOnSurface") {}
-        Lazy< IfcSurface > BasisSurface;
-        IfcParameterValue::Out PointParameterU;
-        IfcParameterValue::Out PointParameterV;
-    };
-
-    // C++ wrapper for IfcPolyLoop
-    struct IfcPolyLoop : IfcLoop, ObjectHelper<IfcPolyLoop,1> { IfcPolyLoop() : Object("IfcPolyLoop") {}
-        ListOf< Lazy< IfcCartesianPoint >, 3, 0 > Polygon;
-    };
-
-    // C++ wrapper for IfcPolygonalBoundedHalfSpace
-    struct IfcPolygonalBoundedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcPolygonalBoundedHalfSpace,2> { IfcPolygonalBoundedHalfSpace() : Object("IfcPolygonalBoundedHalfSpace") {}
-        Lazy< IfcAxis2Placement3D > Position;
-        Lazy< IfcBoundedCurve > PolygonalBoundary;
-    };
-
-    // C++ wrapper for IfcPolyline
-    struct IfcPolyline : IfcBoundedCurve, ObjectHelper<IfcPolyline,1> { IfcPolyline() : Object("IfcPolyline") {}
-        ListOf< Lazy< IfcCartesianPoint >, 2, 0 > Points;
-    };
-
-    // C++ wrapper for IfcPresentationStyleAssignment
-    struct IfcPresentationStyleAssignment :  ObjectHelper<IfcPresentationStyleAssignment,1> { IfcPresentationStyleAssignment() : Object("IfcPresentationStyleAssignment") {}
-        ListOf< IfcPresentationStyleSelect, 1, 0 >::Out Styles;
-    };
-
-    // C++ wrapper for IfcProcedure
-    struct IfcProcedure : IfcProcess, ObjectHelper<IfcProcedure,3> { IfcProcedure() : Object("IfcProcedure") {}
-        IfcIdentifier::Out ProcedureID;
-        IfcProcedureTypeEnum::Out ProcedureType;
-        Maybe< IfcLabel::Out > UserDefinedProcedureType;
-    };
-
-    // C++ wrapper for IfcProductDefinitionShape
-    struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {}
-
-    };
-
-    // C++ wrapper for IfcProject
-    struct IfcProject : IfcObject, ObjectHelper<IfcProject,4> { IfcProject() : Object("IfcProject") {}
-        Maybe< IfcLabel::Out > LongName;
-        Maybe< IfcLabel::Out > Phase;
-        ListOf< Lazy< IfcRepresentationContext >, 1, 0 > RepresentationContexts;
-        Lazy< IfcUnitAssignment > UnitsInContext;
-    };
-
-    // C++ wrapper for IfcProjectOrder
-    struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {}
-        IfcIdentifier::Out ID;
-        IfcProjectOrderTypeEnum::Out PredefinedType;
-        Maybe< IfcLabel::Out > Status;
-    };
-
-    // C++ wrapper for IfcProjectOrderRecord
-    struct IfcProjectOrderRecord : IfcControl, ObjectHelper<IfcProjectOrderRecord,2> { IfcProjectOrderRecord() : Object("IfcProjectOrderRecord") {}
-        ListOf< Lazy< NotImplemented >, 1, 0 > Records;
-        IfcProjectOrderRecordTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProjectionCurve
-    struct IfcProjectionCurve : IfcAnnotationCurveOccurrence, ObjectHelper<IfcProjectionCurve,0> { IfcProjectionCurve() : Object("IfcProjectionCurve") {}
-
-    };
-
-    // C++ wrapper for IfcProjectionElement
-    struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,0> { IfcProjectionElement() : Object("IfcProjectionElement") {}
-
-    };
-
-    // C++ wrapper for IfcSimpleProperty
-    struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {}
-
-    };
-
-    // C++ wrapper for IfcPropertyBoundedValue
-    struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,3> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {}
-        Maybe< IfcValue::Out > UpperBoundValue;
-        Maybe< IfcValue::Out > LowerBoundValue;
-        Maybe< IfcUnit::Out > Unit;
-    };
-
-    // C++ wrapper for IfcPropertyEnumeratedValue
-    struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {}
-        ListOf< IfcValue, 1, 0 >::Out EnumerationValues;
-        Maybe< Lazy< NotImplemented > > EnumerationReference;
-    };
-
-    // C++ wrapper for IfcPropertyListValue
-    struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {}
-        ListOf< IfcValue, 1, 0 >::Out ListValues;
-        Maybe< IfcUnit::Out > Unit;
-    };
-
-    // C++ wrapper for IfcPropertyReferenceValue
-    struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {}
-        Maybe< IfcLabel::Out > UsageName;
-        IfcObjectReferenceSelect::Out PropertyReference;
-    };
-
-    // C++ wrapper for IfcPropertySet
-    struct IfcPropertySet : IfcPropertySetDefinition, ObjectHelper<IfcPropertySet,1> { IfcPropertySet() : Object("IfcPropertySet") {}
-        ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
-    };
-
-    // C++ wrapper for IfcPropertySingleValue
-    struct IfcPropertySingleValue : IfcSimpleProperty, ObjectHelper<IfcPropertySingleValue,2> { IfcPropertySingleValue() : Object("IfcPropertySingleValue") {}
-        Maybe< IfcValue::Out > NominalValue;
-        Maybe< IfcUnit::Out > Unit;
-    };
-
-    // C++ wrapper for IfcPropertyTableValue
-    struct IfcPropertyTableValue : IfcSimpleProperty, ObjectHelper<IfcPropertyTableValue,5> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {}
-        ListOf< IfcValue, 1, 0 >::Out DefiningValues;
-        ListOf< IfcValue, 1, 0 >::Out DefinedValues;
-        Maybe< IfcText::Out > Expression;
-        Maybe< IfcUnit::Out > DefiningUnit;
-        Maybe< IfcUnit::Out > DefinedUnit;
-    };
-
-    // C++ wrapper for IfcProtectiveDeviceType
-    struct IfcProtectiveDeviceType : IfcFlowControllerType, ObjectHelper<IfcProtectiveDeviceType,1> { IfcProtectiveDeviceType() : Object("IfcProtectiveDeviceType") {}
-        IfcProtectiveDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProxy
-    struct IfcProxy : IfcProduct, ObjectHelper<IfcProxy,2> { IfcProxy() : Object("IfcProxy") {}
-        IfcObjectTypeEnum::Out ProxyType;
-        Maybe< IfcLabel::Out > Tag;
-    };
-
-    // C++ wrapper for IfcPumpType
-    struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {}
-        IfcPumpTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRadiusDimension
-    struct IfcRadiusDimension : IfcDimensionCurveDirectedCallout, ObjectHelper<IfcRadiusDimension,0> { IfcRadiusDimension() : Object("IfcRadiusDimension") {}
-
-    };
-
-    // C++ wrapper for IfcRailing
-    struct IfcRailing : IfcBuildingElement, ObjectHelper<IfcRailing,1> { IfcRailing() : Object("IfcRailing") {}
-        Maybe< IfcRailingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcRailingType
-    struct IfcRailingType : IfcBuildingElementType, ObjectHelper<IfcRailingType,1> { IfcRailingType() : Object("IfcRailingType") {}
-        IfcRailingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRamp
-    struct IfcRamp : IfcBuildingElement, ObjectHelper<IfcRamp,1> { IfcRamp() : Object("IfcRamp") {}
-        IfcRampTypeEnum::Out ShapeType;
-    };
-
-    // C++ wrapper for IfcRampFlight
-    struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,0> { IfcRampFlight() : Object("IfcRampFlight") {}
-
-    };
-
-    // C++ wrapper for IfcRampFlightType
-    struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {}
-        IfcRampFlightTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRationalBezierCurve
-    struct IfcRationalBezierCurve : IfcBezierCurve, ObjectHelper<IfcRationalBezierCurve,1> { IfcRationalBezierCurve() : Object("IfcRationalBezierCurve") {}
-        ListOf< REAL, 2, 0 >::Out WeightsData;
-    };
-
-    // C++ wrapper for IfcRectangleProfileDef
-    struct IfcRectangleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcRectangleProfileDef,2> { IfcRectangleProfileDef() : Object("IfcRectangleProfileDef") {}
-        IfcPositiveLengthMeasure::Out XDim;
-        IfcPositiveLengthMeasure::Out YDim;
-    };
-
-    // C++ wrapper for IfcRectangleHollowProfileDef
-    struct IfcRectangleHollowProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRectangleHollowProfileDef,3> { IfcRectangleHollowProfileDef() : Object("IfcRectangleHollowProfileDef") {}
-        IfcPositiveLengthMeasure::Out WallThickness;
-        Maybe< IfcPositiveLengthMeasure::Out > InnerFilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > OuterFilletRadius;
-    };
-
-    // C++ wrapper for IfcRectangularPyramid
-    struct IfcRectangularPyramid : IfcCsgPrimitive3D, ObjectHelper<IfcRectangularPyramid,3> { IfcRectangularPyramid() : Object("IfcRectangularPyramid") {}
-        IfcPositiveLengthMeasure::Out XLength;
-        IfcPositiveLengthMeasure::Out YLength;
-        IfcPositiveLengthMeasure::Out Height;
-    };
-
-    // C++ wrapper for IfcRectangularTrimmedSurface
-    struct IfcRectangularTrimmedSurface : IfcBoundedSurface, ObjectHelper<IfcRectangularTrimmedSurface,7> { IfcRectangularTrimmedSurface() : Object("IfcRectangularTrimmedSurface") {}
-        Lazy< IfcSurface > BasisSurface;
-        IfcParameterValue::Out U1;
-        IfcParameterValue::Out V1;
-        IfcParameterValue::Out U2;
-        IfcParameterValue::Out V2;
-        BOOLEAN::Out Usense;
-        BOOLEAN::Out Vsense;
-    };
-
-    // C++ wrapper for IfcReinforcingElement
-    struct IfcReinforcingElement : IfcBuildingElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {}
-        Maybe< IfcLabel::Out > SteelGrade;
-    };
-
-    // C++ wrapper for IfcReinforcingBar
-    struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {}
-        IfcPositiveLengthMeasure::Out NominalDiameter;
-        IfcAreaMeasure::Out CrossSectionArea;
-        Maybe< IfcPositiveLengthMeasure::Out > BarLength;
-        IfcReinforcingBarRoleEnum::Out BarRole;
-        Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
-    };
-
-    // C++ wrapper for IfcReinforcingMesh
-    struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,8> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {}
-        Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
-        Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
-        IfcPositiveLengthMeasure::Out LongitudinalBarNominalDiameter;
-        IfcPositiveLengthMeasure::Out TransverseBarNominalDiameter;
-        IfcAreaMeasure::Out LongitudinalBarCrossSectionArea;
-        IfcAreaMeasure::Out TransverseBarCrossSectionArea;
-        IfcPositiveLengthMeasure::Out LongitudinalBarSpacing;
-        IfcPositiveLengthMeasure::Out TransverseBarSpacing;
-    };
-
-    // C++ wrapper for IfcRelationship
-    struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {}
-
-    };
-
-    // C++ wrapper for IfcRelDecomposes
-    struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,2> { IfcRelDecomposes() : Object("IfcRelDecomposes") {}
-        Lazy< IfcObjectDefinition > RelatingObject;
-        ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
-    };
-
-    // C++ wrapper for IfcRelAggregates
-    struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,0> { IfcRelAggregates() : Object("IfcRelAggregates") {}
-
-    };
-
-    // C++ wrapper for IfcRelConnects
-    struct IfcRelConnects : IfcRelationship, ObjectHelper<IfcRelConnects,0> { IfcRelConnects() : Object("IfcRelConnects") {}
-
-    };
-
-    // C++ wrapper for IfcRelContainedInSpatialStructure
-    struct IfcRelContainedInSpatialStructure : IfcRelConnects, ObjectHelper<IfcRelContainedInSpatialStructure,2> { IfcRelContainedInSpatialStructure() : Object("IfcRelContainedInSpatialStructure") {}
-        ListOf< Lazy< IfcProduct >, 1, 0 > RelatedElements;
-        Lazy< IfcSpatialStructureElement > RelatingStructure;
-    };
-
-    // C++ wrapper for IfcRelDefines
-    struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,1> { IfcRelDefines() : Object("IfcRelDefines") {}
-        ListOf< Lazy< IfcObject >, 1, 0 > RelatedObjects;
-    };
-
-    // C++ wrapper for IfcRelDefinesByProperties
-    struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,1> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {}
-        Lazy< IfcPropertySetDefinition > RelatingPropertyDefinition;
-    };
-
-    // C++ wrapper for IfcRelFillsElement
-    struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {}
-        Lazy< IfcOpeningElement > RelatingOpeningElement;
-        Lazy< IfcElement > RelatedBuildingElement;
-    };
-
-    // C++ wrapper for IfcRelOverridesProperties
-    struct IfcRelOverridesProperties : IfcRelDefinesByProperties, ObjectHelper<IfcRelOverridesProperties,1> { IfcRelOverridesProperties() : Object("IfcRelOverridesProperties") {}
-        ListOf< Lazy< IfcProperty >, 1, 0 > OverridingProperties;
-    };
-
-    // C++ wrapper for IfcRelVoidsElement
-    struct IfcRelVoidsElement : IfcRelConnects, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {}
-        Lazy< IfcElement > RelatingBuildingElement;
-        Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement;
-    };
-
-    // C++ wrapper for IfcRepresentation
-    struct IfcRepresentation :  ObjectHelper<IfcRepresentation,4> { IfcRepresentation() : Object("IfcRepresentation") {}
-        Lazy< IfcRepresentationContext > ContextOfItems;
-        Maybe< IfcLabel::Out > RepresentationIdentifier;
-        Maybe< IfcLabel::Out > RepresentationType;
-        ListOf< Lazy< IfcRepresentationItem >, 1, 0 > Items;
-    };
-
-    // C++ wrapper for IfcRepresentationMap
-    struct IfcRepresentationMap :  ObjectHelper<IfcRepresentationMap,2> { IfcRepresentationMap() : Object("IfcRepresentationMap") {}
-        IfcAxis2Placement::Out MappingOrigin;
-        Lazy< IfcRepresentation > MappedRepresentation;
-    };
-
-    // C++ wrapper for IfcRevolvedAreaSolid
-    struct IfcRevolvedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcRevolvedAreaSolid,2> { IfcRevolvedAreaSolid() : Object("IfcRevolvedAreaSolid") {}
-        Lazy< IfcAxis1Placement > Axis;
-        IfcPlaneAngleMeasure::Out Angle;
-    };
-
-    // C++ wrapper for IfcRightCircularCone
-    struct IfcRightCircularCone : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCone,2> { IfcRightCircularCone() : Object("IfcRightCircularCone") {}
-        IfcPositiveLengthMeasure::Out Height;
-        IfcPositiveLengthMeasure::Out BottomRadius;
-    };
-
-    // C++ wrapper for IfcRightCircularCylinder
-    struct IfcRightCircularCylinder : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCylinder,2> { IfcRightCircularCylinder() : Object("IfcRightCircularCylinder") {}
-        IfcPositiveLengthMeasure::Out Height;
-        IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcRoof
-    struct IfcRoof : IfcBuildingElement, ObjectHelper<IfcRoof,1> { IfcRoof() : Object("IfcRoof") {}
-        IfcRoofTypeEnum::Out ShapeType;
-    };
-
-    // C++ wrapper for IfcRoundedEdgeFeature
-    struct IfcRoundedEdgeFeature : IfcEdgeFeature, ObjectHelper<IfcRoundedEdgeFeature,1> { IfcRoundedEdgeFeature() : Object("IfcRoundedEdgeFeature") {}
-        Maybe< IfcPositiveLengthMeasure::Out > Radius;
-    };
-
-    // C++ wrapper for IfcRoundedRectangleProfileDef
-    struct IfcRoundedRectangleProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRoundedRectangleProfileDef,1> { IfcRoundedRectangleProfileDef() : Object("IfcRoundedRectangleProfileDef") {}
-        IfcPositiveLengthMeasure::Out RoundingRadius;
-    };
-
-    // C++ wrapper for IfcSIUnit
-    struct IfcSIUnit : IfcNamedUnit, ObjectHelper<IfcSIUnit,2> { IfcSIUnit() : Object("IfcSIUnit") {}
-        Maybe< IfcSIPrefix::Out > Prefix;
-        IfcSIUnitName::Out Name;
-    };
-
-    // C++ wrapper for IfcSanitaryTerminalType
-    struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {}
-        IfcSanitaryTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcScheduleTimeControl
-    struct IfcScheduleTimeControl : IfcControl, ObjectHelper<IfcScheduleTimeControl,18> { IfcScheduleTimeControl() : Object("IfcScheduleTimeControl") {}
-        Maybe< IfcDateTimeSelect::Out > ActualStart;
-        Maybe< IfcDateTimeSelect::Out > EarlyStart;
-        Maybe< IfcDateTimeSelect::Out > LateStart;
-        Maybe< IfcDateTimeSelect::Out > ScheduleStart;
-        Maybe< IfcDateTimeSelect::Out > ActualFinish;
-        Maybe< IfcDateTimeSelect::Out > EarlyFinish;
-        Maybe< IfcDateTimeSelect::Out > LateFinish;
-        Maybe< IfcDateTimeSelect::Out > ScheduleFinish;
-        Maybe< IfcTimeMeasure::Out > ScheduleDuration;
-        Maybe< IfcTimeMeasure::Out > ActualDuration;
-        Maybe< IfcTimeMeasure::Out > RemainingTime;
-        Maybe< IfcTimeMeasure::Out > FreeFloat;
-        Maybe< IfcTimeMeasure::Out > TotalFloat;
-        Maybe< BOOLEAN::Out > IsCritical;
-        Maybe< IfcDateTimeSelect::Out > StatusTime;
-        Maybe< IfcTimeMeasure::Out > StartFloat;
-        Maybe< IfcTimeMeasure::Out > FinishFloat;
-        Maybe< IfcPositiveRatioMeasure::Out > Completion;
-    };
-
-    // C++ wrapper for IfcSectionedSpine
-    struct IfcSectionedSpine : IfcGeometricRepresentationItem, ObjectHelper<IfcSectionedSpine,3> { IfcSectionedSpine() : Object("IfcSectionedSpine") {}
-        Lazy< IfcCompositeCurve > SpineCurve;
-        ListOf< Lazy< IfcProfileDef >, 2, 0 > CrossSections;
-        ListOf< Lazy< IfcAxis2Placement3D >, 2, 0 > CrossSectionPositions;
-    };
-
-    // C++ wrapper for IfcSensorType
-    struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {}
-        IfcSensorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcServiceLife
-    struct IfcServiceLife : IfcControl, ObjectHelper<IfcServiceLife,2> { IfcServiceLife() : Object("IfcServiceLife") {}
-        IfcServiceLifeTypeEnum::Out ServiceLifeType;
-        IfcTimeMeasure::Out ServiceLifeDuration;
-    };
-
-    // C++ wrapper for IfcShapeModel
-    struct IfcShapeModel : IfcRepresentation, ObjectHelper<IfcShapeModel,0> { IfcShapeModel() : Object("IfcShapeModel") {}
-
-    };
-
-    // C++ wrapper for IfcShapeRepresentation
-    struct IfcShapeRepresentation : IfcShapeModel, ObjectHelper<IfcShapeRepresentation,0> { IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
-
-    };
-
-    // C++ wrapper for IfcShellBasedSurfaceModel
-    struct IfcShellBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcShellBasedSurfaceModel,1> { IfcShellBasedSurfaceModel() : Object("IfcShellBasedSurfaceModel") {}
-        ListOf< IfcShell, 1, 0 >::Out SbsmBoundary;
-    };
-
-    // C++ wrapper for IfcSite
-    struct IfcSite : IfcSpatialStructureElement, ObjectHelper<IfcSite,5> { IfcSite() : Object("IfcSite") {}
-        Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLatitude;
-        Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLongitude;
-        Maybe< IfcLengthMeasure::Out > RefElevation;
-        Maybe< IfcLabel::Out > LandTitleNumber;
-        Maybe< Lazy< NotImplemented > > SiteAddress;
-    };
-
-    // C++ wrapper for IfcSlab
-    struct IfcSlab : IfcBuildingElement, ObjectHelper<IfcSlab,1> { IfcSlab() : Object("IfcSlab") {}
-        Maybe< IfcSlabTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSlabType
-    struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {}
-        IfcSlabTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSpace
-    struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {}
-        IfcInternalOrExternalEnum::Out InteriorOrExteriorSpace;
-        Maybe< IfcLengthMeasure::Out > ElevationWithFlooring;
-    };
-
-    // C++ wrapper for IfcSpaceHeaterType
-    struct IfcSpaceHeaterType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {}
-        IfcSpaceHeaterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSpaceProgram
-    struct IfcSpaceProgram : IfcControl, ObjectHelper<IfcSpaceProgram,5> { IfcSpaceProgram() : Object("IfcSpaceProgram") {}
-        IfcIdentifier::Out SpaceProgramIdentifier;
-        Maybe< IfcAreaMeasure::Out > MaxRequiredArea;
-        Maybe< IfcAreaMeasure::Out > MinRequiredArea;
-        Maybe< Lazy< IfcSpatialStructureElement > > RequestedLocation;
-        IfcAreaMeasure::Out StandardRequiredArea;
-    };
-
-    // C++ wrapper for IfcSpatialStructureElementType
-    struct IfcSpatialStructureElementType : IfcElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {}
-
-    };
-
-    // C++ wrapper for IfcSpaceType
-    struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,1> { IfcSpaceType() : Object("IfcSpaceType") {}
-        IfcSpaceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSphere
-    struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {}
-        IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcStackTerminalType
-    struct IfcStackTerminalType : IfcFlowTerminalType, ObjectHelper<IfcStackTerminalType,1> { IfcStackTerminalType() : Object("IfcStackTerminalType") {}
-        IfcStackTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStair
-    struct IfcStair : IfcBuildingElement, ObjectHelper<IfcStair,1> { IfcStair() : Object("IfcStair") {}
-        IfcStairTypeEnum::Out ShapeType;
-    };
-
-    // C++ wrapper for IfcStairFlight
-    struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,4> { IfcStairFlight() : Object("IfcStairFlight") {}
-        Maybe< INTEGER::Out > NumberOfRiser;
-        Maybe< INTEGER::Out > NumberOfTreads;
-        Maybe< IfcPositiveLengthMeasure::Out > RiserHeight;
-        Maybe< IfcPositiveLengthMeasure::Out > TreadLength;
-    };
-
-    // C++ wrapper for IfcStairFlightType
-    struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {}
-        IfcStairFlightTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStructuralActivity
-    struct IfcStructuralActivity : IfcProduct, ObjectHelper<IfcStructuralActivity,2> { IfcStructuralActivity() : Object("IfcStructuralActivity") {}
-        Lazy< NotImplemented > AppliedLoad;
-        IfcGlobalOrLocalEnum::Out GlobalOrLocal;
-    };
-
-    // C++ wrapper for IfcStructuralAction
-    struct IfcStructuralAction : IfcStructuralActivity, ObjectHelper<IfcStructuralAction,2> { IfcStructuralAction() : Object("IfcStructuralAction") {}
-        BOOLEAN::Out DestabilizingLoad;
-        Maybe< Lazy< IfcStructuralReaction > > CausedBy;
-    };
-
-    // C++ wrapper for IfcStructuralAnalysisModel
-    struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,4> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {}
-        IfcAnalysisModelTypeEnum::Out PredefinedType;
-        Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane;
-        Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy;
-        Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults;
-    };
-
-    // C++ wrapper for IfcStructuralItem
-    struct IfcStructuralItem : IfcProduct, ObjectHelper<IfcStructuralItem,0> { IfcStructuralItem() : Object("IfcStructuralItem") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralConnection
-    struct IfcStructuralConnection : IfcStructuralItem, ObjectHelper<IfcStructuralConnection,1> { IfcStructuralConnection() : Object("IfcStructuralConnection") {}
-        Maybe< Lazy< NotImplemented > > AppliedCondition;
-    };
-
-    // C++ wrapper for IfcStructuralCurveConnection
-    struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,0> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralMember
-    struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralCurveMember
-    struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,1> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {}
-        IfcStructuralCurveTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStructuralCurveMemberVarying
-    struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralLinearAction
-    struct IfcStructuralLinearAction : IfcStructuralAction, ObjectHelper<IfcStructuralLinearAction,1> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {}
-        IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue;
-    };
-
-    // C++ wrapper for IfcStructuralLinearActionVarying
-    struct IfcStructuralLinearActionVarying : IfcStructuralLinearAction, ObjectHelper<IfcStructuralLinearActionVarying,2> { IfcStructuralLinearActionVarying() : Object("IfcStructuralLinearActionVarying") {}
-        Lazy< NotImplemented > VaryingAppliedLoadLocation;
-        ListOf< Lazy< NotImplemented >, 1, 0 > SubsequentAppliedLoads;
-    };
-
-    // C++ wrapper for IfcStructuralLoadGroup
-    struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {}
-        IfcLoadGroupTypeEnum::Out PredefinedType;
-        IfcActionTypeEnum::Out ActionType;
-        IfcActionSourceTypeEnum::Out ActionSource;
-        Maybe< IfcPositiveRatioMeasure::Out > Coefficient;
-        Maybe< IfcLabel::Out > Purpose;
-    };
-
-    // C++ wrapper for IfcStructuralPlanarAction
-    struct IfcStructuralPlanarAction : IfcStructuralAction, ObjectHelper<IfcStructuralPlanarAction,1> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {}
-        IfcProjectedOrTrueLengthEnum::Out ProjectedOrTrue;
-    };
-
-    // C++ wrapper for IfcStructuralPlanarActionVarying
-    struct IfcStructuralPlanarActionVarying : IfcStructuralPlanarAction, ObjectHelper<IfcStructuralPlanarActionVarying,2> { IfcStructuralPlanarActionVarying() : Object("IfcStructuralPlanarActionVarying") {}
-        Lazy< NotImplemented > VaryingAppliedLoadLocation;
-        ListOf< Lazy< NotImplemented >, 2, 0 > SubsequentAppliedLoads;
-    };
-
-    // C++ wrapper for IfcStructuralPointAction
-    struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralPointConnection
-    struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,0> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralReaction
-    struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralPointReaction
-    struct IfcStructuralPointReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralPointReaction,0> { IfcStructuralPointReaction() : Object("IfcStructuralPointReaction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralResultGroup
-    struct IfcStructuralResultGroup : IfcGroup, ObjectHelper<IfcStructuralResultGroup,3> { IfcStructuralResultGroup() : Object("IfcStructuralResultGroup") {}
-        IfcAnalysisTheoryTypeEnum::Out TheoryType;
-        Maybe< Lazy< IfcStructuralLoadGroup > > ResultForLoadGroup;
-        BOOLEAN::Out IsLinear;
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceConnection
-    struct IfcStructuralSurfaceConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralSurfaceConnection,0> { IfcStructuralSurfaceConnection() : Object("IfcStructuralSurfaceConnection") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceMember
-    struct IfcStructuralSurfaceMember : IfcStructuralMember, ObjectHelper<IfcStructuralSurfaceMember,2> { IfcStructuralSurfaceMember() : Object("IfcStructuralSurfaceMember") {}
-        IfcStructuralSurfaceTypeEnum::Out PredefinedType;
-        Maybe< IfcPositiveLengthMeasure::Out > Thickness;
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceMemberVarying
-    struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,2> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {}
-        ListOf< IfcPositiveLengthMeasure, 2, 0 >::Out SubsequentThickness;
-        Lazy< NotImplemented > VaryingThicknessLocation;
-    };
-
-    // C++ wrapper for IfcStructuredDimensionCallout
-    struct IfcStructuredDimensionCallout : IfcDraughtingCallout, ObjectHelper<IfcStructuredDimensionCallout,0> { IfcStructuredDimensionCallout() : Object("IfcStructuredDimensionCallout") {}
-
-    };
-
-    // C++ wrapper for IfcStyleModel
-    struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {}
-
-    };
-
-    // C++ wrapper for IfcStyledRepresentation
-    struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {}
-
-    };
-
-    // C++ wrapper for IfcSubContractResource
-    struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,2> { IfcSubContractResource() : Object("IfcSubContractResource") {}
-        Maybe< IfcActorSelect::Out > SubContractor;
-        Maybe< IfcText::Out > JobDescription;
-    };
-
-    // C++ wrapper for IfcSubedge
-    struct IfcSubedge : IfcEdge, ObjectHelper<IfcSubedge,1> { IfcSubedge() : Object("IfcSubedge") {}
-        Lazy< IfcEdge > ParentEdge;
-    };
-
-    // C++ wrapper for IfcSurfaceCurveSweptAreaSolid
-    struct IfcSurfaceCurveSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4> { IfcSurfaceCurveSweptAreaSolid() : Object("IfcSurfaceCurveSweptAreaSolid") {}
-        Lazy< IfcCurve > Directrix;
-        IfcParameterValue::Out StartParam;
-        IfcParameterValue::Out EndParam;
-        Lazy< IfcSurface > ReferenceSurface;
-    };
-
-    // C++ wrapper for IfcSweptSurface
-    struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {}
-        Lazy< IfcProfileDef > SweptCurve;
-        Lazy< IfcAxis2Placement3D > Position;
-    };
-
-    // C++ wrapper for IfcSurfaceOfLinearExtrusion
-    struct IfcSurfaceOfLinearExtrusion : IfcSweptSurface, ObjectHelper<IfcSurfaceOfLinearExtrusion,2> { IfcSurfaceOfLinearExtrusion() : Object("IfcSurfaceOfLinearExtrusion") {}
-        Lazy< IfcDirection > ExtrudedDirection;
-        IfcLengthMeasure::Out Depth;
-    };
-
-    // C++ wrapper for IfcSurfaceOfRevolution
-    struct IfcSurfaceOfRevolution : IfcSweptSurface, ObjectHelper<IfcSurfaceOfRevolution,1> { IfcSurfaceOfRevolution() : Object("IfcSurfaceOfRevolution") {}
-        Lazy< IfcAxis1Placement > AxisPosition;
-    };
-
-    // C++ wrapper for IfcSurfaceStyle
-    struct IfcSurfaceStyle : IfcPresentationStyle, ObjectHelper<IfcSurfaceStyle,2> { IfcSurfaceStyle() : Object("IfcSurfaceStyle") {}
-        IfcSurfaceSide::Out Side;
-        ListOf< IfcSurfaceStyleElementSelect, 1, 5 >::Out Styles;
-    };
-
-    // C++ wrapper for IfcSurfaceStyleShading
-    struct IfcSurfaceStyleShading :  ObjectHelper<IfcSurfaceStyleShading,1> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {}
-        Lazy< IfcColourRgb > SurfaceColour;
-    };
-
-    // C++ wrapper for IfcSurfaceStyleRendering
-    struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,8> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {}
-        Maybe< IfcNormalisedRatioMeasure::Out > Transparency;
-        Maybe< IfcColourOrFactor::Out > DiffuseColour;
-        Maybe< IfcColourOrFactor::Out > TransmissionColour;
-        Maybe< IfcColourOrFactor::Out > DiffuseTransmissionColour;
-        Maybe< IfcColourOrFactor::Out > ReflectionColour;
-        Maybe< IfcColourOrFactor::Out > SpecularColour;
-        Maybe< IfcSpecularHighlightSelect::Out > SpecularHighlight;
-        IfcReflectanceMethodEnum::Out ReflectanceMethod;
-    };
-
-    // C++ wrapper for IfcSurfaceStyleWithTextures
-    struct IfcSurfaceStyleWithTextures :  ObjectHelper<IfcSurfaceStyleWithTextures,1> { IfcSurfaceStyleWithTextures() : Object("IfcSurfaceStyleWithTextures") {}
-        ListOf< Lazy< NotImplemented >, 1, 0 > Textures;
-    };
-
-    // C++ wrapper for IfcSweptDiskSolid
-    struct IfcSweptDiskSolid : IfcSolidModel, ObjectHelper<IfcSweptDiskSolid,5> { IfcSweptDiskSolid() : Object("IfcSweptDiskSolid") {}
-        Lazy< IfcCurve > Directrix;
-        IfcPositiveLengthMeasure::Out Radius;
-        Maybe< IfcPositiveLengthMeasure::Out > InnerRadius;
-        IfcParameterValue::Out StartParam;
-        IfcParameterValue::Out EndParam;
-    };
-
-    // C++ wrapper for IfcSwitchingDeviceType
-    struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {}
-        IfcSwitchingDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSystemFurnitureElementType
-    struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,0> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {}
-
-    };
-
-    // C++ wrapper for IfcTShapeProfileDef
-    struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,10> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out Depth;
-        IfcPositiveLengthMeasure::Out FlangeWidth;
-        IfcPositiveLengthMeasure::Out WebThickness;
-        IfcPositiveLengthMeasure::Out FlangeThickness;
-        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > FlangeEdgeRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > WebEdgeRadius;
-        Maybe< IfcPlaneAngleMeasure::Out > WebSlope;
-        Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInY;
-    };
-
-    // C++ wrapper for IfcTankType
-    struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {}
-        IfcTankTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTendon
-    struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {}
-        IfcTendonTypeEnum::Out PredefinedType;
-        IfcPositiveLengthMeasure::Out NominalDiameter;
-        IfcAreaMeasure::Out CrossSectionArea;
-        Maybe< IfcForceMeasure::Out > TensionForce;
-        Maybe< IfcPressureMeasure::Out > PreStress;
-        Maybe< IfcNormalisedRatioMeasure::Out > FrictionCoefficient;
-        Maybe< IfcPositiveLengthMeasure::Out > AnchorageSlip;
-        Maybe< IfcPositiveLengthMeasure::Out > MinCurvatureRadius;
-    };
-
-    // C++ wrapper for IfcTendonAnchor
-    struct IfcTendonAnchor : IfcReinforcingElement, ObjectHelper<IfcTendonAnchor,0> { IfcTendonAnchor() : Object("IfcTendonAnchor") {}
-
-    };
-
-    // C++ wrapper for IfcTextLiteral
-    struct IfcTextLiteral : IfcGeometricRepresentationItem, ObjectHelper<IfcTextLiteral,3> { IfcTextLiteral() : Object("IfcTextLiteral") {}
-        IfcPresentableText::Out Literal;
-        IfcAxis2Placement::Out Placement;
-        IfcTextPath::Out Path;
-    };
-
-    // C++ wrapper for IfcTextLiteralWithExtent
-    struct IfcTextLiteralWithExtent : IfcTextLiteral, ObjectHelper<IfcTextLiteralWithExtent,2> { IfcTextLiteralWithExtent() : Object("IfcTextLiteralWithExtent") {}
-        Lazy< IfcPlanarExtent > Extent;
-        IfcBoxAlignment::Out BoxAlignment;
-    };
-
-    // C++ wrapper for IfcTimeSeriesSchedule
-    struct IfcTimeSeriesSchedule : IfcControl, ObjectHelper<IfcTimeSeriesSchedule,3> { IfcTimeSeriesSchedule() : Object("IfcTimeSeriesSchedule") {}
-        Maybe< ListOf< IfcDateTimeSelect, 1, 0 >::Out > ApplicableDates;
-        IfcTimeSeriesScheduleTypeEnum::Out TimeSeriesScheduleType;
-        Lazy< NotImplemented > TimeSeries;
-    };
-
-    // C++ wrapper for IfcTopologyRepresentation
-    struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {}
-
-    };
-
-    // C++ wrapper for IfcTransformerType
-    struct IfcTransformerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTransformerType,1> { IfcTransformerType() : Object("IfcTransformerType") {}
-        IfcTransformerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTransportElement
-    struct IfcTransportElement : IfcElement, ObjectHelper<IfcTransportElement,3> { IfcTransportElement() : Object("IfcTransportElement") {}
-        Maybe< IfcTransportElementTypeEnum::Out > OperationType;
-        Maybe< IfcMassMeasure::Out > CapacityByWeight;
-        Maybe< IfcCountMeasure::Out > CapacityByNumber;
-    };
-
-    // C++ wrapper for IfcTransportElementType
-    struct IfcTransportElementType : IfcElementType, ObjectHelper<IfcTransportElementType,1> { IfcTransportElementType() : Object("IfcTransportElementType") {}
-        IfcTransportElementTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTrapeziumProfileDef
-    struct IfcTrapeziumProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTrapeziumProfileDef,4> { IfcTrapeziumProfileDef() : Object("IfcTrapeziumProfileDef") {}
-        IfcPositiveLengthMeasure::Out BottomXDim;
-        IfcPositiveLengthMeasure::Out TopXDim;
-        IfcPositiveLengthMeasure::Out YDim;
-        IfcLengthMeasure::Out TopXOffset;
-    };
-
-    // C++ wrapper for IfcTrimmedCurve
-    struct IfcTrimmedCurve : IfcBoundedCurve, ObjectHelper<IfcTrimmedCurve,5> { IfcTrimmedCurve() : Object("IfcTrimmedCurve") {}
-        Lazy< IfcCurve > BasisCurve;
-        ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim1;
-        ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim2;
-        BOOLEAN::Out SenseAgreement;
-        IfcTrimmingPreference::Out MasterRepresentation;
-    };
-
-    // C++ wrapper for IfcTubeBundleType
-    struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {}
-        IfcTubeBundleTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTwoDirectionRepeatFactor
-    struct IfcTwoDirectionRepeatFactor : IfcOneDirectionRepeatFactor, ObjectHelper<IfcTwoDirectionRepeatFactor,1> { IfcTwoDirectionRepeatFactor() : Object("IfcTwoDirectionRepeatFactor") {}
-        Lazy< IfcVector > SecondRepeatFactor;
-    };
-
-    // C++ wrapper for IfcUShapeProfileDef
-    struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,8> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out Depth;
-        IfcPositiveLengthMeasure::Out FlangeWidth;
-        IfcPositiveLengthMeasure::Out WebThickness;
-        IfcPositiveLengthMeasure::Out FlangeThickness;
-        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
-        Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
-        Maybe< IfcPositiveLengthMeasure::Out > CentreOfGravityInX;
-    };
-
-    // C++ wrapper for IfcUnitAssignment
-    struct IfcUnitAssignment :  ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {}
-        ListOf< IfcUnit, 1, 0 >::Out Units;
-    };
-
-    // C++ wrapper for IfcUnitaryEquipmentType
-    struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {}
-        IfcUnitaryEquipmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcValveType
-    struct IfcValveType : IfcFlowControllerType, ObjectHelper<IfcValveType,1> { IfcValveType() : Object("IfcValveType") {}
-        IfcValveTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcVector
-    struct IfcVector : IfcGeometricRepresentationItem, ObjectHelper<IfcVector,2> { IfcVector() : Object("IfcVector") {}
-        Lazy< IfcDirection > Orientation;
-        IfcLengthMeasure::Out Magnitude;
-    };
-
-    // C++ wrapper for IfcVertex
-    struct IfcVertex : IfcTopologicalRepresentationItem, ObjectHelper<IfcVertex,0> { IfcVertex() : Object("IfcVertex") {}
-
-    };
-
-    // C++ wrapper for IfcVertexLoop
-    struct IfcVertexLoop : IfcLoop, ObjectHelper<IfcVertexLoop,1> { IfcVertexLoop() : Object("IfcVertexLoop") {}
-        Lazy< IfcVertex > LoopVertex;
-    };
-
-    // C++ wrapper for IfcVertexPoint
-    struct IfcVertexPoint : IfcVertex, ObjectHelper<IfcVertexPoint,1> { IfcVertexPoint() : Object("IfcVertexPoint") {}
-        Lazy< IfcPoint > VertexGeometry;
-    };
-
-    // C++ wrapper for IfcVibrationIsolatorType
-    struct IfcVibrationIsolatorType : IfcDiscreteAccessoryType, ObjectHelper<IfcVibrationIsolatorType,1> { IfcVibrationIsolatorType() : Object("IfcVibrationIsolatorType") {}
-        IfcVibrationIsolatorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcVirtualElement
-    struct IfcVirtualElement : IfcElement, ObjectHelper<IfcVirtualElement,0> { IfcVirtualElement() : Object("IfcVirtualElement") {}
-
-    };
-
-    // C++ wrapper for IfcWall
-    struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,0> { IfcWall() : Object("IfcWall") {}
-
-    };
-
-    // C++ wrapper for IfcWallStandardCase
-    struct IfcWallStandardCase : IfcWall, ObjectHelper<IfcWallStandardCase,0> { IfcWallStandardCase() : Object("IfcWallStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcWallType
-    struct IfcWallType : IfcBuildingElementType, ObjectHelper<IfcWallType,1> { IfcWallType() : Object("IfcWallType") {}
-        IfcWallTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcWasteTerminalType
-    struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {}
-        IfcWasteTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcWindow
-    struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,2> { IfcWindow() : Object("IfcWindow") {}
-        Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
-        Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
-    };
-
-    // C++ wrapper for IfcWindowStyle
-    struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {}
-        IfcWindowStyleConstructionEnum::Out ConstructionType;
-        IfcWindowStyleOperationEnum::Out OperationType;
-        BOOLEAN::Out ParameterTakesPrecedence;
-        BOOLEAN::Out Sizeable;
-    };
-
-    // C++ wrapper for IfcWorkControl
-    struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,10> { IfcWorkControl() : Object("IfcWorkControl") {}
-        IfcIdentifier::Out Identifier;
-        IfcDateTimeSelect::Out CreationDate;
-        Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators;
-        Maybe< IfcLabel::Out > Purpose;
-        Maybe< IfcTimeMeasure::Out > Duration;
-        Maybe< IfcTimeMeasure::Out > TotalFloat;
-        IfcDateTimeSelect::Out StartTime;
-        Maybe< IfcDateTimeSelect::Out > FinishTime;
-        Maybe< IfcWorkControlTypeEnum::Out > WorkControlType;
-        Maybe< IfcLabel::Out > UserDefinedControlType;
-    };
-
-    // C++ wrapper for IfcWorkPlan
-    struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,0> { IfcWorkPlan() : Object("IfcWorkPlan") {}
-
-    };
-
-    // C++ wrapper for IfcWorkSchedule
-    struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,0> { IfcWorkSchedule() : Object("IfcWorkSchedule") {}
-
-    };
-
-    // C++ wrapper for IfcZShapeProfileDef
-    struct IfcZShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcZShapeProfileDef,6> { IfcZShapeProfileDef() : Object("IfcZShapeProfileDef") {}
-        IfcPositiveLengthMeasure::Out Depth;
-        IfcPositiveLengthMeasure::Out FlangeWidth;
-        IfcPositiveLengthMeasure::Out WebThickness;
-        IfcPositiveLengthMeasure::Out FlangeThickness;
-        Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
-        Maybe< IfcPositiveLengthMeasure::Out > EdgeRadius;
-    };
-
-    // C++ wrapper for IfcZone
-    struct IfcZone : IfcGroup, ObjectHelper<IfcZone,0> { IfcZone() : Object("IfcZone") {}
-
-    };
-
-    void GetSchema(EXPRESS::ConversionSchema& out);
-    } //! Schema_2x3
-} //! IFC
-
-namespace STEP {
-
-    // ******************************************************************************
-    // Converter stubs
-    // ******************************************************************************
-
-#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::Schema_2x3::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::Schema_2x3::type* in)
-
-    DECL_CONV_STUB(IfcRepresentationItem);
-    DECL_CONV_STUB(IfcGeometricRepresentationItem);
-    DECL_CONV_STUB(IfcCurve);
-    DECL_CONV_STUB(IfcBoundedCurve);
-    DECL_CONV_STUB(IfcCompositeCurve);
-    DECL_CONV_STUB(Ifc2DCompositeCurve);
-    DECL_CONV_STUB(IfcRoot);
-    DECL_CONV_STUB(IfcObjectDefinition);
-    DECL_CONV_STUB(IfcObject);
-    DECL_CONV_STUB(IfcControl);
-    DECL_CONV_STUB(IfcActionRequest);
-    DECL_CONV_STUB(IfcActor);
-    DECL_CONV_STUB(IfcTypeObject);
-    DECL_CONV_STUB(IfcTypeProduct);
-    DECL_CONV_STUB(IfcElementType);
-    DECL_CONV_STUB(IfcDistributionElementType);
-    DECL_CONV_STUB(IfcDistributionControlElementType);
-    DECL_CONV_STUB(IfcActuatorType);
-    DECL_CONV_STUB(IfcDistributionFlowElementType);
-    DECL_CONV_STUB(IfcFlowControllerType);
-    DECL_CONV_STUB(IfcAirTerminalBoxType);
-    DECL_CONV_STUB(IfcFlowTerminalType);
-    DECL_CONV_STUB(IfcAirTerminalType);
-    DECL_CONV_STUB(IfcEnergyConversionDeviceType);
-    DECL_CONV_STUB(IfcAirToAirHeatRecoveryType);
-    DECL_CONV_STUB(IfcAlarmType);
-    DECL_CONV_STUB(IfcDraughtingCallout);
-    DECL_CONV_STUB(IfcDimensionCurveDirectedCallout);
-    DECL_CONV_STUB(IfcAngularDimension);
-    DECL_CONV_STUB(IfcProduct);
-    DECL_CONV_STUB(IfcAnnotation);
-    DECL_CONV_STUB(IfcStyledItem);
-    DECL_CONV_STUB(IfcAnnotationOccurrence);
-    DECL_CONV_STUB(IfcAnnotationCurveOccurrence);
-    DECL_CONV_STUB(IfcAnnotationFillArea);
-    DECL_CONV_STUB(IfcAnnotationFillAreaOccurrence);
-    DECL_CONV_STUB(IfcAnnotationSurface);
-    DECL_CONV_STUB(IfcAnnotationSurfaceOccurrence);
-    DECL_CONV_STUB(IfcAnnotationSymbolOccurrence);
-    DECL_CONV_STUB(IfcAnnotationTextOccurrence);
-    DECL_CONV_STUB(IfcProfileDef);
-    DECL_CONV_STUB(IfcArbitraryClosedProfileDef);
-    DECL_CONV_STUB(IfcArbitraryOpenProfileDef);
-    DECL_CONV_STUB(IfcArbitraryProfileDefWithVoids);
-    DECL_CONV_STUB(IfcGroup);
-    DECL_CONV_STUB(IfcAsset);
-    DECL_CONV_STUB(IfcParameterizedProfileDef);
-    DECL_CONV_STUB(IfcIShapeProfileDef);
-    DECL_CONV_STUB(IfcAsymmetricIShapeProfileDef);
-    DECL_CONV_STUB(IfcPlacement);
-    DECL_CONV_STUB(IfcAxis1Placement);
-    DECL_CONV_STUB(IfcAxis2Placement2D);
-    DECL_CONV_STUB(IfcAxis2Placement3D);
-    DECL_CONV_STUB(IfcBSplineCurve);
-    DECL_CONV_STUB(IfcElement);
-    DECL_CONV_STUB(IfcBuildingElement);
-    DECL_CONV_STUB(IfcBeam);
-    DECL_CONV_STUB(IfcBuildingElementType);
-    DECL_CONV_STUB(IfcBeamType);
-    DECL_CONV_STUB(IfcBezierCurve);
-    DECL_CONV_STUB(IfcCsgPrimitive3D);
-    DECL_CONV_STUB(IfcBlock);
-    DECL_CONV_STUB(IfcBoilerType);
-    DECL_CONV_STUB(IfcBooleanResult);
-    DECL_CONV_STUB(IfcBooleanClippingResult);
-    DECL_CONV_STUB(IfcSurface);
-    DECL_CONV_STUB(IfcBoundedSurface);
-    DECL_CONV_STUB(IfcBoundingBox);
-    DECL_CONV_STUB(IfcHalfSpaceSolid);
-    DECL_CONV_STUB(IfcBoxedHalfSpace);
-    DECL_CONV_STUB(IfcSpatialStructureElement);
-    DECL_CONV_STUB(IfcBuilding);
-    DECL_CONV_STUB(IfcBuildingElementComponent);
-    DECL_CONV_STUB(IfcBuildingElementPart);
-    DECL_CONV_STUB(IfcBuildingElementProxy);
-    DECL_CONV_STUB(IfcBuildingElementProxyType);
-    DECL_CONV_STUB(IfcBuildingStorey);
-    DECL_CONV_STUB(IfcCShapeProfileDef);
-    DECL_CONV_STUB(IfcFlowFittingType);
-    DECL_CONV_STUB(IfcCableCarrierFittingType);
-    DECL_CONV_STUB(IfcFlowSegmentType);
-    DECL_CONV_STUB(IfcCableCarrierSegmentType);
-    DECL_CONV_STUB(IfcCableSegmentType);
-    DECL_CONV_STUB(IfcPoint);
-    DECL_CONV_STUB(IfcCartesianPoint);
-    DECL_CONV_STUB(IfcCartesianTransformationOperator);
-    DECL_CONV_STUB(IfcCartesianTransformationOperator2D);
-    DECL_CONV_STUB(IfcCartesianTransformationOperator2DnonUniform);
-    DECL_CONV_STUB(IfcCartesianTransformationOperator3D);
-    DECL_CONV_STUB(IfcCartesianTransformationOperator3DnonUniform);
-    DECL_CONV_STUB(IfcCenterLineProfileDef);
-    DECL_CONV_STUB(IfcFeatureElement);
-    DECL_CONV_STUB(IfcFeatureElementSubtraction);
-    DECL_CONV_STUB(IfcEdgeFeature);
-    DECL_CONV_STUB(IfcChamferEdgeFeature);
-    DECL_CONV_STUB(IfcChillerType);
-    DECL_CONV_STUB(IfcConic);
-    DECL_CONV_STUB(IfcCircle);
-    DECL_CONV_STUB(IfcCircleProfileDef);
-    DECL_CONV_STUB(IfcCircleHollowProfileDef);
-    DECL_CONV_STUB(IfcTopologicalRepresentationItem);
-    DECL_CONV_STUB(IfcConnectedFaceSet);
-    DECL_CONV_STUB(IfcClosedShell);
-    DECL_CONV_STUB(IfcCoilType);
-    DECL_CONV_STUB(IfcColourSpecification);
-    DECL_CONV_STUB(IfcColourRgb);
-    DECL_CONV_STUB(IfcColumn);
-    DECL_CONV_STUB(IfcColumnType);
-    DECL_CONV_STUB(IfcProperty);
-    DECL_CONV_STUB(IfcComplexProperty);
-    DECL_CONV_STUB(IfcCompositeCurveSegment);
-    DECL_CONV_STUB(IfcCompositeProfileDef);
-    DECL_CONV_STUB(IfcFlowMovingDeviceType);
-    DECL_CONV_STUB(IfcCompressorType);
-    DECL_CONV_STUB(IfcCondenserType);
-    DECL_CONV_STUB(IfcCondition);
-    DECL_CONV_STUB(IfcConditionCriterion);
-    DECL_CONV_STUB(IfcResource);
-    DECL_CONV_STUB(IfcConstructionResource);
-    DECL_CONV_STUB(IfcConstructionEquipmentResource);
-    DECL_CONV_STUB(IfcConstructionMaterialResource);
-    DECL_CONV_STUB(IfcConstructionProductResource);
-    DECL_CONV_STUB(IfcNamedUnit);
-    DECL_CONV_STUB(IfcContextDependentUnit);
-    DECL_CONV_STUB(IfcControllerType);
-    DECL_CONV_STUB(IfcConversionBasedUnit);
-    DECL_CONV_STUB(IfcCooledBeamType);
-    DECL_CONV_STUB(IfcCoolingTowerType);
-    DECL_CONV_STUB(IfcCostItem);
-    DECL_CONV_STUB(IfcCostSchedule);
-    DECL_CONV_STUB(IfcCovering);
-    DECL_CONV_STUB(IfcCoveringType);
-    DECL_CONV_STUB(IfcCraneRailAShapeProfileDef);
-    DECL_CONV_STUB(IfcCraneRailFShapeProfileDef);
-    DECL_CONV_STUB(IfcCrewResource);
-    DECL_CONV_STUB(IfcSolidModel);
-    DECL_CONV_STUB(IfcCsgSolid);
-    DECL_CONV_STUB(IfcCurtainWall);
-    DECL_CONV_STUB(IfcCurtainWallType);
-    DECL_CONV_STUB(IfcCurveBoundedPlane);
-    DECL_CONV_STUB(IfcPresentationStyle);
-    DECL_CONV_STUB(IfcDamperType);
-    DECL_CONV_STUB(IfcDefinedSymbol);
-    DECL_CONV_STUB(IfcDerivedProfileDef);
-    DECL_CONV_STUB(IfcDiameterDimension);
-    DECL_CONV_STUB(IfcDimensionCurve);
-    DECL_CONV_STUB(IfcTerminatorSymbol);
-    DECL_CONV_STUB(IfcDimensionCurveTerminator);
-    DECL_CONV_STUB(IfcDirection);
-    DECL_CONV_STUB(IfcElementComponent);
-    DECL_CONV_STUB(IfcDiscreteAccessory);
-    DECL_CONV_STUB(IfcElementComponentType);
-    DECL_CONV_STUB(IfcDiscreteAccessoryType);
-    DECL_CONV_STUB(IfcDistributionElement);
-    DECL_CONV_STUB(IfcDistributionFlowElement);
-    DECL_CONV_STUB(IfcDistributionChamberElement);
-    DECL_CONV_STUB(IfcDistributionChamberElementType);
-    DECL_CONV_STUB(IfcDistributionControlElement);
-    DECL_CONV_STUB(IfcPort);
-    DECL_CONV_STUB(IfcDistributionPort);
-    DECL_CONV_STUB(IfcDoor);
-    DECL_CONV_STUB(IfcPropertyDefinition);
-    DECL_CONV_STUB(IfcPropertySetDefinition);
-    DECL_CONV_STUB(IfcDoorStyle);
-    DECL_CONV_STUB(IfcDuctFittingType);
-    DECL_CONV_STUB(IfcDuctSegmentType);
-    DECL_CONV_STUB(IfcFlowTreatmentDeviceType);
-    DECL_CONV_STUB(IfcDuctSilencerType);
-    DECL_CONV_STUB(IfcEdge);
-    DECL_CONV_STUB(IfcEdgeCurve);
-    DECL_CONV_STUB(IfcLoop);
-    DECL_CONV_STUB(IfcEdgeLoop);
-    DECL_CONV_STUB(IfcElectricApplianceType);
-    DECL_CONV_STUB(IfcFlowController);
-    DECL_CONV_STUB(IfcElectricDistributionPoint);
-    DECL_CONV_STUB(IfcFlowStorageDeviceType);
-    DECL_CONV_STUB(IfcElectricFlowStorageDeviceType);
-    DECL_CONV_STUB(IfcElectricGeneratorType);
-    DECL_CONV_STUB(IfcElectricHeaterType);
-    DECL_CONV_STUB(IfcElectricMotorType);
-    DECL_CONV_STUB(IfcElectricTimeControlType);
-    DECL_CONV_STUB(IfcSystem);
-    DECL_CONV_STUB(IfcElectricalCircuit);
-    DECL_CONV_STUB(IfcElectricalElement);
-    DECL_CONV_STUB(IfcElementAssembly);
-    DECL_CONV_STUB(IfcElementQuantity);
-    DECL_CONV_STUB(IfcElementarySurface);
-    DECL_CONV_STUB(IfcEllipse);
-    DECL_CONV_STUB(IfcEllipseProfileDef);
-    DECL_CONV_STUB(IfcEnergyConversionDevice);
-    DECL_CONV_STUB(IfcEquipmentElement);
-    DECL_CONV_STUB(IfcEquipmentStandard);
-    DECL_CONV_STUB(IfcEvaporativeCoolerType);
-    DECL_CONV_STUB(IfcEvaporatorType);
-    DECL_CONV_STUB(IfcSweptAreaSolid);
-    DECL_CONV_STUB(IfcExtrudedAreaSolid);
-    DECL_CONV_STUB(IfcFace);
-    DECL_CONV_STUB(IfcFaceBasedSurfaceModel);
-    DECL_CONV_STUB(IfcFaceBound);
-    DECL_CONV_STUB(IfcFaceOuterBound);
-    DECL_CONV_STUB(IfcFaceSurface);
-    DECL_CONV_STUB(IfcManifoldSolidBrep);
-    DECL_CONV_STUB(IfcFacetedBrep);
-    DECL_CONV_STUB(IfcFacetedBrepWithVoids);
-    DECL_CONV_STUB(IfcFanType);
-    DECL_CONV_STUB(IfcFastener);
-    DECL_CONV_STUB(IfcFastenerType);
-    DECL_CONV_STUB(IfcFeatureElementAddition);
-    DECL_CONV_STUB(IfcFillAreaStyleHatching);
-    DECL_CONV_STUB(IfcFillAreaStyleTileSymbolWithStyle);
-    DECL_CONV_STUB(IfcFillAreaStyleTiles);
-    DECL_CONV_STUB(IfcFilterType);
-    DECL_CONV_STUB(IfcFireSuppressionTerminalType);
-    DECL_CONV_STUB(IfcFlowFitting);
-    DECL_CONV_STUB(IfcFlowInstrumentType);
-    DECL_CONV_STUB(IfcFlowMeterType);
-    DECL_CONV_STUB(IfcFlowMovingDevice);
-    DECL_CONV_STUB(IfcFlowSegment);
-    DECL_CONV_STUB(IfcFlowStorageDevice);
-    DECL_CONV_STUB(IfcFlowTerminal);
-    DECL_CONV_STUB(IfcFlowTreatmentDevice);
-    DECL_CONV_STUB(IfcFooting);
-    DECL_CONV_STUB(IfcFurnishingElement);
-    DECL_CONV_STUB(IfcFurnishingElementType);
-    DECL_CONV_STUB(IfcFurnitureStandard);
-    DECL_CONV_STUB(IfcFurnitureType);
-    DECL_CONV_STUB(IfcGasTerminalType);
-    DECL_CONV_STUB(IfcGeometricSet);
-    DECL_CONV_STUB(IfcGeometricCurveSet);
-    DECL_CONV_STUB(IfcRepresentationContext);
-    DECL_CONV_STUB(IfcGeometricRepresentationContext);
-    DECL_CONV_STUB(IfcGeometricRepresentationSubContext);
-    DECL_CONV_STUB(IfcGrid);
-    DECL_CONV_STUB(IfcObjectPlacement);
-    DECL_CONV_STUB(IfcGridPlacement);
-    DECL_CONV_STUB(IfcHeatExchangerType);
-    DECL_CONV_STUB(IfcHumidifierType);
-    DECL_CONV_STUB(IfcInventory);
-    DECL_CONV_STUB(IfcJunctionBoxType);
-    DECL_CONV_STUB(IfcLShapeProfileDef);
-    DECL_CONV_STUB(IfcLaborResource);
-    DECL_CONV_STUB(IfcLampType);
-    DECL_CONV_STUB(IfcLightFixtureType);
-    DECL_CONV_STUB(IfcLightSource);
-    DECL_CONV_STUB(IfcLightSourceAmbient);
-    DECL_CONV_STUB(IfcLightSourceDirectional);
-    DECL_CONV_STUB(IfcLightSourceGoniometric);
-    DECL_CONV_STUB(IfcLightSourcePositional);
-    DECL_CONV_STUB(IfcLightSourceSpot);
-    DECL_CONV_STUB(IfcLine);
-    DECL_CONV_STUB(IfcLinearDimension);
-    DECL_CONV_STUB(IfcLocalPlacement);
-    DECL_CONV_STUB(IfcMappedItem);
-    DECL_CONV_STUB(IfcProductRepresentation);
-    DECL_CONV_STUB(IfcMaterialDefinitionRepresentation);
-    DECL_CONV_STUB(IfcMeasureWithUnit);
-    DECL_CONV_STUB(IfcMechanicalFastener);
-    DECL_CONV_STUB(IfcMechanicalFastenerType);
-    DECL_CONV_STUB(IfcMember);
-    DECL_CONV_STUB(IfcMemberType);
-    DECL_CONV_STUB(IfcMotorConnectionType);
-    DECL_CONV_STUB(IfcProcess);
-    DECL_CONV_STUB(IfcTask);
-    DECL_CONV_STUB(IfcMove);
-    DECL_CONV_STUB(IfcOccupant);
-    DECL_CONV_STUB(IfcOffsetCurve2D);
-    DECL_CONV_STUB(IfcOffsetCurve3D);
-    DECL_CONV_STUB(IfcOneDirectionRepeatFactor);
-    DECL_CONV_STUB(IfcOpenShell);
-    DECL_CONV_STUB(IfcOpeningElement);
-    DECL_CONV_STUB(IfcOrderAction);
-    DECL_CONV_STUB(IfcOrientedEdge);
-    DECL_CONV_STUB(IfcOutletType);
-    DECL_CONV_STUB(IfcPath);
-    DECL_CONV_STUB(IfcPerformanceHistory);
-    DECL_CONV_STUB(IfcPermit);
-    DECL_CONV_STUB(IfcPile);
-    DECL_CONV_STUB(IfcPipeFittingType);
-    DECL_CONV_STUB(IfcPipeSegmentType);
-    DECL_CONV_STUB(IfcPlanarExtent);
-    DECL_CONV_STUB(IfcPlanarBox);
-    DECL_CONV_STUB(IfcPlane);
-    DECL_CONV_STUB(IfcPlate);
-    DECL_CONV_STUB(IfcPlateType);
-    DECL_CONV_STUB(IfcPointOnCurve);
-    DECL_CONV_STUB(IfcPointOnSurface);
-    DECL_CONV_STUB(IfcPolyLoop);
-    DECL_CONV_STUB(IfcPolygonalBoundedHalfSpace);
-    DECL_CONV_STUB(IfcPolyline);
-    DECL_CONV_STUB(IfcPresentationStyleAssignment);
-    DECL_CONV_STUB(IfcProcedure);
-    DECL_CONV_STUB(IfcProductDefinitionShape);
-    DECL_CONV_STUB(IfcProject);
-    DECL_CONV_STUB(IfcProjectOrder);
-    DECL_CONV_STUB(IfcProjectOrderRecord);
-    DECL_CONV_STUB(IfcProjectionCurve);
-    DECL_CONV_STUB(IfcProjectionElement);
-    DECL_CONV_STUB(IfcSimpleProperty);
-    DECL_CONV_STUB(IfcPropertyBoundedValue);
-    DECL_CONV_STUB(IfcPropertyEnumeratedValue);
-    DECL_CONV_STUB(IfcPropertyListValue);
-    DECL_CONV_STUB(IfcPropertyReferenceValue);
-    DECL_CONV_STUB(IfcPropertySet);
-    DECL_CONV_STUB(IfcPropertySingleValue);
-    DECL_CONV_STUB(IfcPropertyTableValue);
-    DECL_CONV_STUB(IfcProtectiveDeviceType);
-    DECL_CONV_STUB(IfcProxy);
-    DECL_CONV_STUB(IfcPumpType);
-    DECL_CONV_STUB(IfcRadiusDimension);
-    DECL_CONV_STUB(IfcRailing);
-    DECL_CONV_STUB(IfcRailingType);
-    DECL_CONV_STUB(IfcRamp);
-    DECL_CONV_STUB(IfcRampFlight);
-    DECL_CONV_STUB(IfcRampFlightType);
-    DECL_CONV_STUB(IfcRationalBezierCurve);
-    DECL_CONV_STUB(IfcRectangleProfileDef);
-    DECL_CONV_STUB(IfcRectangleHollowProfileDef);
-    DECL_CONV_STUB(IfcRectangularPyramid);
-    DECL_CONV_STUB(IfcRectangularTrimmedSurface);
-    DECL_CONV_STUB(IfcReinforcingElement);
-    DECL_CONV_STUB(IfcReinforcingBar);
-    DECL_CONV_STUB(IfcReinforcingMesh);
-    DECL_CONV_STUB(IfcRelationship);
-    DECL_CONV_STUB(IfcRelDecomposes);
-    DECL_CONV_STUB(IfcRelAggregates);
-    DECL_CONV_STUB(IfcRelConnects);
-    DECL_CONV_STUB(IfcRelContainedInSpatialStructure);
-    DECL_CONV_STUB(IfcRelDefines);
-    DECL_CONV_STUB(IfcRelDefinesByProperties);
-    DECL_CONV_STUB(IfcRelFillsElement);
-    DECL_CONV_STUB(IfcRelOverridesProperties);
-    DECL_CONV_STUB(IfcRelVoidsElement);
-    DECL_CONV_STUB(IfcRepresentation);
-    DECL_CONV_STUB(IfcRepresentationMap);
-    DECL_CONV_STUB(IfcRevolvedAreaSolid);
-    DECL_CONV_STUB(IfcRightCircularCone);
-    DECL_CONV_STUB(IfcRightCircularCylinder);
-    DECL_CONV_STUB(IfcRoof);
-    DECL_CONV_STUB(IfcRoundedEdgeFeature);
-    DECL_CONV_STUB(IfcRoundedRectangleProfileDef);
-    DECL_CONV_STUB(IfcSIUnit);
-    DECL_CONV_STUB(IfcSanitaryTerminalType);
-    DECL_CONV_STUB(IfcScheduleTimeControl);
-    DECL_CONV_STUB(IfcSectionedSpine);
-    DECL_CONV_STUB(IfcSensorType);
-    DECL_CONV_STUB(IfcServiceLife);
-    DECL_CONV_STUB(IfcShapeModel);
-    DECL_CONV_STUB(IfcShapeRepresentation);
-    DECL_CONV_STUB(IfcShellBasedSurfaceModel);
-    DECL_CONV_STUB(IfcSite);
-    DECL_CONV_STUB(IfcSlab);
-    DECL_CONV_STUB(IfcSlabType);
-    DECL_CONV_STUB(IfcSpace);
-    DECL_CONV_STUB(IfcSpaceHeaterType);
-    DECL_CONV_STUB(IfcSpaceProgram);
-    DECL_CONV_STUB(IfcSpatialStructureElementType);
-    DECL_CONV_STUB(IfcSpaceType);
-    DECL_CONV_STUB(IfcSphere);
-    DECL_CONV_STUB(IfcStackTerminalType);
-    DECL_CONV_STUB(IfcStair);
-    DECL_CONV_STUB(IfcStairFlight);
-    DECL_CONV_STUB(IfcStairFlightType);
-    DECL_CONV_STUB(IfcStructuralActivity);
-    DECL_CONV_STUB(IfcStructuralAction);
-    DECL_CONV_STUB(IfcStructuralAnalysisModel);
-    DECL_CONV_STUB(IfcStructuralItem);
-    DECL_CONV_STUB(IfcStructuralConnection);
-    DECL_CONV_STUB(IfcStructuralCurveConnection);
-    DECL_CONV_STUB(IfcStructuralMember);
-    DECL_CONV_STUB(IfcStructuralCurveMember);
-    DECL_CONV_STUB(IfcStructuralCurveMemberVarying);
-    DECL_CONV_STUB(IfcStructuralLinearAction);
-    DECL_CONV_STUB(IfcStructuralLinearActionVarying);
-    DECL_CONV_STUB(IfcStructuralLoadGroup);
-    DECL_CONV_STUB(IfcStructuralPlanarAction);
-    DECL_CONV_STUB(IfcStructuralPlanarActionVarying);
-    DECL_CONV_STUB(IfcStructuralPointAction);
-    DECL_CONV_STUB(IfcStructuralPointConnection);
-    DECL_CONV_STUB(IfcStructuralReaction);
-    DECL_CONV_STUB(IfcStructuralPointReaction);
-    DECL_CONV_STUB(IfcStructuralResultGroup);
-    DECL_CONV_STUB(IfcStructuralSurfaceConnection);
-    DECL_CONV_STUB(IfcStructuralSurfaceMember);
-    DECL_CONV_STUB(IfcStructuralSurfaceMemberVarying);
-    DECL_CONV_STUB(IfcStructuredDimensionCallout);
-    DECL_CONV_STUB(IfcStyleModel);
-    DECL_CONV_STUB(IfcStyledRepresentation);
-    DECL_CONV_STUB(IfcSubContractResource);
-    DECL_CONV_STUB(IfcSubedge);
-    DECL_CONV_STUB(IfcSurfaceCurveSweptAreaSolid);
-    DECL_CONV_STUB(IfcSweptSurface);
-    DECL_CONV_STUB(IfcSurfaceOfLinearExtrusion);
-    DECL_CONV_STUB(IfcSurfaceOfRevolution);
-    DECL_CONV_STUB(IfcSurfaceStyle);
-    DECL_CONV_STUB(IfcSurfaceStyleShading);
-    DECL_CONV_STUB(IfcSurfaceStyleRendering);
-    DECL_CONV_STUB(IfcSurfaceStyleWithTextures);
-    DECL_CONV_STUB(IfcSweptDiskSolid);
-    DECL_CONV_STUB(IfcSwitchingDeviceType);
-    DECL_CONV_STUB(IfcSystemFurnitureElementType);
-    DECL_CONV_STUB(IfcTShapeProfileDef);
-    DECL_CONV_STUB(IfcTankType);
-    DECL_CONV_STUB(IfcTendon);
-    DECL_CONV_STUB(IfcTendonAnchor);
-    DECL_CONV_STUB(IfcTextLiteral);
-    DECL_CONV_STUB(IfcTextLiteralWithExtent);
-    DECL_CONV_STUB(IfcTimeSeriesSchedule);
-    DECL_CONV_STUB(IfcTopologyRepresentation);
-    DECL_CONV_STUB(IfcTransformerType);
-    DECL_CONV_STUB(IfcTransportElement);
-    DECL_CONV_STUB(IfcTransportElementType);
-    DECL_CONV_STUB(IfcTrapeziumProfileDef);
-    DECL_CONV_STUB(IfcTrimmedCurve);
-    DECL_CONV_STUB(IfcTubeBundleType);
-    DECL_CONV_STUB(IfcTwoDirectionRepeatFactor);
-    DECL_CONV_STUB(IfcUShapeProfileDef);
-    DECL_CONV_STUB(IfcUnitAssignment);
-    DECL_CONV_STUB(IfcUnitaryEquipmentType);
-    DECL_CONV_STUB(IfcValveType);
-    DECL_CONV_STUB(IfcVector);
-    DECL_CONV_STUB(IfcVertex);
-    DECL_CONV_STUB(IfcVertexLoop);
-    DECL_CONV_STUB(IfcVertexPoint);
-    DECL_CONV_STUB(IfcVibrationIsolatorType);
-    DECL_CONV_STUB(IfcVirtualElement);
-    DECL_CONV_STUB(IfcWall);
-    DECL_CONV_STUB(IfcWallStandardCase);
-    DECL_CONV_STUB(IfcWallType);
-    DECL_CONV_STUB(IfcWasteTerminalType);
-    DECL_CONV_STUB(IfcWindow);
-    DECL_CONV_STUB(IfcWindowStyle);
-    DECL_CONV_STUB(IfcWorkControl);
-    DECL_CONV_STUB(IfcWorkPlan);
-    DECL_CONV_STUB(IfcWorkSchedule);
-    DECL_CONV_STUB(IfcZShapeProfileDef);
-    DECL_CONV_STUB(IfcZone);
-
-
-#undef DECL_CONV_STUB
-
-} //! STEP
-} //! Assimp
-
-#ifdef _MSC_VER
-#    pragma warning(pop)
-#endif // _MSC_VER
-
-#endif // INCLUDED_IFC_READER_GEN_H
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.cpp
deleted file mode 100644
index 1793229..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.cpp
+++ /dev/null
@@ -1,6207 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "AssimpPCH.h"
-#include "IFCReaderGen_4.h"
-
-namespace Assimp {
-using namespace IFC;
-using namespace ::Assimp::IFC::Schema_4;
-
-namespace {
-
-	typedef EXPRESS::ConversionSchema::SchemaEntry SchemaEntry;
-	const SchemaEntry schema_raw[] =  {
-		SchemaEntry("ifcstrippedoptional",NULL )
-,		SchemaEntry("ifcabsorbeddosemeasure",NULL )
-,		SchemaEntry("ifcaccelerationmeasure",NULL )
-,		SchemaEntry("ifcamountofsubstancemeasure",NULL )
-,		SchemaEntry("ifcangularvelocitymeasure",NULL )
-,		SchemaEntry("ifcarcindex",NULL )
-,		SchemaEntry("ifcareadensitymeasure",NULL )
-,		SchemaEntry("ifcareameasure",NULL )
-,		SchemaEntry("ifcbinary",NULL )
-,		SchemaEntry("ifcboolean",NULL )
-,		SchemaEntry("ifcboxalignment",NULL )
-,		SchemaEntry("ifccardinalpointreference",NULL )
-,		SchemaEntry("ifccomplexnumber",NULL )
-,		SchemaEntry("ifccompoundplaneanglemeasure",NULL )
-,		SchemaEntry("ifccontextdependentmeasure",NULL )
-,		SchemaEntry("ifccountmeasure",NULL )
-,		SchemaEntry("ifccurvaturemeasure",NULL )
-,		SchemaEntry("ifcdate",NULL )
-,		SchemaEntry("ifcdatetime",NULL )
-,		SchemaEntry("ifcdayinmonthnumber",NULL )
-,		SchemaEntry("ifcdayinweeknumber",NULL )
-,		SchemaEntry("ifcdescriptivemeasure",NULL )
-,		SchemaEntry("ifcdimensioncount",NULL )
-,		SchemaEntry("ifcdoseequivalentmeasure",NULL )
-,		SchemaEntry("ifcduration",NULL )
-,		SchemaEntry("ifcdynamicviscositymeasure",NULL )
-,		SchemaEntry("ifcelectriccapacitancemeasure",NULL )
-,		SchemaEntry("ifcelectricchargemeasure",NULL )
-,		SchemaEntry("ifcelectricconductancemeasure",NULL )
-,		SchemaEntry("ifcelectriccurrentmeasure",NULL )
-,		SchemaEntry("ifcelectricresistancemeasure",NULL )
-,		SchemaEntry("ifcelectricvoltagemeasure",NULL )
-,		SchemaEntry("ifcenergymeasure",NULL )
-,		SchemaEntry("ifcfontstyle",NULL )
-,		SchemaEntry("ifcfontvariant",NULL )
-,		SchemaEntry("ifcfontweight",NULL )
-,		SchemaEntry("ifcforcemeasure",NULL )
-,		SchemaEntry("ifcfrequencymeasure",NULL )
-,		SchemaEntry("ifcgloballyuniqueid",NULL )
-,		SchemaEntry("ifcheatfluxdensitymeasure",NULL )
-,		SchemaEntry("ifcheatingvaluemeasure",NULL )
-,		SchemaEntry("ifcidentifier",NULL )
-,		SchemaEntry("ifcilluminancemeasure",NULL )
-,		SchemaEntry("ifcinductancemeasure",NULL )
-,		SchemaEntry("ifcinteger",NULL )
-,		SchemaEntry("ifcintegercountratemeasure",NULL )
-,		SchemaEntry("ifcionconcentrationmeasure",NULL )
-,		SchemaEntry("ifcisothermalmoisturecapacitymeasure",NULL )
-,		SchemaEntry("ifckinematicviscositymeasure",NULL )
-,		SchemaEntry("ifclabel",NULL )
-,		SchemaEntry("ifclanguageid",NULL )
-,		SchemaEntry("ifclengthmeasure",NULL )
-,		SchemaEntry("ifclineindex",NULL )
-,		SchemaEntry("ifclinearforcemeasure",NULL )
-,		SchemaEntry("ifclinearmomentmeasure",NULL )
-,		SchemaEntry("ifclinearstiffnessmeasure",NULL )
-,		SchemaEntry("ifclinearvelocitymeasure",NULL )
-,		SchemaEntry("ifclogical",NULL )
-,		SchemaEntry("ifcluminousfluxmeasure",NULL )
-,		SchemaEntry("ifcluminousintensitydistributionmeasure",NULL )
-,		SchemaEntry("ifcluminousintensitymeasure",NULL )
-,		SchemaEntry("ifcmagneticfluxdensitymeasure",NULL )
-,		SchemaEntry("ifcmagneticfluxmeasure",NULL )
-,		SchemaEntry("ifcmassdensitymeasure",NULL )
-,		SchemaEntry("ifcmassflowratemeasure",NULL )
-,		SchemaEntry("ifcmassmeasure",NULL )
-,		SchemaEntry("ifcmassperlengthmeasure",NULL )
-,		SchemaEntry("ifcmodulusofelasticitymeasure",NULL )
-,		SchemaEntry("ifcmodulusoflinearsubgradereactionmeasure",NULL )
-,		SchemaEntry("ifcmodulusofrotationalsubgradereactionmeasure",NULL )
-,		SchemaEntry("ifcmodulusofsubgradereactionmeasure",NULL )
-,		SchemaEntry("ifcmoisturediffusivitymeasure",NULL )
-,		SchemaEntry("ifcmolecularweightmeasure",NULL )
-,		SchemaEntry("ifcmomentofinertiameasure",NULL )
-,		SchemaEntry("ifcmonetarymeasure",NULL )
-,		SchemaEntry("ifcmonthinyearnumber",NULL )
-,		SchemaEntry("ifcnonnegativelengthmeasure",NULL )
-,		SchemaEntry("ifcnormalisedratiomeasure",NULL )
-,		SchemaEntry("ifcnumericmeasure",NULL )
-,		SchemaEntry("ifcphmeasure",NULL )
-,		SchemaEntry("ifcparametervalue",NULL )
-,		SchemaEntry("ifcplanarforcemeasure",NULL )
-,		SchemaEntry("ifcplaneanglemeasure",NULL )
-,		SchemaEntry("ifcpositiveinteger",NULL )
-,		SchemaEntry("ifcpositivelengthmeasure",NULL )
-,		SchemaEntry("ifcpositiveplaneanglemeasure",NULL )
-,		SchemaEntry("ifcpositiveratiomeasure",NULL )
-,		SchemaEntry("ifcpowermeasure",NULL )
-,		SchemaEntry("ifcpresentabletext",NULL )
-,		SchemaEntry("ifcpressuremeasure",NULL )
-,		SchemaEntry("ifcpropertysetdefinitionset",NULL )
-,		SchemaEntry("ifcradioactivitymeasure",NULL )
-,		SchemaEntry("ifcratiomeasure",NULL )
-,		SchemaEntry("ifcreal",NULL )
-,		SchemaEntry("ifcrotationalfrequencymeasure",NULL )
-,		SchemaEntry("ifcrotationalmassmeasure",NULL )
-,		SchemaEntry("ifcrotationalstiffnessmeasure",NULL )
-,		SchemaEntry("ifcsectionmodulusmeasure",NULL )
-,		SchemaEntry("ifcsectionalareaintegralmeasure",NULL )
-,		SchemaEntry("ifcshearmodulusmeasure",NULL )
-,		SchemaEntry("ifcsolidanglemeasure",NULL )
-,		SchemaEntry("ifcsoundpowerlevelmeasure",NULL )
-,		SchemaEntry("ifcsoundpowermeasure",NULL )
-,		SchemaEntry("ifcsoundpressurelevelmeasure",NULL )
-,		SchemaEntry("ifcsoundpressuremeasure",NULL )
-,		SchemaEntry("ifcspecificheatcapacitymeasure",NULL )
-,		SchemaEntry("ifcspecularexponent",NULL )
-,		SchemaEntry("ifcspecularroughness",NULL )
-,		SchemaEntry("ifctemperaturegradientmeasure",NULL )
-,		SchemaEntry("ifctemperaturerateofchangemeasure",NULL )
-,		SchemaEntry("ifctext",NULL )
-,		SchemaEntry("ifctextalignment",NULL )
-,		SchemaEntry("ifctextdecoration",NULL )
-,		SchemaEntry("ifctextfontname",NULL )
-,		SchemaEntry("ifctexttransformation",NULL )
-,		SchemaEntry("ifcthermaladmittancemeasure",NULL )
-,		SchemaEntry("ifcthermalconductivitymeasure",NULL )
-,		SchemaEntry("ifcthermalexpansioncoefficientmeasure",NULL )
-,		SchemaEntry("ifcthermalresistancemeasure",NULL )
-,		SchemaEntry("ifcthermaltransmittancemeasure",NULL )
-,		SchemaEntry("ifcthermodynamictemperaturemeasure",NULL )
-,		SchemaEntry("ifctime",NULL )
-,		SchemaEntry("ifctimemeasure",NULL )
-,		SchemaEntry("ifctimestamp",NULL )
-,		SchemaEntry("ifctorquemeasure",NULL )
-,		SchemaEntry("ifcurireference",NULL )
-,		SchemaEntry("ifcvaporpermeabilitymeasure",NULL )
-,		SchemaEntry("ifcvolumemeasure",NULL )
-,		SchemaEntry("ifcvolumetricflowratemeasure",NULL )
-,		SchemaEntry("ifcwarpingconstantmeasure",NULL )
-,		SchemaEntry("ifcwarpingmomentmeasure",NULL )
-,		SchemaEntry("ifcactionrequesttypeenum",NULL )
-,		SchemaEntry("ifcactionsourcetypeenum",NULL )
-,		SchemaEntry("ifcactiontypeenum",NULL )
-,		SchemaEntry("ifcactuatortypeenum",NULL )
-,		SchemaEntry("ifcaddresstypeenum",NULL )
-,		SchemaEntry("ifcairterminalboxtypeenum",NULL )
-,		SchemaEntry("ifcairterminaltypeenum",NULL )
-,		SchemaEntry("ifcairtoairheatrecoverytypeenum",NULL )
-,		SchemaEntry("ifcalarmtypeenum",NULL )
-,		SchemaEntry("ifcanalysismodeltypeenum",NULL )
-,		SchemaEntry("ifcanalysistheorytypeenum",NULL )
-,		SchemaEntry("ifcarithmeticoperatorenum",NULL )
-,		SchemaEntry("ifcassemblyplaceenum",NULL )
-,		SchemaEntry("ifcaudiovisualappliancetypeenum",NULL )
-,		SchemaEntry("ifcbsplinecurveform",NULL )
-,		SchemaEntry("ifcbsplinesurfaceform",NULL )
-,		SchemaEntry("ifcbeamtypeenum",NULL )
-,		SchemaEntry("ifcbenchmarkenum",NULL )
-,		SchemaEntry("ifcboilertypeenum",NULL )
-,		SchemaEntry("ifcbooleanoperator",NULL )
-,		SchemaEntry("ifcbuildingelementparttypeenum",NULL )
-,		SchemaEntry("ifcbuildingelementproxytypeenum",NULL )
-,		SchemaEntry("ifcbuildingsystemtypeenum",NULL )
-,		SchemaEntry("ifcburnertypeenum",NULL )
-,		SchemaEntry("ifccablecarrierfittingtypeenum",NULL )
-,		SchemaEntry("ifccablecarriersegmenttypeenum",NULL )
-,		SchemaEntry("ifccablefittingtypeenum",NULL )
-,		SchemaEntry("ifccablesegmenttypeenum",NULL )
-,		SchemaEntry("ifcchangeactionenum",NULL )
-,		SchemaEntry("ifcchillertypeenum",NULL )
-,		SchemaEntry("ifcchimneytypeenum",NULL )
-,		SchemaEntry("ifccoiltypeenum",NULL )
-,		SchemaEntry("ifccolumntypeenum",NULL )
-,		SchemaEntry("ifccommunicationsappliancetypeenum",NULL )
-,		SchemaEntry("ifccomplexpropertytemplatetypeenum",NULL )
-,		SchemaEntry("ifccompressortypeenum",NULL )
-,		SchemaEntry("ifccondensertypeenum",NULL )
-,		SchemaEntry("ifcconnectiontypeenum",NULL )
-,		SchemaEntry("ifcconstraintenum",NULL )
-,		SchemaEntry("ifcconstructionequipmentresourcetypeenum",NULL )
-,		SchemaEntry("ifcconstructionmaterialresourcetypeenum",NULL )
-,		SchemaEntry("ifcconstructionproductresourcetypeenum",NULL )
-,		SchemaEntry("ifccontrollertypeenum",NULL )
-,		SchemaEntry("ifccooledbeamtypeenum",NULL )
-,		SchemaEntry("ifccoolingtowertypeenum",NULL )
-,		SchemaEntry("ifccostitemtypeenum",NULL )
-,		SchemaEntry("ifccostscheduletypeenum",NULL )
-,		SchemaEntry("ifccoveringtypeenum",NULL )
-,		SchemaEntry("ifccrewresourcetypeenum",NULL )
-,		SchemaEntry("ifccurtainwalltypeenum",NULL )
-,		SchemaEntry("ifccurveinterpolationenum",NULL )
-,		SchemaEntry("ifcdampertypeenum",NULL )
-,		SchemaEntry("ifcdataoriginenum",NULL )
-,		SchemaEntry("ifcderivedunitenum",NULL )
-,		SchemaEntry("ifcdirectionsenseenum",NULL )
-,		SchemaEntry("ifcdiscreteaccessorytypeenum",NULL )
-,		SchemaEntry("ifcdistributionchamberelementtypeenum",NULL )
-,		SchemaEntry("ifcdistributionporttypeenum",NULL )
-,		SchemaEntry("ifcdistributionsystemenum",NULL )
-,		SchemaEntry("ifcdocumentconfidentialityenum",NULL )
-,		SchemaEntry("ifcdocumentstatusenum",NULL )
-,		SchemaEntry("ifcdoorpaneloperationenum",NULL )
-,		SchemaEntry("ifcdoorpanelpositionenum",NULL )
-,		SchemaEntry("ifcdoorstyleconstructionenum",NULL )
-,		SchemaEntry("ifcdoorstyleoperationenum",NULL )
-,		SchemaEntry("ifcdoortypeenum",NULL )
-,		SchemaEntry("ifcdoortypeoperationenum",NULL )
-,		SchemaEntry("ifcductfittingtypeenum",NULL )
-,		SchemaEntry("ifcductsegmenttypeenum",NULL )
-,		SchemaEntry("ifcductsilencertypeenum",NULL )
-,		SchemaEntry("ifcelectricappliancetypeenum",NULL )
-,		SchemaEntry("ifcelectricdistributionboardtypeenum",NULL )
-,		SchemaEntry("ifcelectricflowstoragedevicetypeenum",NULL )
-,		SchemaEntry("ifcelectricgeneratortypeenum",NULL )
-,		SchemaEntry("ifcelectricmotortypeenum",NULL )
-,		SchemaEntry("ifcelectrictimecontroltypeenum",NULL )
-,		SchemaEntry("ifcelementassemblytypeenum",NULL )
-,		SchemaEntry("ifcelementcompositionenum",NULL )
-,		SchemaEntry("ifcenginetypeenum",NULL )
-,		SchemaEntry("ifcevaporativecoolertypeenum",NULL )
-,		SchemaEntry("ifcevaporatortypeenum",NULL )
-,		SchemaEntry("ifceventtriggertypeenum",NULL )
-,		SchemaEntry("ifceventtypeenum",NULL )
-,		SchemaEntry("ifcexternalspatialelementtypeenum",NULL )
-,		SchemaEntry("ifcfantypeenum",NULL )
-,		SchemaEntry("ifcfastenertypeenum",NULL )
-,		SchemaEntry("ifcfiltertypeenum",NULL )
-,		SchemaEntry("ifcfiresuppressionterminaltypeenum",NULL )
-,		SchemaEntry("ifcflowdirectionenum",NULL )
-,		SchemaEntry("ifcflowinstrumenttypeenum",NULL )
-,		SchemaEntry("ifcflowmetertypeenum",NULL )
-,		SchemaEntry("ifcfootingtypeenum",NULL )
-,		SchemaEntry("ifcfurnituretypeenum",NULL )
-,		SchemaEntry("ifcgeographicelementtypeenum",NULL )
-,		SchemaEntry("ifcgeometricprojectionenum",NULL )
-,		SchemaEntry("ifcglobalorlocalenum",NULL )
-,		SchemaEntry("ifcgridtypeenum",NULL )
-,		SchemaEntry("ifcheatexchangertypeenum",NULL )
-,		SchemaEntry("ifchumidifiertypeenum",NULL )
-,		SchemaEntry("ifcinterceptortypeenum",NULL )
-,		SchemaEntry("ifcinternalorexternalenum",NULL )
-,		SchemaEntry("ifcinventorytypeenum",NULL )
-,		SchemaEntry("ifcjunctionboxtypeenum",NULL )
-,		SchemaEntry("ifcknottype",NULL )
-,		SchemaEntry("ifclaborresourcetypeenum",NULL )
-,		SchemaEntry("ifclamptypeenum",NULL )
-,		SchemaEntry("ifclayersetdirectionenum",NULL )
-,		SchemaEntry("ifclightdistributioncurveenum",NULL )
-,		SchemaEntry("ifclightemissionsourceenum",NULL )
-,		SchemaEntry("ifclightfixturetypeenum",NULL )
-,		SchemaEntry("ifcloadgrouptypeenum",NULL )
-,		SchemaEntry("ifclogicaloperatorenum",NULL )
-,		SchemaEntry("ifcmechanicalfastenertypeenum",NULL )
-,		SchemaEntry("ifcmedicaldevicetypeenum",NULL )
-,		SchemaEntry("ifcmembertypeenum",NULL )
-,		SchemaEntry("ifcmotorconnectiontypeenum",NULL )
-,		SchemaEntry("ifcnullstyle",NULL )
-,		SchemaEntry("ifcobjecttypeenum",NULL )
-,		SchemaEntry("ifcobjectiveenum",NULL )
-,		SchemaEntry("ifcoccupanttypeenum",NULL )
-,		SchemaEntry("ifcopeningelementtypeenum",NULL )
-,		SchemaEntry("ifcoutlettypeenum",NULL )
-,		SchemaEntry("ifcperformancehistorytypeenum",NULL )
-,		SchemaEntry("ifcpermeablecoveringoperationenum",NULL )
-,		SchemaEntry("ifcpermittypeenum",NULL )
-,		SchemaEntry("ifcphysicalorvirtualenum",NULL )
-,		SchemaEntry("ifcpileconstructionenum",NULL )
-,		SchemaEntry("ifcpiletypeenum",NULL )
-,		SchemaEntry("ifcpipefittingtypeenum",NULL )
-,		SchemaEntry("ifcpipesegmenttypeenum",NULL )
-,		SchemaEntry("ifcplatetypeenum",NULL )
-,		SchemaEntry("ifcpreferredsurfacecurverepresentation",NULL )
-,		SchemaEntry("ifcproceduretypeenum",NULL )
-,		SchemaEntry("ifcprofiletypeenum",NULL )
-,		SchemaEntry("ifcprojectordertypeenum",NULL )
-,		SchemaEntry("ifcprojectedortruelengthenum",NULL )
-,		SchemaEntry("ifcprojectionelementtypeenum",NULL )
-,		SchemaEntry("ifcpropertysettemplatetypeenum",NULL )
-,		SchemaEntry("ifcprotectivedevicetrippingunittypeenum",NULL )
-,		SchemaEntry("ifcprotectivedevicetypeenum",NULL )
-,		SchemaEntry("ifcpumptypeenum",NULL )
-,		SchemaEntry("ifcrailingtypeenum",NULL )
-,		SchemaEntry("ifcrampflighttypeenum",NULL )
-,		SchemaEntry("ifcramptypeenum",NULL )
-,		SchemaEntry("ifcrecurrencetypeenum",NULL )
-,		SchemaEntry("ifcreflectancemethodenum",NULL )
-,		SchemaEntry("ifcreinforcingbarroleenum",NULL )
-,		SchemaEntry("ifcreinforcingbarsurfaceenum",NULL )
-,		SchemaEntry("ifcreinforcingbartypeenum",NULL )
-,		SchemaEntry("ifcreinforcingmeshtypeenum",NULL )
-,		SchemaEntry("ifcroleenum",NULL )
-,		SchemaEntry("ifcrooftypeenum",NULL )
-,		SchemaEntry("ifcsiprefix",NULL )
-,		SchemaEntry("ifcsiunitname",NULL )
-,		SchemaEntry("ifcsanitaryterminaltypeenum",NULL )
-,		SchemaEntry("ifcsectiontypeenum",NULL )
-,		SchemaEntry("ifcsensortypeenum",NULL )
-,		SchemaEntry("ifcsequenceenum",NULL )
-,		SchemaEntry("ifcshadingdevicetypeenum",NULL )
-,		SchemaEntry("ifcsimplepropertytemplatetypeenum",NULL )
-,		SchemaEntry("ifcslabtypeenum",NULL )
-,		SchemaEntry("ifcsolardevicetypeenum",NULL )
-,		SchemaEntry("ifcspaceheatertypeenum",NULL )
-,		SchemaEntry("ifcspacetypeenum",NULL )
-,		SchemaEntry("ifcspatialzonetypeenum",NULL )
-,		SchemaEntry("ifcstackterminaltypeenum",NULL )
-,		SchemaEntry("ifcstairflighttypeenum",NULL )
-,		SchemaEntry("ifcstairtypeenum",NULL )
-,		SchemaEntry("ifcstateenum",NULL )
-,		SchemaEntry("ifcstructuralcurveactivitytypeenum",NULL )
-,		SchemaEntry("ifcstructuralcurvemembertypeenum",NULL )
-,		SchemaEntry("ifcstructuralsurfaceactivitytypeenum",NULL )
-,		SchemaEntry("ifcstructuralsurfacemembertypeenum",NULL )
-,		SchemaEntry("ifcsubcontractresourcetypeenum",NULL )
-,		SchemaEntry("ifcsurfacefeaturetypeenum",NULL )
-,		SchemaEntry("ifcsurfaceside",NULL )
-,		SchemaEntry("ifcswitchingdevicetypeenum",NULL )
-,		SchemaEntry("ifcsystemfurnitureelementtypeenum",NULL )
-,		SchemaEntry("ifctanktypeenum",NULL )
-,		SchemaEntry("ifctaskdurationenum",NULL )
-,		SchemaEntry("ifctasktypeenum",NULL )
-,		SchemaEntry("ifctendonanchortypeenum",NULL )
-,		SchemaEntry("ifctendontypeenum",NULL )
-,		SchemaEntry("ifctextpath",NULL )
-,		SchemaEntry("ifctimeseriesdatatypeenum",NULL )
-,		SchemaEntry("ifctransformertypeenum",NULL )
-,		SchemaEntry("ifctransitioncode",NULL )
-,		SchemaEntry("ifctransportelementtypeenum",NULL )
-,		SchemaEntry("ifctrimmingpreference",NULL )
-,		SchemaEntry("ifctubebundletypeenum",NULL )
-,		SchemaEntry("ifcunitenum",NULL )
-,		SchemaEntry("ifcunitarycontrolelementtypeenum",NULL )
-,		SchemaEntry("ifcunitaryequipmenttypeenum",NULL )
-,		SchemaEntry("ifcvalvetypeenum",NULL )
-,		SchemaEntry("ifcvibrationisolatortypeenum",NULL )
-,		SchemaEntry("ifcvoidingfeaturetypeenum",NULL )
-,		SchemaEntry("ifcwalltypeenum",NULL )
-,		SchemaEntry("ifcwasteterminaltypeenum",NULL )
-,		SchemaEntry("ifcwindowpaneloperationenum",NULL )
-,		SchemaEntry("ifcwindowpanelpositionenum",NULL )
-,		SchemaEntry("ifcwindowstyleconstructionenum",NULL )
-,		SchemaEntry("ifcwindowstyleoperationenum",NULL )
-,		SchemaEntry("ifcwindowtypeenum",NULL )
-,		SchemaEntry("ifcwindowtypepartitioningenum",NULL )
-,		SchemaEntry("ifcworkcalendartypeenum",NULL )
-,		SchemaEntry("ifcworkplantypeenum",NULL )
-,		SchemaEntry("ifcworkscheduletypeenum",NULL )
-,		SchemaEntry("ifcactorselect",NULL )
-,		SchemaEntry("ifcappliedvalueselect",NULL )
-,		SchemaEntry("ifcaxis2placement",NULL )
-,		SchemaEntry("ifcbendingparameterselect",NULL )
-,		SchemaEntry("ifcbooleanoperand",NULL )
-,		SchemaEntry("ifcclassificationreferenceselect",NULL )
-,		SchemaEntry("ifcclassificationselect",NULL )
-,		SchemaEntry("ifccolour",NULL )
-,		SchemaEntry("ifccolourorfactor",NULL )
-,		SchemaEntry("ifccoordinatereferencesystemselect",NULL )
-,		SchemaEntry("ifccsgselect",NULL )
-,		SchemaEntry("ifccurvefontorscaledcurvefontselect",NULL )
-,		SchemaEntry("ifccurveonsurface",NULL )
-,		SchemaEntry("ifccurveoredgecurve",NULL )
-,		SchemaEntry("ifccurvestylefontselect",NULL )
-,		SchemaEntry("ifcdefinitionselect",NULL )
-,		SchemaEntry("ifcderivedmeasurevalue",NULL )
-,		SchemaEntry("ifcdocumentselect",NULL )
-,		SchemaEntry("ifcfillstyleselect",NULL )
-,		SchemaEntry("ifcgeometricsetselect",NULL )
-,		SchemaEntry("ifcgridplacementdirectionselect",NULL )
-,		SchemaEntry("ifchatchlinedistanceselect",NULL )
-,		SchemaEntry("ifclayereditem",NULL )
-,		SchemaEntry("ifclibraryselect",NULL )
-,		SchemaEntry("ifclightdistributiondatasourceselect",NULL )
-,		SchemaEntry("ifcmaterialselect",NULL )
-,		SchemaEntry("ifcmeasurevalue",NULL )
-,		SchemaEntry("ifcmetricvalueselect",NULL )
-,		SchemaEntry("ifcmodulusofrotationalsubgradereactionselect",NULL )
-,		SchemaEntry("ifcmodulusofsubgradereactionselect",NULL )
-,		SchemaEntry("ifcmodulusoftranslationalsubgradereactionselect",NULL )
-,		SchemaEntry("ifcobjectreferenceselect",NULL )
-,		SchemaEntry("ifcpointorvertexpoint",NULL )
-,		SchemaEntry("ifcpresentationstyleselect",NULL )
-,		SchemaEntry("ifcprocessselect",NULL )
-,		SchemaEntry("ifcproductrepresentationselect",NULL )
-,		SchemaEntry("ifcproductselect",NULL )
-,		SchemaEntry("ifcpropertysetdefinitionselect",NULL )
-,		SchemaEntry("ifcresourceobjectselect",NULL )
-,		SchemaEntry("ifcresourceselect",NULL )
-,		SchemaEntry("ifcrotationalstiffnessselect",NULL )
-,		SchemaEntry("ifcsegmentindexselect",NULL )
-,		SchemaEntry("ifcshell",NULL )
-,		SchemaEntry("ifcsimplevalue",NULL )
-,		SchemaEntry("ifcsizeselect",NULL )
-,		SchemaEntry("ifcsolidorshell",NULL )
-,		SchemaEntry("ifcspaceboundaryselect",NULL )
-,		SchemaEntry("ifcspecularhighlightselect",NULL )
-,		SchemaEntry("ifcstructuralactivityassignmentselect",NULL )
-,		SchemaEntry("ifcstyleassignmentselect",NULL )
-,		SchemaEntry("ifcsurfaceorfacesurface",NULL )
-,		SchemaEntry("ifcsurfacestyleelementselect",NULL )
-,		SchemaEntry("ifctextfontselect",NULL )
-,		SchemaEntry("ifctimeorratioselect",NULL )
-,		SchemaEntry("ifctranslationalstiffnessselect",NULL )
-,		SchemaEntry("ifctrimmingselect",NULL )
-,		SchemaEntry("ifcunit",NULL )
-,		SchemaEntry("ifcvalue",NULL )
-,		SchemaEntry("ifcvectorordirection",NULL )
-,		SchemaEntry("ifcwarpingstiffnessselect",NULL )
-,		SchemaEntry("ifcroot",&STEP::ObjectHelper<IfcRoot,4>::Construct )
-,		SchemaEntry("ifcobjectdefinition",&STEP::ObjectHelper<IfcObjectDefinition,0>::Construct )
-,		SchemaEntry("ifcobject",&STEP::ObjectHelper<IfcObject,1>::Construct )
-,		SchemaEntry("ifccontrol",&STEP::ObjectHelper<IfcControl,1>::Construct )
-,		SchemaEntry("ifcactionrequest",&STEP::ObjectHelper<IfcActionRequest,3>::Construct )
-,		SchemaEntry("ifcactor",&STEP::ObjectHelper<IfcActor,1>::Construct )
-,		SchemaEntry("ifcactorrole",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcproduct",&STEP::ObjectHelper<IfcProduct,2>::Construct )
-,		SchemaEntry("ifcelement",&STEP::ObjectHelper<IfcElement,1>::Construct )
-,		SchemaEntry("ifcdistributionelement",&STEP::ObjectHelper<IfcDistributionElement,0>::Construct )
-,		SchemaEntry("ifcdistributioncontrolelement",&STEP::ObjectHelper<IfcDistributionControlElement,0>::Construct )
-,		SchemaEntry("ifcactuator",&STEP::ObjectHelper<IfcActuator,1>::Construct )
-,		SchemaEntry("ifctypeobject",&STEP::ObjectHelper<IfcTypeObject,2>::Construct )
-,		SchemaEntry("ifctypeproduct",&STEP::ObjectHelper<IfcTypeProduct,2>::Construct )
-,		SchemaEntry("ifcelementtype",&STEP::ObjectHelper<IfcElementType,1>::Construct )
-,		SchemaEntry("ifcdistributionelementtype",&STEP::ObjectHelper<IfcDistributionElementType,0>::Construct )
-,		SchemaEntry("ifcdistributioncontrolelementtype",&STEP::ObjectHelper<IfcDistributionControlElementType,0>::Construct )
-,		SchemaEntry("ifcactuatortype",&STEP::ObjectHelper<IfcActuatorType,1>::Construct )
-,		SchemaEntry("ifcaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrepresentationitem",&STEP::ObjectHelper<IfcRepresentationItem,0>::Construct )
-,		SchemaEntry("ifcgeometricrepresentationitem",&STEP::ObjectHelper<IfcGeometricRepresentationItem,0>::Construct )
-,		SchemaEntry("ifcsolidmodel",&STEP::ObjectHelper<IfcSolidModel,0>::Construct )
-,		SchemaEntry("ifcmanifoldsolidbrep",&STEP::ObjectHelper<IfcManifoldSolidBrep,1>::Construct )
-,		SchemaEntry("ifcadvancedbrep",&STEP::ObjectHelper<IfcAdvancedBrep,0>::Construct )
-,		SchemaEntry("ifcadvancedbrepwithvoids",&STEP::ObjectHelper<IfcAdvancedBrepWithVoids,1>::Construct )
-,		SchemaEntry("ifctopologicalrepresentationitem",&STEP::ObjectHelper<IfcTopologicalRepresentationItem,0>::Construct )
-,		SchemaEntry("ifcface",&STEP::ObjectHelper<IfcFace,1>::Construct )
-,		SchemaEntry("ifcfacesurface",&STEP::ObjectHelper<IfcFaceSurface,2>::Construct )
-,		SchemaEntry("ifcadvancedface",&STEP::ObjectHelper<IfcAdvancedFace,0>::Construct )
-,		SchemaEntry("ifcdistributionflowelement",&STEP::ObjectHelper<IfcDistributionFlowElement,0>::Construct )
-,		SchemaEntry("ifcflowterminal",&STEP::ObjectHelper<IfcFlowTerminal,0>::Construct )
-,		SchemaEntry("ifcairterminal",&STEP::ObjectHelper<IfcAirTerminal,1>::Construct )
-,		SchemaEntry("ifcflowcontroller",&STEP::ObjectHelper<IfcFlowController,0>::Construct )
-,		SchemaEntry("ifcairterminalbox",&STEP::ObjectHelper<IfcAirTerminalBox,1>::Construct )
-,		SchemaEntry("ifcdistributionflowelementtype",&STEP::ObjectHelper<IfcDistributionFlowElementType,0>::Construct )
-,		SchemaEntry("ifcflowcontrollertype",&STEP::ObjectHelper<IfcFlowControllerType,0>::Construct )
-,		SchemaEntry("ifcairterminalboxtype",&STEP::ObjectHelper<IfcAirTerminalBoxType,1>::Construct )
-,		SchemaEntry("ifcflowterminaltype",&STEP::ObjectHelper<IfcFlowTerminalType,0>::Construct )
-,		SchemaEntry("ifcairterminaltype",&STEP::ObjectHelper<IfcAirTerminalType,1>::Construct )
-,		SchemaEntry("ifcenergyconversiondevice",&STEP::ObjectHelper<IfcEnergyConversionDevice,0>::Construct )
-,		SchemaEntry("ifcairtoairheatrecovery",&STEP::ObjectHelper<IfcAirToAirHeatRecovery,1>::Construct )
-,		SchemaEntry("ifcenergyconversiondevicetype",&STEP::ObjectHelper<IfcEnergyConversionDeviceType,0>::Construct )
-,		SchemaEntry("ifcairtoairheatrecoverytype",&STEP::ObjectHelper<IfcAirToAirHeatRecoveryType,1>::Construct )
-,		SchemaEntry("ifcalarm",&STEP::ObjectHelper<IfcAlarm,1>::Construct )
-,		SchemaEntry("ifcalarmtype",&STEP::ObjectHelper<IfcAlarmType,1>::Construct )
-,		SchemaEntry("ifcannotation",&STEP::ObjectHelper<IfcAnnotation,0>::Construct )
-,		SchemaEntry("ifcannotationfillarea",&STEP::ObjectHelper<IfcAnnotationFillArea,2>::Construct )
-,		SchemaEntry("ifcapplication",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcappliedvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcresourcelevelrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcapprovalrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcprofiledef",&STEP::ObjectHelper<IfcProfileDef,2>::Construct )
-,		SchemaEntry("ifcarbitraryclosedprofiledef",&STEP::ObjectHelper<IfcArbitraryClosedProfileDef,1>::Construct )
-,		SchemaEntry("ifcarbitraryopenprofiledef",&STEP::ObjectHelper<IfcArbitraryOpenProfileDef,1>::Construct )
-,		SchemaEntry("ifcarbitraryprofiledefwithvoids",&STEP::ObjectHelper<IfcArbitraryProfileDefWithVoids,1>::Construct )
-,		SchemaEntry("ifcgroup",&STEP::ObjectHelper<IfcGroup,0>::Construct )
-,		SchemaEntry("ifcasset",&STEP::ObjectHelper<IfcAsset,9>::Construct )
-,		SchemaEntry("ifcparameterizedprofiledef",&STEP::ObjectHelper<IfcParameterizedProfileDef,1>::Construct )
-,		SchemaEntry("ifcasymmetricishapeprofiledef",&STEP::ObjectHelper<IfcAsymmetricIShapeProfileDef,12>::Construct )
-,		SchemaEntry("ifcaudiovisualappliance",&STEP::ObjectHelper<IfcAudioVisualAppliance,1>::Construct )
-,		SchemaEntry("ifcaudiovisualappliancetype",&STEP::ObjectHelper<IfcAudioVisualApplianceType,1>::Construct )
-,		SchemaEntry("ifcplacement",&STEP::ObjectHelper<IfcPlacement,1>::Construct )
-,		SchemaEntry("ifcaxis1placement",&STEP::ObjectHelper<IfcAxis1Placement,1>::Construct )
-,		SchemaEntry("ifcaxis2placement2d",&STEP::ObjectHelper<IfcAxis2Placement2D,1>::Construct )
-,		SchemaEntry("ifcaxis2placement3d",&STEP::ObjectHelper<IfcAxis2Placement3D,2>::Construct )
-,		SchemaEntry("ifccurve",&STEP::ObjectHelper<IfcCurve,0>::Construct )
-,		SchemaEntry("ifcboundedcurve",&STEP::ObjectHelper<IfcBoundedCurve,0>::Construct )
-,		SchemaEntry("ifcbsplinecurve",&STEP::ObjectHelper<IfcBSplineCurve,5>::Construct )
-,		SchemaEntry("ifcbsplinecurvewithknots",&STEP::ObjectHelper<IfcBSplineCurveWithKnots,3>::Construct )
-,		SchemaEntry("ifcsurface",&STEP::ObjectHelper<IfcSurface,0>::Construct )
-,		SchemaEntry("ifcboundedsurface",&STEP::ObjectHelper<IfcBoundedSurface,0>::Construct )
-,		SchemaEntry("ifcbsplinesurface",&STEP::ObjectHelper<IfcBSplineSurface,6>::Construct )
-,		SchemaEntry("ifcbsplinesurfacewithknots",&STEP::ObjectHelper<IfcBSplineSurfaceWithKnots,5>::Construct )
-,		SchemaEntry("ifcbuildingelement",&STEP::ObjectHelper<IfcBuildingElement,0>::Construct )
-,		SchemaEntry("ifcbeam",&STEP::ObjectHelper<IfcBeam,1>::Construct )
-,		SchemaEntry("ifcbeamstandardcase",&STEP::ObjectHelper<IfcBeamStandardCase,0>::Construct )
-,		SchemaEntry("ifcbuildingelementtype",&STEP::ObjectHelper<IfcBuildingElementType,0>::Construct )
-,		SchemaEntry("ifcbeamtype",&STEP::ObjectHelper<IfcBeamType,1>::Construct )
-,		SchemaEntry("ifcpresentationitem",&STEP::ObjectHelper<IfcPresentationItem,0>::Construct )
-,		SchemaEntry("ifcsurfacetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcblobtexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccsgprimitive3d",&STEP::ObjectHelper<IfcCsgPrimitive3D,1>::Construct )
-,		SchemaEntry("ifcblock",&STEP::ObjectHelper<IfcBlock,3>::Construct )
-,		SchemaEntry("ifcboiler",&STEP::ObjectHelper<IfcBoiler,1>::Construct )
-,		SchemaEntry("ifcboilertype",&STEP::ObjectHelper<IfcBoilerType,1>::Construct )
-,		SchemaEntry("ifcbooleanresult",&STEP::ObjectHelper<IfcBooleanResult,3>::Construct )
-,		SchemaEntry("ifcbooleanclippingresult",&STEP::ObjectHelper<IfcBooleanClippingResult,0>::Construct )
-,		SchemaEntry("ifcboundarycondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccompositecurve",&STEP::ObjectHelper<IfcCompositeCurve,2>::Construct )
-,		SchemaEntry("ifccompositecurveonsurface",&STEP::ObjectHelper<IfcCompositeCurveOnSurface,0>::Construct )
-,		SchemaEntry("ifcboundarycurve",&STEP::ObjectHelper<IfcBoundaryCurve,0>::Construct )
-,		SchemaEntry("ifcboundaryedgecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboundaryfacecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboundarynodecondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboundarynodeconditionwarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcboundingbox",&STEP::ObjectHelper<IfcBoundingBox,4>::Construct )
-,		SchemaEntry("ifchalfspacesolid",&STEP::ObjectHelper<IfcHalfSpaceSolid,2>::Construct )
-,		SchemaEntry("ifcboxedhalfspace",&STEP::ObjectHelper<IfcBoxedHalfSpace,1>::Construct )
-,		SchemaEntry("ifcspatialelement",&STEP::ObjectHelper<IfcSpatialElement,1>::Construct )
-,		SchemaEntry("ifcspatialstructureelement",&STEP::ObjectHelper<IfcSpatialStructureElement,1>::Construct )
-,		SchemaEntry("ifcbuilding",&STEP::ObjectHelper<IfcBuilding,3>::Construct )
-,		SchemaEntry("ifcelementcomponent",&STEP::ObjectHelper<IfcElementComponent,0>::Construct )
-,		SchemaEntry("ifcbuildingelementpart",&STEP::ObjectHelper<IfcBuildingElementPart,1>::Construct )
-,		SchemaEntry("ifcelementcomponenttype",&STEP::ObjectHelper<IfcElementComponentType,0>::Construct )
-,		SchemaEntry("ifcbuildingelementparttype",&STEP::ObjectHelper<IfcBuildingElementPartType,1>::Construct )
-,		SchemaEntry("ifcbuildingelementproxy",&STEP::ObjectHelper<IfcBuildingElementProxy,1>::Construct )
-,		SchemaEntry("ifcbuildingelementproxytype",&STEP::ObjectHelper<IfcBuildingElementProxyType,1>::Construct )
-,		SchemaEntry("ifcbuildingstorey",&STEP::ObjectHelper<IfcBuildingStorey,1>::Construct )
-,		SchemaEntry("ifcsystem",&STEP::ObjectHelper<IfcSystem,0>::Construct )
-,		SchemaEntry("ifcbuildingsystem",&STEP::ObjectHelper<IfcBuildingSystem,2>::Construct )
-,		SchemaEntry("ifcburner",&STEP::ObjectHelper<IfcBurner,1>::Construct )
-,		SchemaEntry("ifcburnertype",&STEP::ObjectHelper<IfcBurnerType,1>::Construct )
-,		SchemaEntry("ifccshapeprofiledef",&STEP::ObjectHelper<IfcCShapeProfileDef,5>::Construct )
-,		SchemaEntry("ifcflowfitting",&STEP::ObjectHelper<IfcFlowFitting,0>::Construct )
-,		SchemaEntry("ifccablecarrierfitting",&STEP::ObjectHelper<IfcCableCarrierFitting,1>::Construct )
-,		SchemaEntry("ifcflowfittingtype",&STEP::ObjectHelper<IfcFlowFittingType,0>::Construct )
-,		SchemaEntry("ifccablecarrierfittingtype",&STEP::ObjectHelper<IfcCableCarrierFittingType,1>::Construct )
-,		SchemaEntry("ifcflowsegment",&STEP::ObjectHelper<IfcFlowSegment,0>::Construct )
-,		SchemaEntry("ifccablecarriersegment",&STEP::ObjectHelper<IfcCableCarrierSegment,1>::Construct )
-,		SchemaEntry("ifcflowsegmenttype",&STEP::ObjectHelper<IfcFlowSegmentType,0>::Construct )
-,		SchemaEntry("ifccablecarriersegmenttype",&STEP::ObjectHelper<IfcCableCarrierSegmentType,1>::Construct )
-,		SchemaEntry("ifccablefitting",&STEP::ObjectHelper<IfcCableFitting,1>::Construct )
-,		SchemaEntry("ifccablefittingtype",&STEP::ObjectHelper<IfcCableFittingType,1>::Construct )
-,		SchemaEntry("ifccablesegment",&STEP::ObjectHelper<IfcCableSegment,1>::Construct )
-,		SchemaEntry("ifccablesegmenttype",&STEP::ObjectHelper<IfcCableSegmentType,1>::Construct )
-,		SchemaEntry("ifcpoint",&STEP::ObjectHelper<IfcPoint,0>::Construct )
-,		SchemaEntry("ifccartesianpoint",&STEP::ObjectHelper<IfcCartesianPoint,1>::Construct )
-,		SchemaEntry("ifccartesianpointlist",&STEP::ObjectHelper<IfcCartesianPointList,0>::Construct )
-,		SchemaEntry("ifccartesianpointlist2d",&STEP::ObjectHelper<IfcCartesianPointList2D,0>::Construct )
-,		SchemaEntry("ifccartesianpointlist3d",&STEP::ObjectHelper<IfcCartesianPointList3D,0>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator",&STEP::ObjectHelper<IfcCartesianTransformationOperator,4>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator2d",&STEP::ObjectHelper<IfcCartesianTransformationOperator2D,0>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator2dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator3d",&STEP::ObjectHelper<IfcCartesianTransformationOperator3D,1>::Construct )
-,		SchemaEntry("ifccartesiantransformationoperator3dnonuniform",&STEP::ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2>::Construct )
-,		SchemaEntry("ifccenterlineprofiledef",&STEP::ObjectHelper<IfcCenterLineProfileDef,1>::Construct )
-,		SchemaEntry("ifcchiller",&STEP::ObjectHelper<IfcChiller,1>::Construct )
-,		SchemaEntry("ifcchillertype",&STEP::ObjectHelper<IfcChillerType,1>::Construct )
-,		SchemaEntry("ifcchimney",&STEP::ObjectHelper<IfcChimney,1>::Construct )
-,		SchemaEntry("ifcchimneytype",&STEP::ObjectHelper<IfcChimneyType,1>::Construct )
-,		SchemaEntry("ifcconic",&STEP::ObjectHelper<IfcConic,1>::Construct )
-,		SchemaEntry("ifccircle",&STEP::ObjectHelper<IfcCircle,1>::Construct )
-,		SchemaEntry("ifccircleprofiledef",&STEP::ObjectHelper<IfcCircleProfileDef,1>::Construct )
-,		SchemaEntry("ifccirclehollowprofiledef",&STEP::ObjectHelper<IfcCircleHollowProfileDef,1>::Construct )
-,		SchemaEntry("ifccivilelement",&STEP::ObjectHelper<IfcCivilElement,0>::Construct )
-,		SchemaEntry("ifccivilelementtype",&STEP::ObjectHelper<IfcCivilElementType,0>::Construct )
-,		SchemaEntry("ifcexternalinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcexternalreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcclassificationreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectedfaceset",&STEP::ObjectHelper<IfcConnectedFaceSet,1>::Construct )
-,		SchemaEntry("ifcclosedshell",&STEP::ObjectHelper<IfcClosedShell,0>::Construct )
-,		SchemaEntry("ifccoil",&STEP::ObjectHelper<IfcCoil,1>::Construct )
-,		SchemaEntry("ifccoiltype",&STEP::ObjectHelper<IfcCoilType,1>::Construct )
-,		SchemaEntry("ifccolourspecification",&STEP::ObjectHelper<IfcColourSpecification,1>::Construct )
-,		SchemaEntry("ifccolourrgb",&STEP::ObjectHelper<IfcColourRgb,3>::Construct )
-,		SchemaEntry("ifccolourrgblist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccolumn",&STEP::ObjectHelper<IfcColumn,1>::Construct )
-,		SchemaEntry("ifccolumnstandardcase",&STEP::ObjectHelper<IfcColumnStandardCase,0>::Construct )
-,		SchemaEntry("ifccolumntype",&STEP::ObjectHelper<IfcColumnType,1>::Construct )
-,		SchemaEntry("ifccommunicationsappliance",&STEP::ObjectHelper<IfcCommunicationsAppliance,1>::Construct )
-,		SchemaEntry("ifccommunicationsappliancetype",&STEP::ObjectHelper<IfcCommunicationsApplianceType,1>::Construct )
-,		SchemaEntry("ifcpropertyabstraction",&STEP::ObjectHelper<IfcPropertyAbstraction,0>::Construct )
-,		SchemaEntry("ifcproperty",&STEP::ObjectHelper<IfcProperty,2>::Construct )
-,		SchemaEntry("ifccomplexproperty",&STEP::ObjectHelper<IfcComplexProperty,2>::Construct )
-,		SchemaEntry("ifcpropertydefinition",&STEP::ObjectHelper<IfcPropertyDefinition,0>::Construct )
-,		SchemaEntry("ifcpropertytemplatedefinition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccomplexpropertytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccompositecurvesegment",&STEP::ObjectHelper<IfcCompositeCurveSegment,3>::Construct )
-,		SchemaEntry("ifccompositeprofiledef",&STEP::ObjectHelper<IfcCompositeProfileDef,2>::Construct )
-,		SchemaEntry("ifcflowmovingdevice",&STEP::ObjectHelper<IfcFlowMovingDevice,0>::Construct )
-,		SchemaEntry("ifccompressor",&STEP::ObjectHelper<IfcCompressor,1>::Construct )
-,		SchemaEntry("ifcflowmovingdevicetype",&STEP::ObjectHelper<IfcFlowMovingDeviceType,0>::Construct )
-,		SchemaEntry("ifccompressortype",&STEP::ObjectHelper<IfcCompressorType,1>::Construct )
-,		SchemaEntry("ifccondenser",&STEP::ObjectHelper<IfcCondenser,1>::Construct )
-,		SchemaEntry("ifccondensertype",&STEP::ObjectHelper<IfcCondenserType,1>::Construct )
-,		SchemaEntry("ifcconnectiongeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectioncurvegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectionpointgeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectionpointeccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectionsurfacegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconnectionvolumegeometry",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcresource",&STEP::ObjectHelper<IfcResource,2>::Construct )
-,		SchemaEntry("ifcconstructionresource",&STEP::ObjectHelper<IfcConstructionResource,3>::Construct )
-,		SchemaEntry("ifcconstructionequipmentresource",&STEP::ObjectHelper<IfcConstructionEquipmentResource,1>::Construct )
-,		SchemaEntry("ifctyperesource",&STEP::ObjectHelper<IfcTypeResource,3>::Construct )
-,		SchemaEntry("ifcconstructionresourcetype",&STEP::ObjectHelper<IfcConstructionResourceType,2>::Construct )
-,		SchemaEntry("ifcconstructionequipmentresourcetype",&STEP::ObjectHelper<IfcConstructionEquipmentResourceType,1>::Construct )
-,		SchemaEntry("ifcconstructionmaterialresource",&STEP::ObjectHelper<IfcConstructionMaterialResource,1>::Construct )
-,		SchemaEntry("ifcconstructionmaterialresourcetype",&STEP::ObjectHelper<IfcConstructionMaterialResourceType,1>::Construct )
-,		SchemaEntry("ifcconstructionproductresource",&STEP::ObjectHelper<IfcConstructionProductResource,1>::Construct )
-,		SchemaEntry("ifcconstructionproductresourcetype",&STEP::ObjectHelper<IfcConstructionProductResourceType,1>::Construct )
-,		SchemaEntry("ifccontext",&STEP::ObjectHelper<IfcContext,5>::Construct )
-,		SchemaEntry("ifcnamedunit",&STEP::ObjectHelper<IfcNamedUnit,2>::Construct )
-,		SchemaEntry("ifccontextdependentunit",&STEP::ObjectHelper<IfcContextDependentUnit,1>::Construct )
-,		SchemaEntry("ifccontroller",&STEP::ObjectHelper<IfcController,1>::Construct )
-,		SchemaEntry("ifccontrollertype",&STEP::ObjectHelper<IfcControllerType,1>::Construct )
-,		SchemaEntry("ifcconversionbasedunit",&STEP::ObjectHelper<IfcConversionBasedUnit,2>::Construct )
-,		SchemaEntry("ifcconversionbasedunitwithoffset",&STEP::ObjectHelper<IfcConversionBasedUnitWithOffset,1>::Construct )
-,		SchemaEntry("ifccooledbeam",&STEP::ObjectHelper<IfcCooledBeam,1>::Construct )
-,		SchemaEntry("ifccooledbeamtype",&STEP::ObjectHelper<IfcCooledBeamType,1>::Construct )
-,		SchemaEntry("ifccoolingtower",&STEP::ObjectHelper<IfcCoolingTower,1>::Construct )
-,		SchemaEntry("ifccoolingtowertype",&STEP::ObjectHelper<IfcCoolingTowerType,1>::Construct )
-,		SchemaEntry("ifccoordinateoperation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccoordinatereferencesystem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccostitem",&STEP::ObjectHelper<IfcCostItem,3>::Construct )
-,		SchemaEntry("ifccostschedule",&STEP::ObjectHelper<IfcCostSchedule,4>::Construct )
-,		SchemaEntry("ifccostvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccovering",&STEP::ObjectHelper<IfcCovering,1>::Construct )
-,		SchemaEntry("ifccoveringtype",&STEP::ObjectHelper<IfcCoveringType,1>::Construct )
-,		SchemaEntry("ifccrewresource",&STEP::ObjectHelper<IfcCrewResource,1>::Construct )
-,		SchemaEntry("ifccrewresourcetype",&STEP::ObjectHelper<IfcCrewResourceType,1>::Construct )
-,		SchemaEntry("ifccsgsolid",&STEP::ObjectHelper<IfcCsgSolid,1>::Construct )
-,		SchemaEntry("ifccurrencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurtainwall",&STEP::ObjectHelper<IfcCurtainWall,1>::Construct )
-,		SchemaEntry("ifccurtainwalltype",&STEP::ObjectHelper<IfcCurtainWallType,1>::Construct )
-,		SchemaEntry("ifccurveboundedplane",&STEP::ObjectHelper<IfcCurveBoundedPlane,3>::Construct )
-,		SchemaEntry("ifccurveboundedsurface",&STEP::ObjectHelper<IfcCurveBoundedSurface,3>::Construct )
-,		SchemaEntry("ifcpresentationstyle",&STEP::ObjectHelper<IfcPresentationStyle,1>::Construct )
-,		SchemaEntry("ifccurvestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurvestylefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurvestylefontandscaling",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifccurvestylefontpattern",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcelementarysurface",&STEP::ObjectHelper<IfcElementarySurface,1>::Construct )
-,		SchemaEntry("ifccylindricalsurface",&STEP::ObjectHelper<IfcCylindricalSurface,1>::Construct )
-,		SchemaEntry("ifcdamper",&STEP::ObjectHelper<IfcDamper,1>::Construct )
-,		SchemaEntry("ifcdampertype",&STEP::ObjectHelper<IfcDamperType,1>::Construct )
-,		SchemaEntry("ifcderivedprofiledef",&STEP::ObjectHelper<IfcDerivedProfileDef,3>::Construct )
-,		SchemaEntry("ifcderivedunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcderivedunitelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdimensionalexponents",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdirection",&STEP::ObjectHelper<IfcDirection,1>::Construct )
-,		SchemaEntry("ifcdiscreteaccessory",&STEP::ObjectHelper<IfcDiscreteAccessory,1>::Construct )
-,		SchemaEntry("ifcdiscreteaccessorytype",&STEP::ObjectHelper<IfcDiscreteAccessoryType,1>::Construct )
-,		SchemaEntry("ifcdistributionchamberelement",&STEP::ObjectHelper<IfcDistributionChamberElement,1>::Construct )
-,		SchemaEntry("ifcdistributionchamberelementtype",&STEP::ObjectHelper<IfcDistributionChamberElementType,1>::Construct )
-,		SchemaEntry("ifcdistributionsystem",&STEP::ObjectHelper<IfcDistributionSystem,2>::Construct )
-,		SchemaEntry("ifcdistributioncircuit",&STEP::ObjectHelper<IfcDistributionCircuit,0>::Construct )
-,		SchemaEntry("ifcport",&STEP::ObjectHelper<IfcPort,0>::Construct )
-,		SchemaEntry("ifcdistributionport",&STEP::ObjectHelper<IfcDistributionPort,3>::Construct )
-,		SchemaEntry("ifcdocumentinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdocumentinformationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdocumentreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdoor",&STEP::ObjectHelper<IfcDoor,5>::Construct )
-,		SchemaEntry("ifcpropertysetdefinition",&STEP::ObjectHelper<IfcPropertySetDefinition,0>::Construct )
-,		SchemaEntry("ifcpredefinedpropertyset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdoorliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdoorpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdoorstandardcase",&STEP::ObjectHelper<IfcDoorStandardCase,0>::Construct )
-,		SchemaEntry("ifcdoorstyle",&STEP::ObjectHelper<IfcDoorStyle,4>::Construct )
-,		SchemaEntry("ifcdoortype",&STEP::ObjectHelper<IfcDoorType,4>::Construct )
-,		SchemaEntry("ifcpredefineditem",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdraughtingpredefinedcolour",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcdraughtingpredefinedcurvefont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcductfitting",&STEP::ObjectHelper<IfcDuctFitting,1>::Construct )
-,		SchemaEntry("ifcductfittingtype",&STEP::ObjectHelper<IfcDuctFittingType,1>::Construct )
-,		SchemaEntry("ifcductsegment",&STEP::ObjectHelper<IfcDuctSegment,1>::Construct )
-,		SchemaEntry("ifcductsegmenttype",&STEP::ObjectHelper<IfcDuctSegmentType,1>::Construct )
-,		SchemaEntry("ifcflowtreatmentdevice",&STEP::ObjectHelper<IfcFlowTreatmentDevice,0>::Construct )
-,		SchemaEntry("ifcductsilencer",&STEP::ObjectHelper<IfcDuctSilencer,1>::Construct )
-,		SchemaEntry("ifcflowtreatmentdevicetype",&STEP::ObjectHelper<IfcFlowTreatmentDeviceType,0>::Construct )
-,		SchemaEntry("ifcductsilencertype",&STEP::ObjectHelper<IfcDuctSilencerType,1>::Construct )
-,		SchemaEntry("ifcedge",&STEP::ObjectHelper<IfcEdge,2>::Construct )
-,		SchemaEntry("ifcedgecurve",&STEP::ObjectHelper<IfcEdgeCurve,2>::Construct )
-,		SchemaEntry("ifcloop",&STEP::ObjectHelper<IfcLoop,0>::Construct )
-,		SchemaEntry("ifcedgeloop",&STEP::ObjectHelper<IfcEdgeLoop,1>::Construct )
-,		SchemaEntry("ifcelectricappliance",&STEP::ObjectHelper<IfcElectricAppliance,1>::Construct )
-,		SchemaEntry("ifcelectricappliancetype",&STEP::ObjectHelper<IfcElectricApplianceType,1>::Construct )
-,		SchemaEntry("ifcelectricdistributionboard",&STEP::ObjectHelper<IfcElectricDistributionBoard,1>::Construct )
-,		SchemaEntry("ifcelectricdistributionboardtype",&STEP::ObjectHelper<IfcElectricDistributionBoardType,1>::Construct )
-,		SchemaEntry("ifcflowstoragedevice",&STEP::ObjectHelper<IfcFlowStorageDevice,0>::Construct )
-,		SchemaEntry("ifcelectricflowstoragedevice",&STEP::ObjectHelper<IfcElectricFlowStorageDevice,1>::Construct )
-,		SchemaEntry("ifcflowstoragedevicetype",&STEP::ObjectHelper<IfcFlowStorageDeviceType,0>::Construct )
-,		SchemaEntry("ifcelectricflowstoragedevicetype",&STEP::ObjectHelper<IfcElectricFlowStorageDeviceType,1>::Construct )
-,		SchemaEntry("ifcelectricgenerator",&STEP::ObjectHelper<IfcElectricGenerator,1>::Construct )
-,		SchemaEntry("ifcelectricgeneratortype",&STEP::ObjectHelper<IfcElectricGeneratorType,1>::Construct )
-,		SchemaEntry("ifcelectricmotor",&STEP::ObjectHelper<IfcElectricMotor,1>::Construct )
-,		SchemaEntry("ifcelectricmotortype",&STEP::ObjectHelper<IfcElectricMotorType,1>::Construct )
-,		SchemaEntry("ifcelectrictimecontrol",&STEP::ObjectHelper<IfcElectricTimeControl,1>::Construct )
-,		SchemaEntry("ifcelectrictimecontroltype",&STEP::ObjectHelper<IfcElectricTimeControlType,1>::Construct )
-,		SchemaEntry("ifcelementassembly",&STEP::ObjectHelper<IfcElementAssembly,2>::Construct )
-,		SchemaEntry("ifcelementassemblytype",&STEP::ObjectHelper<IfcElementAssemblyType,1>::Construct )
-,		SchemaEntry("ifcquantityset",&STEP::ObjectHelper<IfcQuantitySet,0>::Construct )
-,		SchemaEntry("ifcelementquantity",&STEP::ObjectHelper<IfcElementQuantity,2>::Construct )
-,		SchemaEntry("ifcellipse",&STEP::ObjectHelper<IfcEllipse,2>::Construct )
-,		SchemaEntry("ifcellipseprofiledef",&STEP::ObjectHelper<IfcEllipseProfileDef,2>::Construct )
-,		SchemaEntry("ifcengine",&STEP::ObjectHelper<IfcEngine,1>::Construct )
-,		SchemaEntry("ifcenginetype",&STEP::ObjectHelper<IfcEngineType,1>::Construct )
-,		SchemaEntry("ifcevaporativecooler",&STEP::ObjectHelper<IfcEvaporativeCooler,1>::Construct )
-,		SchemaEntry("ifcevaporativecoolertype",&STEP::ObjectHelper<IfcEvaporativeCoolerType,1>::Construct )
-,		SchemaEntry("ifcevaporator",&STEP::ObjectHelper<IfcEvaporator,1>::Construct )
-,		SchemaEntry("ifcevaporatortype",&STEP::ObjectHelper<IfcEvaporatorType,1>::Construct )
-,		SchemaEntry("ifcprocess",&STEP::ObjectHelper<IfcProcess,2>::Construct )
-,		SchemaEntry("ifcevent",&STEP::ObjectHelper<IfcEvent,4>::Construct )
-,		SchemaEntry("ifcschedulingtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifceventtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctypeprocess",&STEP::ObjectHelper<IfcTypeProcess,3>::Construct )
-,		SchemaEntry("ifceventtype",&STEP::ObjectHelper<IfcEventType,3>::Construct )
-,		SchemaEntry("ifcextendedproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcexternalreferencerelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcexternalspatialstructureelement",&STEP::ObjectHelper<IfcExternalSpatialStructureElement,0>::Construct )
-,		SchemaEntry("ifcexternalspatialelement",&STEP::ObjectHelper<IfcExternalSpatialElement,1>::Construct )
-,		SchemaEntry("ifcexternallydefinedhatchstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcexternallydefinedsurfacestyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcexternallydefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsweptareasolid",&STEP::ObjectHelper<IfcSweptAreaSolid,2>::Construct )
-,		SchemaEntry("ifcextrudedareasolid",&STEP::ObjectHelper<IfcExtrudedAreaSolid,2>::Construct )
-,		SchemaEntry("ifcextrudedareasolidtapered",&STEP::ObjectHelper<IfcExtrudedAreaSolidTapered,1>::Construct )
-,		SchemaEntry("ifcfacebasedsurfacemodel",&STEP::ObjectHelper<IfcFaceBasedSurfaceModel,1>::Construct )
-,		SchemaEntry("ifcfacebound",&STEP::ObjectHelper<IfcFaceBound,2>::Construct )
-,		SchemaEntry("ifcfaceouterbound",&STEP::ObjectHelper<IfcFaceOuterBound,0>::Construct )
-,		SchemaEntry("ifcfacetedbrep",&STEP::ObjectHelper<IfcFacetedBrep,0>::Construct )
-,		SchemaEntry("ifcfacetedbrepwithvoids",&STEP::ObjectHelper<IfcFacetedBrepWithVoids,1>::Construct )
-,		SchemaEntry("ifcstructuralconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfailureconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfan",&STEP::ObjectHelper<IfcFan,1>::Construct )
-,		SchemaEntry("ifcfantype",&STEP::ObjectHelper<IfcFanType,1>::Construct )
-,		SchemaEntry("ifcfastener",&STEP::ObjectHelper<IfcFastener,1>::Construct )
-,		SchemaEntry("ifcfastenertype",&STEP::ObjectHelper<IfcFastenerType,1>::Construct )
-,		SchemaEntry("ifcfeatureelement",&STEP::ObjectHelper<IfcFeatureElement,0>::Construct )
-,		SchemaEntry("ifcfeatureelementaddition",&STEP::ObjectHelper<IfcFeatureElementAddition,0>::Construct )
-,		SchemaEntry("ifcfeatureelementsubtraction",&STEP::ObjectHelper<IfcFeatureElementSubtraction,0>::Construct )
-,		SchemaEntry("ifcfillareastyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcfillareastylehatching",&STEP::ObjectHelper<IfcFillAreaStyleHatching,5>::Construct )
-,		SchemaEntry("ifcfillareastyletiles",&STEP::ObjectHelper<IfcFillAreaStyleTiles,3>::Construct )
-,		SchemaEntry("ifcfilter",&STEP::ObjectHelper<IfcFilter,1>::Construct )
-,		SchemaEntry("ifcfiltertype",&STEP::ObjectHelper<IfcFilterType,1>::Construct )
-,		SchemaEntry("ifcfiresuppressionterminal",&STEP::ObjectHelper<IfcFireSuppressionTerminal,1>::Construct )
-,		SchemaEntry("ifcfiresuppressionterminaltype",&STEP::ObjectHelper<IfcFireSuppressionTerminalType,1>::Construct )
-,		SchemaEntry("ifcfixedreferencesweptareasolid",&STEP::ObjectHelper<IfcFixedReferenceSweptAreaSolid,4>::Construct )
-,		SchemaEntry("ifcflowinstrument",&STEP::ObjectHelper<IfcFlowInstrument,1>::Construct )
-,		SchemaEntry("ifcflowinstrumenttype",&STEP::ObjectHelper<IfcFlowInstrumentType,1>::Construct )
-,		SchemaEntry("ifcflowmeter",&STEP::ObjectHelper<IfcFlowMeter,1>::Construct )
-,		SchemaEntry("ifcflowmetertype",&STEP::ObjectHelper<IfcFlowMeterType,1>::Construct )
-,		SchemaEntry("ifcfooting",&STEP::ObjectHelper<IfcFooting,1>::Construct )
-,		SchemaEntry("ifcfootingtype",&STEP::ObjectHelper<IfcFootingType,1>::Construct )
-,		SchemaEntry("ifcfurnishingelement",&STEP::ObjectHelper<IfcFurnishingElement,0>::Construct )
-,		SchemaEntry("ifcfurnishingelementtype",&STEP::ObjectHelper<IfcFurnishingElementType,0>::Construct )
-,		SchemaEntry("ifcfurniture",&STEP::ObjectHelper<IfcFurniture,1>::Construct )
-,		SchemaEntry("ifcfurnituretype",&STEP::ObjectHelper<IfcFurnitureType,2>::Construct )
-,		SchemaEntry("ifcgeographicelement",&STEP::ObjectHelper<IfcGeographicElement,1>::Construct )
-,		SchemaEntry("ifcgeographicelementtype",&STEP::ObjectHelper<IfcGeographicElementType,1>::Construct )
-,		SchemaEntry("ifcgeometricset",&STEP::ObjectHelper<IfcGeometricSet,1>::Construct )
-,		SchemaEntry("ifcgeometriccurveset",&STEP::ObjectHelper<IfcGeometricCurveSet,0>::Construct )
-,		SchemaEntry("ifcrepresentationcontext",&STEP::ObjectHelper<IfcRepresentationContext,2>::Construct )
-,		SchemaEntry("ifcgeometricrepresentationcontext",&STEP::ObjectHelper<IfcGeometricRepresentationContext,4>::Construct )
-,		SchemaEntry("ifcgeometricrepresentationsubcontext",&STEP::ObjectHelper<IfcGeometricRepresentationSubContext,4>::Construct )
-,		SchemaEntry("ifcgrid",&STEP::ObjectHelper<IfcGrid,4>::Construct )
-,		SchemaEntry("ifcgridaxis",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcobjectplacement",&STEP::ObjectHelper<IfcObjectPlacement,0>::Construct )
-,		SchemaEntry("ifcgridplacement",&STEP::ObjectHelper<IfcGridPlacement,2>::Construct )
-,		SchemaEntry("ifcheatexchanger",&STEP::ObjectHelper<IfcHeatExchanger,1>::Construct )
-,		SchemaEntry("ifcheatexchangertype",&STEP::ObjectHelper<IfcHeatExchangerType,1>::Construct )
-,		SchemaEntry("ifchumidifier",&STEP::ObjectHelper<IfcHumidifier,1>::Construct )
-,		SchemaEntry("ifchumidifiertype",&STEP::ObjectHelper<IfcHumidifierType,1>::Construct )
-,		SchemaEntry("ifcishapeprofiledef",&STEP::ObjectHelper<IfcIShapeProfileDef,7>::Construct )
-,		SchemaEntry("ifcimagetexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcindexedcolourmap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcindexedpolycurve",&STEP::ObjectHelper<IfcIndexedPolyCurve,3>::Construct )
-,		SchemaEntry("ifctessellateditem",&STEP::ObjectHelper<IfcTessellatedItem,0>::Construct )
-,		SchemaEntry("ifcindexedpolygonalface",&STEP::ObjectHelper<IfcIndexedPolygonalFace,1>::Construct )
-,		SchemaEntry("ifcindexedpolygonalfacewithvoids",&STEP::ObjectHelper<IfcIndexedPolygonalFaceWithVoids,0>::Construct )
-,		SchemaEntry("ifctexturecoordinate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcindexedtexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcindexedtriangletexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcinterceptor",&STEP::ObjectHelper<IfcInterceptor,1>::Construct )
-,		SchemaEntry("ifcinterceptortype",&STEP::ObjectHelper<IfcInterceptorType,1>::Construct )
-,		SchemaEntry("ifcsurfacecurve",&STEP::ObjectHelper<IfcSurfaceCurve,3>::Construct )
-,		SchemaEntry("ifcintersectioncurve",&STEP::ObjectHelper<IfcIntersectionCurve,0>::Construct )
-,		SchemaEntry("ifcinventory",&STEP::ObjectHelper<IfcInventory,6>::Construct )
-,		SchemaEntry("ifctimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcirregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcirregulartimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcjunctionbox",&STEP::ObjectHelper<IfcJunctionBox,1>::Construct )
-,		SchemaEntry("ifcjunctionboxtype",&STEP::ObjectHelper<IfcJunctionBoxType,1>::Construct )
-,		SchemaEntry("ifclshapeprofiledef",&STEP::ObjectHelper<IfcLShapeProfileDef,6>::Construct )
-,		SchemaEntry("ifclaborresource",&STEP::ObjectHelper<IfcLaborResource,1>::Construct )
-,		SchemaEntry("ifclaborresourcetype",&STEP::ObjectHelper<IfcLaborResourceType,1>::Construct )
-,		SchemaEntry("ifclagtime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclamp",&STEP::ObjectHelper<IfcLamp,1>::Construct )
-,		SchemaEntry("ifclamptype",&STEP::ObjectHelper<IfcLampType,1>::Construct )
-,		SchemaEntry("ifclibraryinformation",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclibraryreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclightdistributiondata",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclightfixture",&STEP::ObjectHelper<IfcLightFixture,1>::Construct )
-,		SchemaEntry("ifclightfixturetype",&STEP::ObjectHelper<IfcLightFixtureType,1>::Construct )
-,		SchemaEntry("ifclightintensitydistribution",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifclightsource",&STEP::ObjectHelper<IfcLightSource,4>::Construct )
-,		SchemaEntry("ifclightsourceambient",&STEP::ObjectHelper<IfcLightSourceAmbient,0>::Construct )
-,		SchemaEntry("ifclightsourcedirectional",&STEP::ObjectHelper<IfcLightSourceDirectional,1>::Construct )
-,		SchemaEntry("ifclightsourcegoniometric",&STEP::ObjectHelper<IfcLightSourceGoniometric,6>::Construct )
-,		SchemaEntry("ifclightsourcepositional",&STEP::ObjectHelper<IfcLightSourcePositional,5>::Construct )
-,		SchemaEntry("ifclightsourcespot",&STEP::ObjectHelper<IfcLightSourceSpot,4>::Construct )
-,		SchemaEntry("ifcline",&STEP::ObjectHelper<IfcLine,2>::Construct )
-,		SchemaEntry("ifclocalplacement",&STEP::ObjectHelper<IfcLocalPlacement,2>::Construct )
-,		SchemaEntry("ifcmapconversion",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmappeditem",&STEP::ObjectHelper<IfcMappedItem,2>::Construct )
-,		SchemaEntry("ifcmaterialdefinition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialclassificationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialconstituent",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialconstituentset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcproductrepresentation",&STEP::ObjectHelper<IfcProductRepresentation,3>::Construct )
-,		SchemaEntry("ifcmaterialdefinitionrepresentation",&STEP::ObjectHelper<IfcMaterialDefinitionRepresentation,1>::Construct )
-,		SchemaEntry("ifcmateriallayer",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmateriallayerset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialusagedefinition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmateriallayersetusage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmateriallayerwithoffsets",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmateriallist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialprofile",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialprofileset",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialprofilesetusage",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialprofilesetusagetapering",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialprofilewithoffsets",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmaterialrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmeasurewithunit",&STEP::ObjectHelper<IfcMeasureWithUnit,2>::Construct )
-,		SchemaEntry("ifcmechanicalfastener",&STEP::ObjectHelper<IfcMechanicalFastener,3>::Construct )
-,		SchemaEntry("ifcmechanicalfastenertype",&STEP::ObjectHelper<IfcMechanicalFastenerType,3>::Construct )
-,		SchemaEntry("ifcmedicaldevice",&STEP::ObjectHelper<IfcMedicalDevice,1>::Construct )
-,		SchemaEntry("ifcmedicaldevicetype",&STEP::ObjectHelper<IfcMedicalDeviceType,1>::Construct )
-,		SchemaEntry("ifcmember",&STEP::ObjectHelper<IfcMember,1>::Construct )
-,		SchemaEntry("ifcmemberstandardcase",&STEP::ObjectHelper<IfcMemberStandardCase,0>::Construct )
-,		SchemaEntry("ifcmembertype",&STEP::ObjectHelper<IfcMemberType,1>::Construct )
-,		SchemaEntry("ifcmetric",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmirroredprofiledef",&STEP::ObjectHelper<IfcMirroredProfileDef,0>::Construct )
-,		SchemaEntry("ifcmonetaryunit",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcmotorconnection",&STEP::ObjectHelper<IfcMotorConnection,1>::Construct )
-,		SchemaEntry("ifcmotorconnectiontype",&STEP::ObjectHelper<IfcMotorConnectionType,1>::Construct )
-,		SchemaEntry("ifcobjective",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcoccupant",&STEP::ObjectHelper<IfcOccupant,1>::Construct )
-,		SchemaEntry("ifcoffsetcurve2d",&STEP::ObjectHelper<IfcOffsetCurve2D,3>::Construct )
-,		SchemaEntry("ifcoffsetcurve3d",&STEP::ObjectHelper<IfcOffsetCurve3D,4>::Construct )
-,		SchemaEntry("ifcopenshell",&STEP::ObjectHelper<IfcOpenShell,0>::Construct )
-,		SchemaEntry("ifcopeningelement",&STEP::ObjectHelper<IfcOpeningElement,1>::Construct )
-,		SchemaEntry("ifcopeningstandardcase",&STEP::ObjectHelper<IfcOpeningStandardCase,0>::Construct )
-,		SchemaEntry("ifcorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcorganizationrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcorientededge",&STEP::ObjectHelper<IfcOrientedEdge,2>::Construct )
-,		SchemaEntry("ifcouterboundarycurve",&STEP::ObjectHelper<IfcOuterBoundaryCurve,0>::Construct )
-,		SchemaEntry("ifcoutlet",&STEP::ObjectHelper<IfcOutlet,1>::Construct )
-,		SchemaEntry("ifcoutlettype",&STEP::ObjectHelper<IfcOutletType,1>::Construct )
-,		SchemaEntry("ifcownerhistory",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpath",&STEP::ObjectHelper<IfcPath,1>::Construct )
-,		SchemaEntry("ifcpcurve",&STEP::ObjectHelper<IfcPcurve,2>::Construct )
-,		SchemaEntry("ifcperformancehistory",&STEP::ObjectHelper<IfcPerformanceHistory,2>::Construct )
-,		SchemaEntry("ifcpermeablecoveringproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpermit",&STEP::ObjectHelper<IfcPermit,3>::Construct )
-,		SchemaEntry("ifcperson",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpersonandorganization",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcphysicalquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcphysicalcomplexquantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcphysicalsimplequantity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpile",&STEP::ObjectHelper<IfcPile,2>::Construct )
-,		SchemaEntry("ifcpiletype",&STEP::ObjectHelper<IfcPileType,1>::Construct )
-,		SchemaEntry("ifcpipefitting",&STEP::ObjectHelper<IfcPipeFitting,1>::Construct )
-,		SchemaEntry("ifcpipefittingtype",&STEP::ObjectHelper<IfcPipeFittingType,1>::Construct )
-,		SchemaEntry("ifcpipesegment",&STEP::ObjectHelper<IfcPipeSegment,1>::Construct )
-,		SchemaEntry("ifcpipesegmenttype",&STEP::ObjectHelper<IfcPipeSegmentType,1>::Construct )
-,		SchemaEntry("ifcpixeltexture",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcplanarextent",&STEP::ObjectHelper<IfcPlanarExtent,2>::Construct )
-,		SchemaEntry("ifcplanarbox",&STEP::ObjectHelper<IfcPlanarBox,1>::Construct )
-,		SchemaEntry("ifcplane",&STEP::ObjectHelper<IfcPlane,0>::Construct )
-,		SchemaEntry("ifcplate",&STEP::ObjectHelper<IfcPlate,1>::Construct )
-,		SchemaEntry("ifcplatestandardcase",&STEP::ObjectHelper<IfcPlateStandardCase,0>::Construct )
-,		SchemaEntry("ifcplatetype",&STEP::ObjectHelper<IfcPlateType,1>::Construct )
-,		SchemaEntry("ifcpointoncurve",&STEP::ObjectHelper<IfcPointOnCurve,2>::Construct )
-,		SchemaEntry("ifcpointonsurface",&STEP::ObjectHelper<IfcPointOnSurface,3>::Construct )
-,		SchemaEntry("ifcpolyloop",&STEP::ObjectHelper<IfcPolyLoop,1>::Construct )
-,		SchemaEntry("ifcpolygonalboundedhalfspace",&STEP::ObjectHelper<IfcPolygonalBoundedHalfSpace,2>::Construct )
-,		SchemaEntry("ifctessellatedfaceset",&STEP::ObjectHelper<IfcTessellatedFaceSet,1>::Construct )
-,		SchemaEntry("ifcpolygonalfaceset",&STEP::ObjectHelper<IfcPolygonalFaceSet,3>::Construct )
-,		SchemaEntry("ifcpolyline",&STEP::ObjectHelper<IfcPolyline,1>::Construct )
-,		SchemaEntry("ifcpostaladdress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpredefinedtextfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpresentationlayerassignment",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpresentationlayerwithstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpresentationstyleassignment",&STEP::ObjectHelper<IfcPresentationStyleAssignment,1>::Construct )
-,		SchemaEntry("ifcprocedure",&STEP::ObjectHelper<IfcProcedure,1>::Construct )
-,		SchemaEntry("ifcproceduretype",&STEP::ObjectHelper<IfcProcedureType,1>::Construct )
-,		SchemaEntry("ifcproductdefinitionshape",&STEP::ObjectHelper<IfcProductDefinitionShape,0>::Construct )
-,		SchemaEntry("ifcprofileproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcproject",&STEP::ObjectHelper<IfcProject,0>::Construct )
-,		SchemaEntry("ifcprojectlibrary",&STEP::ObjectHelper<IfcProjectLibrary,0>::Construct )
-,		SchemaEntry("ifcprojectorder",&STEP::ObjectHelper<IfcProjectOrder,3>::Construct )
-,		SchemaEntry("ifcprojectedcrs",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcprojectionelement",&STEP::ObjectHelper<IfcProjectionElement,1>::Construct )
-,		SchemaEntry("ifcsimpleproperty",&STEP::ObjectHelper<IfcSimpleProperty,0>::Construct )
-,		SchemaEntry("ifcpropertyboundedvalue",&STEP::ObjectHelper<IfcPropertyBoundedValue,4>::Construct )
-,		SchemaEntry("ifcpropertydependencyrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertyenumeratedvalue",&STEP::ObjectHelper<IfcPropertyEnumeratedValue,2>::Construct )
-,		SchemaEntry("ifcpropertyenumeration",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertylistvalue",&STEP::ObjectHelper<IfcPropertyListValue,2>::Construct )
-,		SchemaEntry("ifcpropertyreferencevalue",&STEP::ObjectHelper<IfcPropertyReferenceValue,2>::Construct )
-,		SchemaEntry("ifcpropertyset",&STEP::ObjectHelper<IfcPropertySet,1>::Construct )
-,		SchemaEntry("ifcpropertysettemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcpropertysinglevalue",&STEP::ObjectHelper<IfcPropertySingleValue,2>::Construct )
-,		SchemaEntry("ifcpropertytablevalue",&STEP::ObjectHelper<IfcPropertyTableValue,6>::Construct )
-,		SchemaEntry("ifcprotectivedevice",&STEP::ObjectHelper<IfcProtectiveDevice,1>::Construct )
-,		SchemaEntry("ifcprotectivedevicetrippingunit",&STEP::ObjectHelper<IfcProtectiveDeviceTrippingUnit,1>::Construct )
-,		SchemaEntry("ifcprotectivedevicetrippingunittype",&STEP::ObjectHelper<IfcProtectiveDeviceTrippingUnitType,1>::Construct )
-,		SchemaEntry("ifcprotectivedevicetype",&STEP::ObjectHelper<IfcProtectiveDeviceType,1>::Construct )
-,		SchemaEntry("ifcproxy",&STEP::ObjectHelper<IfcProxy,2>::Construct )
-,		SchemaEntry("ifcpump",&STEP::ObjectHelper<IfcPump,1>::Construct )
-,		SchemaEntry("ifcpumptype",&STEP::ObjectHelper<IfcPumpType,1>::Construct )
-,		SchemaEntry("ifcquantityarea",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantitycount",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantitylength",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantitytime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantityvolume",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcquantityweight",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrailing",&STEP::ObjectHelper<IfcRailing,1>::Construct )
-,		SchemaEntry("ifcrailingtype",&STEP::ObjectHelper<IfcRailingType,1>::Construct )
-,		SchemaEntry("ifcramp",&STEP::ObjectHelper<IfcRamp,1>::Construct )
-,		SchemaEntry("ifcrampflight",&STEP::ObjectHelper<IfcRampFlight,1>::Construct )
-,		SchemaEntry("ifcrampflighttype",&STEP::ObjectHelper<IfcRampFlightType,1>::Construct )
-,		SchemaEntry("ifcramptype",&STEP::ObjectHelper<IfcRampType,1>::Construct )
-,		SchemaEntry("ifcrationalbsplinecurvewithknots",&STEP::ObjectHelper<IfcRationalBSplineCurveWithKnots,1>::Construct )
-,		SchemaEntry("ifcrationalbsplinesurfacewithknots",&STEP::ObjectHelper<IfcRationalBSplineSurfaceWithKnots,0>::Construct )
-,		SchemaEntry("ifcrectangleprofiledef",&STEP::ObjectHelper<IfcRectangleProfileDef,2>::Construct )
-,		SchemaEntry("ifcrectanglehollowprofiledef",&STEP::ObjectHelper<IfcRectangleHollowProfileDef,3>::Construct )
-,		SchemaEntry("ifcrectangularpyramid",&STEP::ObjectHelper<IfcRectangularPyramid,3>::Construct )
-,		SchemaEntry("ifcrectangulartrimmedsurface",&STEP::ObjectHelper<IfcRectangularTrimmedSurface,7>::Construct )
-,		SchemaEntry("ifcrecurrencepattern",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreference",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcregulartimeseries",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreinforcementbarproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreinforcementdefinitionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreinforcingelement",&STEP::ObjectHelper<IfcReinforcingElement,1>::Construct )
-,		SchemaEntry("ifcreinforcingbar",&STEP::ObjectHelper<IfcReinforcingBar,5>::Construct )
-,		SchemaEntry("ifcreinforcingelementtype",&STEP::ObjectHelper<IfcReinforcingElementType,0>::Construct )
-,		SchemaEntry("ifcreinforcingbartype",&STEP::ObjectHelper<IfcReinforcingBarType,7>::Construct )
-,		SchemaEntry("ifcreinforcingmesh",&STEP::ObjectHelper<IfcReinforcingMesh,9>::Construct )
-,		SchemaEntry("ifcreinforcingmeshtype",&STEP::ObjectHelper<IfcReinforcingMeshType,11>::Construct )
-,		SchemaEntry("ifcrelationship",&STEP::ObjectHelper<IfcRelationship,0>::Construct )
-,		SchemaEntry("ifcreldecomposes",&STEP::ObjectHelper<IfcRelDecomposes,0>::Construct )
-,		SchemaEntry("ifcrelaggregates",&STEP::ObjectHelper<IfcRelAggregates,2>::Construct )
-,		SchemaEntry("ifcrelassigns",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstoactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstocontrol",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstogroup",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstogroupbyfactor",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstoprocess",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstoproduct",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassignstoresource",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociates",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesapproval",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesclassification",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesconstraint",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesdocument",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociateslibrary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelassociatesmaterial",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnects",&STEP::ObjectHelper<IfcRelConnects,0>::Construct )
-,		SchemaEntry("ifcrelconnectselements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectspathelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectsporttoelement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectsports",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectsstructuralactivity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectsstructuralmember",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectswitheccentricity",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelconnectswithrealizingelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelcontainedinspatialstructure",&STEP::ObjectHelper<IfcRelContainedInSpatialStructure,2>::Construct )
-,		SchemaEntry("ifcrelcoversbldgelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelcoversspaces",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreldeclares",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreldefines",&STEP::ObjectHelper<IfcRelDefines,0>::Construct )
-,		SchemaEntry("ifcreldefinesbyobject",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreldefinesbyproperties",&STEP::ObjectHelper<IfcRelDefinesByProperties,2>::Construct )
-,		SchemaEntry("ifcreldefinesbytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcreldefinesbytype",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelfillselement",&STEP::ObjectHelper<IfcRelFillsElement,2>::Construct )
-,		SchemaEntry("ifcrelflowcontrolelements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelinterfereselements",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelnests",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelprojectselement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelreferencedinspatialstructure",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelsequence",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelservicesbuildings",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelspaceboundary",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelspaceboundary1stlevel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelspaceboundary2ndlevel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrelvoidselement",&STEP::ObjectHelper<IfcRelVoidsElement,2>::Construct )
-,		SchemaEntry("ifcreparametrisedcompositecurvesegment",&STEP::ObjectHelper<IfcReparametrisedCompositeCurveSegment,1>::Construct )
-,		SchemaEntry("ifcrepresentation",&STEP::ObjectHelper<IfcRepresentation,4>::Construct )
-,		SchemaEntry("ifcrepresentationmap",&STEP::ObjectHelper<IfcRepresentationMap,2>::Construct )
-,		SchemaEntry("ifcresourceapprovalrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcresourceconstraintrelationship",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcresourcetime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcrevolvedareasolid",&STEP::ObjectHelper<IfcRevolvedAreaSolid,2>::Construct )
-,		SchemaEntry("ifcrevolvedareasolidtapered",&STEP::ObjectHelper<IfcRevolvedAreaSolidTapered,1>::Construct )
-,		SchemaEntry("ifcrightcircularcone",&STEP::ObjectHelper<IfcRightCircularCone,2>::Construct )
-,		SchemaEntry("ifcrightcircularcylinder",&STEP::ObjectHelper<IfcRightCircularCylinder,2>::Construct )
-,		SchemaEntry("ifcroof",&STEP::ObjectHelper<IfcRoof,1>::Construct )
-,		SchemaEntry("ifcrooftype",&STEP::ObjectHelper<IfcRoofType,1>::Construct )
-,		SchemaEntry("ifcroundedrectangleprofiledef",&STEP::ObjectHelper<IfcRoundedRectangleProfileDef,1>::Construct )
-,		SchemaEntry("ifcsiunit",&STEP::ObjectHelper<IfcSIUnit,2>::Construct )
-,		SchemaEntry("ifcsanitaryterminal",&STEP::ObjectHelper<IfcSanitaryTerminal,1>::Construct )
-,		SchemaEntry("ifcsanitaryterminaltype",&STEP::ObjectHelper<IfcSanitaryTerminalType,1>::Construct )
-,		SchemaEntry("ifcseamcurve",&STEP::ObjectHelper<IfcSeamCurve,0>::Construct )
-,		SchemaEntry("ifcsectionproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsectionreinforcementproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsectionedspine",&STEP::ObjectHelper<IfcSectionedSpine,3>::Construct )
-,		SchemaEntry("ifcsensor",&STEP::ObjectHelper<IfcSensor,1>::Construct )
-,		SchemaEntry("ifcsensortype",&STEP::ObjectHelper<IfcSensorType,1>::Construct )
-,		SchemaEntry("ifcshadingdevice",&STEP::ObjectHelper<IfcShadingDevice,1>::Construct )
-,		SchemaEntry("ifcshadingdevicetype",&STEP::ObjectHelper<IfcShadingDeviceType,1>::Construct )
-,		SchemaEntry("ifcshapeaspect",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcshapemodel",&STEP::ObjectHelper<IfcShapeModel,0>::Construct )
-,		SchemaEntry("ifcshaperepresentation",&STEP::ObjectHelper<IfcShapeRepresentation,0>::Construct )
-,		SchemaEntry("ifcshellbasedsurfacemodel",&STEP::ObjectHelper<IfcShellBasedSurfaceModel,1>::Construct )
-,		SchemaEntry("ifcsimplepropertytemplate",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsite",&STEP::ObjectHelper<IfcSite,5>::Construct )
-,		SchemaEntry("ifcslab",&STEP::ObjectHelper<IfcSlab,1>::Construct )
-,		SchemaEntry("ifcslabelementedcase",&STEP::ObjectHelper<IfcSlabElementedCase,0>::Construct )
-,		SchemaEntry("ifcslabstandardcase",&STEP::ObjectHelper<IfcSlabStandardCase,0>::Construct )
-,		SchemaEntry("ifcslabtype",&STEP::ObjectHelper<IfcSlabType,1>::Construct )
-,		SchemaEntry("ifcslippageconnectioncondition",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsolardevice",&STEP::ObjectHelper<IfcSolarDevice,1>::Construct )
-,		SchemaEntry("ifcsolardevicetype",&STEP::ObjectHelper<IfcSolarDeviceType,1>::Construct )
-,		SchemaEntry("ifcspace",&STEP::ObjectHelper<IfcSpace,2>::Construct )
-,		SchemaEntry("ifcspaceheater",&STEP::ObjectHelper<IfcSpaceHeater,1>::Construct )
-,		SchemaEntry("ifcspaceheatertype",&STEP::ObjectHelper<IfcSpaceHeaterType,1>::Construct )
-,		SchemaEntry("ifcspatialelementtype",&STEP::ObjectHelper<IfcSpatialElementType,1>::Construct )
-,		SchemaEntry("ifcspatialstructureelementtype",&STEP::ObjectHelper<IfcSpatialStructureElementType,0>::Construct )
-,		SchemaEntry("ifcspacetype",&STEP::ObjectHelper<IfcSpaceType,2>::Construct )
-,		SchemaEntry("ifcspatialzone",&STEP::ObjectHelper<IfcSpatialZone,1>::Construct )
-,		SchemaEntry("ifcspatialzonetype",&STEP::ObjectHelper<IfcSpatialZoneType,2>::Construct )
-,		SchemaEntry("ifcsphere",&STEP::ObjectHelper<IfcSphere,1>::Construct )
-,		SchemaEntry("ifcsphericalsurface",&STEP::ObjectHelper<IfcSphericalSurface,1>::Construct )
-,		SchemaEntry("ifcstackterminal",&STEP::ObjectHelper<IfcStackTerminal,1>::Construct )
-,		SchemaEntry("ifcstackterminaltype",&STEP::ObjectHelper<IfcStackTerminalType,1>::Construct )
-,		SchemaEntry("ifcstair",&STEP::ObjectHelper<IfcStair,1>::Construct )
-,		SchemaEntry("ifcstairflight",&STEP::ObjectHelper<IfcStairFlight,5>::Construct )
-,		SchemaEntry("ifcstairflighttype",&STEP::ObjectHelper<IfcStairFlightType,1>::Construct )
-,		SchemaEntry("ifcstairtype",&STEP::ObjectHelper<IfcStairType,1>::Construct )
-,		SchemaEntry("ifcstructuralactivity",&STEP::ObjectHelper<IfcStructuralActivity,2>::Construct )
-,		SchemaEntry("ifcstructuralaction",&STEP::ObjectHelper<IfcStructuralAction,1>::Construct )
-,		SchemaEntry("ifcstructuralanalysismodel",&STEP::ObjectHelper<IfcStructuralAnalysisModel,5>::Construct )
-,		SchemaEntry("ifcstructuralitem",&STEP::ObjectHelper<IfcStructuralItem,0>::Construct )
-,		SchemaEntry("ifcstructuralconnection",&STEP::ObjectHelper<IfcStructuralConnection,1>::Construct )
-,		SchemaEntry("ifcstructuralcurveaction",&STEP::ObjectHelper<IfcStructuralCurveAction,2>::Construct )
-,		SchemaEntry("ifcstructuralcurveconnection",&STEP::ObjectHelper<IfcStructuralCurveConnection,1>::Construct )
-,		SchemaEntry("ifcstructuralmember",&STEP::ObjectHelper<IfcStructuralMember,0>::Construct )
-,		SchemaEntry("ifcstructuralcurvemember",&STEP::ObjectHelper<IfcStructuralCurveMember,2>::Construct )
-,		SchemaEntry("ifcstructuralcurvemembervarying",&STEP::ObjectHelper<IfcStructuralCurveMemberVarying,0>::Construct )
-,		SchemaEntry("ifcstructuralreaction",&STEP::ObjectHelper<IfcStructuralReaction,0>::Construct )
-,		SchemaEntry("ifcstructuralcurvereaction",&STEP::ObjectHelper<IfcStructuralCurveReaction,1>::Construct )
-,		SchemaEntry("ifcstructurallinearaction",&STEP::ObjectHelper<IfcStructuralLinearAction,0>::Construct )
-,		SchemaEntry("ifcstructuralload",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadgroup",&STEP::ObjectHelper<IfcStructuralLoadGroup,5>::Construct )
-,		SchemaEntry("ifcstructuralloadcase",&STEP::ObjectHelper<IfcStructuralLoadCase,1>::Construct )
-,		SchemaEntry("ifcstructuralloadconfiguration",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadorresult",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadstatic",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadlinearforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadplanarforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingledisplacement",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingledisplacementdistortion",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingleforce",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadsingleforcewarping",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralloadtemperature",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcstructuralsurfaceaction",&STEP::ObjectHelper<IfcStructuralSurfaceAction,2>::Construct )
-,		SchemaEntry("ifcstructuralplanaraction",&STEP::ObjectHelper<IfcStructuralPlanarAction,0>::Construct )
-,		SchemaEntry("ifcstructuralpointaction",&STEP::ObjectHelper<IfcStructuralPointAction,0>::Construct )
-,		SchemaEntry("ifcstructuralpointconnection",&STEP::ObjectHelper<IfcStructuralPointConnection,1>::Construct )
-,		SchemaEntry("ifcstructuralpointreaction",&STEP::ObjectHelper<IfcStructuralPointReaction,0>::Construct )
-,		SchemaEntry("ifcstructuralresultgroup",&STEP::ObjectHelper<IfcStructuralResultGroup,3>::Construct )
-,		SchemaEntry("ifcstructuralsurfaceconnection",&STEP::ObjectHelper<IfcStructuralSurfaceConnection,0>::Construct )
-,		SchemaEntry("ifcstructuralsurfacemember",&STEP::ObjectHelper<IfcStructuralSurfaceMember,2>::Construct )
-,		SchemaEntry("ifcstructuralsurfacemembervarying",&STEP::ObjectHelper<IfcStructuralSurfaceMemberVarying,0>::Construct )
-,		SchemaEntry("ifcstructuralsurfacereaction",&STEP::ObjectHelper<IfcStructuralSurfaceReaction,1>::Construct )
-,		SchemaEntry("ifcstylemodel",&STEP::ObjectHelper<IfcStyleModel,0>::Construct )
-,		SchemaEntry("ifcstyleditem",&STEP::ObjectHelper<IfcStyledItem,3>::Construct )
-,		SchemaEntry("ifcstyledrepresentation",&STEP::ObjectHelper<IfcStyledRepresentation,0>::Construct )
-,		SchemaEntry("ifcsubcontractresource",&STEP::ObjectHelper<IfcSubContractResource,1>::Construct )
-,		SchemaEntry("ifcsubcontractresourcetype",&STEP::ObjectHelper<IfcSubContractResourceType,1>::Construct )
-,		SchemaEntry("ifcsubedge",&STEP::ObjectHelper<IfcSubedge,1>::Construct )
-,		SchemaEntry("ifcsurfacecurvesweptareasolid",&STEP::ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4>::Construct )
-,		SchemaEntry("ifcsurfacefeature",&STEP::ObjectHelper<IfcSurfaceFeature,1>::Construct )
-,		SchemaEntry("ifcsweptsurface",&STEP::ObjectHelper<IfcSweptSurface,2>::Construct )
-,		SchemaEntry("ifcsurfaceoflinearextrusion",&STEP::ObjectHelper<IfcSurfaceOfLinearExtrusion,2>::Construct )
-,		SchemaEntry("ifcsurfaceofrevolution",&STEP::ObjectHelper<IfcSurfaceOfRevolution,1>::Construct )
-,		SchemaEntry("ifcsurfacereinforcementarea",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacestyle",&STEP::ObjectHelper<IfcSurfaceStyle,2>::Construct )
-,		SchemaEntry("ifcsurfacestylelighting",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacestylerefraction",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcsurfacestyleshading",&STEP::ObjectHelper<IfcSurfaceStyleShading,2>::Construct )
-,		SchemaEntry("ifcsurfacestylerendering",&STEP::ObjectHelper<IfcSurfaceStyleRendering,7>::Construct )
-,		SchemaEntry("ifcsurfacestylewithtextures",&STEP::ObjectHelper<IfcSurfaceStyleWithTextures,1>::Construct )
-,		SchemaEntry("ifcsweptdisksolid",&STEP::ObjectHelper<IfcSweptDiskSolid,5>::Construct )
-,		SchemaEntry("ifcsweptdisksolidpolygonal",&STEP::ObjectHelper<IfcSweptDiskSolidPolygonal,1>::Construct )
-,		SchemaEntry("ifcswitchingdevice",&STEP::ObjectHelper<IfcSwitchingDevice,1>::Construct )
-,		SchemaEntry("ifcswitchingdevicetype",&STEP::ObjectHelper<IfcSwitchingDeviceType,1>::Construct )
-,		SchemaEntry("ifcsystemfurnitureelement",&STEP::ObjectHelper<IfcSystemFurnitureElement,1>::Construct )
-,		SchemaEntry("ifcsystemfurnitureelementtype",&STEP::ObjectHelper<IfcSystemFurnitureElementType,1>::Construct )
-,		SchemaEntry("ifctshapeprofiledef",&STEP::ObjectHelper<IfcTShapeProfileDef,9>::Construct )
-,		SchemaEntry("ifctable",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctablecolumn",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctablerow",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctank",&STEP::ObjectHelper<IfcTank,1>::Construct )
-,		SchemaEntry("ifctanktype",&STEP::ObjectHelper<IfcTankType,1>::Construct )
-,		SchemaEntry("ifctask",&STEP::ObjectHelper<IfcTask,6>::Construct )
-,		SchemaEntry("ifctasktime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctasktimerecurring",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctasktype",&STEP::ObjectHelper<IfcTaskType,2>::Construct )
-,		SchemaEntry("ifctelecomaddress",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctendon",&STEP::ObjectHelper<IfcTendon,8>::Construct )
-,		SchemaEntry("ifctendonanchor",&STEP::ObjectHelper<IfcTendonAnchor,1>::Construct )
-,		SchemaEntry("ifctendonanchortype",&STEP::ObjectHelper<IfcTendonAnchorType,1>::Construct )
-,		SchemaEntry("ifctendontype",&STEP::ObjectHelper<IfcTendonType,4>::Construct )
-,		SchemaEntry("ifctextliteral",&STEP::ObjectHelper<IfcTextLiteral,3>::Construct )
-,		SchemaEntry("ifctextliteralwithextent",&STEP::ObjectHelper<IfcTextLiteralWithExtent,2>::Construct )
-,		SchemaEntry("ifctextstyle",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctextstylefontmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctextstylefordefinedfont",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctextstyletextmodel",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctexturecoordinategenerator",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctexturemap",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctexturevertex",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctexturevertexlist",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctimeperiod",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctimeseriesvalue",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifctopologyrepresentation",&STEP::ObjectHelper<IfcTopologyRepresentation,0>::Construct )
-,		SchemaEntry("ifctoroidalsurface",&STEP::ObjectHelper<IfcToroidalSurface,2>::Construct )
-,		SchemaEntry("ifctransformer",&STEP::ObjectHelper<IfcTransformer,1>::Construct )
-,		SchemaEntry("ifctransformertype",&STEP::ObjectHelper<IfcTransformerType,1>::Construct )
-,		SchemaEntry("ifctransportelement",&STEP::ObjectHelper<IfcTransportElement,1>::Construct )
-,		SchemaEntry("ifctransportelementtype",&STEP::ObjectHelper<IfcTransportElementType,1>::Construct )
-,		SchemaEntry("ifctrapeziumprofiledef",&STEP::ObjectHelper<IfcTrapeziumProfileDef,4>::Construct )
-,		SchemaEntry("ifctriangulatedfaceset",&STEP::ObjectHelper<IfcTriangulatedFaceSet,2>::Construct )
-,		SchemaEntry("ifctrimmedcurve",&STEP::ObjectHelper<IfcTrimmedCurve,5>::Construct )
-,		SchemaEntry("ifctubebundle",&STEP::ObjectHelper<IfcTubeBundle,1>::Construct )
-,		SchemaEntry("ifctubebundletype",&STEP::ObjectHelper<IfcTubeBundleType,1>::Construct )
-,		SchemaEntry("ifcushapeprofiledef",&STEP::ObjectHelper<IfcUShapeProfileDef,7>::Construct )
-,		SchemaEntry("ifcunitassignment",&STEP::ObjectHelper<IfcUnitAssignment,1>::Construct )
-,		SchemaEntry("ifcunitarycontrolelement",&STEP::ObjectHelper<IfcUnitaryControlElement,1>::Construct )
-,		SchemaEntry("ifcunitarycontrolelementtype",&STEP::ObjectHelper<IfcUnitaryControlElementType,1>::Construct )
-,		SchemaEntry("ifcunitaryequipment",&STEP::ObjectHelper<IfcUnitaryEquipment,1>::Construct )
-,		SchemaEntry("ifcunitaryequipmenttype",&STEP::ObjectHelper<IfcUnitaryEquipmentType,1>::Construct )
-,		SchemaEntry("ifcvalve",&STEP::ObjectHelper<IfcValve,1>::Construct )
-,		SchemaEntry("ifcvalvetype",&STEP::ObjectHelper<IfcValveType,1>::Construct )
-,		SchemaEntry("ifcvector",&STEP::ObjectHelper<IfcVector,2>::Construct )
-,		SchemaEntry("ifcvertex",&STEP::ObjectHelper<IfcVertex,0>::Construct )
-,		SchemaEntry("ifcvertexloop",&STEP::ObjectHelper<IfcVertexLoop,1>::Construct )
-,		SchemaEntry("ifcvertexpoint",&STEP::ObjectHelper<IfcVertexPoint,1>::Construct )
-,		SchemaEntry("ifcvibrationisolator",&STEP::ObjectHelper<IfcVibrationIsolator,1>::Construct )
-,		SchemaEntry("ifcvibrationisolatortype",&STEP::ObjectHelper<IfcVibrationIsolatorType,1>::Construct )
-,		SchemaEntry("ifcvirtualelement",&STEP::ObjectHelper<IfcVirtualElement,0>::Construct )
-,		SchemaEntry("ifcvirtualgridintersection",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcvoidingfeature",&STEP::ObjectHelper<IfcVoidingFeature,1>::Construct )
-,		SchemaEntry("ifcwall",&STEP::ObjectHelper<IfcWall,1>::Construct )
-,		SchemaEntry("ifcwallelementedcase",&STEP::ObjectHelper<IfcWallElementedCase,0>::Construct )
-,		SchemaEntry("ifcwallstandardcase",&STEP::ObjectHelper<IfcWallStandardCase,0>::Construct )
-,		SchemaEntry("ifcwalltype",&STEP::ObjectHelper<IfcWallType,1>::Construct )
-,		SchemaEntry("ifcwasteterminal",&STEP::ObjectHelper<IfcWasteTerminal,1>::Construct )
-,		SchemaEntry("ifcwasteterminaltype",&STEP::ObjectHelper<IfcWasteTerminalType,1>::Construct )
-,		SchemaEntry("ifcwindow",&STEP::ObjectHelper<IfcWindow,5>::Construct )
-,		SchemaEntry("ifcwindowliningproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwindowpanelproperties",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifcwindowstandardcase",&STEP::ObjectHelper<IfcWindowStandardCase,0>::Construct )
-,		SchemaEntry("ifcwindowstyle",&STEP::ObjectHelper<IfcWindowStyle,4>::Construct )
-,		SchemaEntry("ifcwindowtype",&STEP::ObjectHelper<IfcWindowType,4>::Construct )
-,		SchemaEntry("ifcworkcalendar",&STEP::ObjectHelper<IfcWorkCalendar,3>::Construct )
-,		SchemaEntry("ifcworkcontrol",&STEP::ObjectHelper<IfcWorkControl,7>::Construct )
-,		SchemaEntry("ifcworkplan",&STEP::ObjectHelper<IfcWorkPlan,1>::Construct )
-,		SchemaEntry("ifcworkschedule",&STEP::ObjectHelper<IfcWorkSchedule,1>::Construct )
-,		SchemaEntry("ifcworktime",&STEP::ObjectHelper<NotImplemented,0>::Construct )
-,		SchemaEntry("ifczshapeprofiledef",&STEP::ObjectHelper<IfcZShapeProfileDef,6>::Construct )
-,		SchemaEntry("ifczone",&STEP::ObjectHelper<IfcZone,1>::Construct )
-
-	};
-}
-
-// -----------------------------------------------------------------------------------------------------------
-void IFC::GetSchema(EXPRESS::ConversionSchema& out)
-{
-	out = EXPRESS::ConversionSchema(schema_raw);
-}
-
-namespace STEP {
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<NotImplemented>(const STEP::DB& db, const LIST& params, NotImplemented* in)
-{
-	return 0;
-}
-
-
-
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoot>(const DB& db, const LIST& params, IfcRoot* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRoot"); }    do { // convert the 'GlobalId' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->GlobalId, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRoot to be a `IfcGloballyUniqueId`")); }
-    } while(0);
-    do { // convert the 'OwnerHistory' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OwnerHistory, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRoot to be a `IfcOwnerHistory`")); }
-    } while(0);
-    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRoot to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Description' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRoot,4>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRoot to be a `IfcText`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcObjectDefinition>(const DB& db, const LIST& params, IfcObjectDefinition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcObjectDefinition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcObject>(const DB& db, const LIST& params, IfcObject* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcObject"); }    do { // convert the 'ObjectType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcObject,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcObject to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcControl>(const DB& db, const LIST& params, IfcControl* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActionRequest>(const DB& db, const LIST& params, IfcActionRequest* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActor>(const DB& db, const LIST& params, IfcActor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProduct>(const DB& db, const LIST& params, IfcProduct* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcProduct"); }    do { // convert the 'ObjectPlacement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectPlacement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcProduct to be a `IfcObjectPlacement`")); }
-    } while(0);
-    do { // convert the 'Representation' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProduct,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Representation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcProduct to be a `IfcProductRepresentation`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElement>(const DB& db, const LIST& params, IfcElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcElement"); }    do { // convert the 'Tag' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElement,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Tag, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcElement to be a `IfcIdentifier`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionElement>(const DB& db, const LIST& params, IfcDistributionElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionControlElement>(const DB& db, const LIST& params, IfcDistributionControlElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActuator>(const DB& db, const LIST& params, IfcActuator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTypeObject>(const DB& db, const LIST& params, IfcTypeObject* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTypeProduct>(const DB& db, const LIST& params, IfcTypeProduct* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementType>(const DB& db, const LIST& params, IfcElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionElementType>(const DB& db, const LIST& params, IfcDistributionElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionControlElementType>(const DB& db, const LIST& params, IfcDistributionControlElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcActuatorType>(const DB& db, const LIST& params, IfcActuatorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentationItem>(const DB& db, const LIST& params, IfcRepresentationItem* in)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricRepresentationItem>(const DB& db, const LIST& params, IfcGeometricRepresentationItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSolidModel>(const DB& db, const LIST& params, IfcSolidModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcManifoldSolidBrep>(const DB& db, const LIST& params, IfcManifoldSolidBrep* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcManifoldSolidBrep"); }    do { // convert the 'Outer' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcManifoldSolidBrep,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Outer, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcManifoldSolidBrep to be a `IfcClosedShell`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAdvancedBrep>(const DB& db, const LIST& params, IfcAdvancedBrep* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAdvancedBrepWithVoids>(const DB& db, const LIST& params, IfcAdvancedBrepWithVoids* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcAdvancedBrep*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTopologicalRepresentationItem>(const DB& db, const LIST& params, IfcTopologicalRepresentationItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); }    do { // convert the 'Bounds' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFace,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bounds, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceSurface>(const DB& db, const LIST& params, IfcFaceSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFace*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAdvancedFace>(const DB& db, const LIST& params, IfcAdvancedFace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFaceSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionFlowElement>(const DB& db, const LIST& params, IfcDistributionFlowElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTerminal>(const DB& db, const LIST& params, IfcFlowTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirTerminal>(const DB& db, const LIST& params, IfcAirTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowController>(const DB& db, const LIST& params, IfcFlowController* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirTerminalBox>(const DB& db, const LIST& params, IfcAirTerminalBox* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionFlowElementType>(const DB& db, const LIST& params, IfcDistributionFlowElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowControllerType>(const DB& db, const LIST& params, IfcFlowControllerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirTerminalBoxType>(const DB& db, const LIST& params, IfcAirTerminalBoxType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTerminalType>(const DB& db, const LIST& params, IfcFlowTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirTerminalType>(const DB& db, const LIST& params, IfcAirTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEnergyConversionDevice>(const DB& db, const LIST& params, IfcEnergyConversionDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirToAirHeatRecovery>(const DB& db, const LIST& params, IfcAirToAirHeatRecovery* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEnergyConversionDeviceType>(const DB& db, const LIST& params, IfcEnergyConversionDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAirToAirHeatRecoveryType>(const DB& db, const LIST& params, IfcAirToAirHeatRecoveryType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAlarm>(const DB& db, const LIST& params, IfcAlarm* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAlarmType>(const DB& db, const LIST& params, IfcAlarmType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotation>(const DB& db, const LIST& params, IfcAnnotation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcAnnotation"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAnnotationFillArea>(const DB& db, const LIST& params, IfcAnnotationFillArea* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProfileDef>(const DB& db, const LIST& params, IfcProfileDef* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProfileDef"); }    do { // convert the 'ProfileType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ProfileType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProfileDef to be a `IfcProfileTypeEnum`")); }
-    } while(0);
-    do { // convert the 'ProfileName' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProfileDef,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ProfileName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProfileDef to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcArbitraryClosedProfileDef>(const DB& db, const LIST& params, IfcArbitraryClosedProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryClosedProfileDef"); }    do { // convert the 'OuterCurve' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryClosedProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->OuterCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryClosedProfileDef to be a `IfcCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcArbitraryOpenProfileDef>(const DB& db, const LIST& params, IfcArbitraryOpenProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcArbitraryOpenProfileDef"); }    do { // convert the 'Curve' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcArbitraryOpenProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Curve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcArbitraryOpenProfileDef to be a `IfcBoundedCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcArbitraryProfileDefWithVoids>(const DB& db, const LIST& params, IfcArbitraryProfileDefWithVoids* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcArbitraryClosedProfileDef*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcArbitraryProfileDefWithVoids"); }    do { // convert the 'InnerCurves' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->InnerCurves, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcArbitraryProfileDefWithVoids to be a `SET [1:?] OF IfcCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGroup>(const DB& db, const LIST& params, IfcGroup* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAsset>(const DB& db, const LIST& params, IfcAsset* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcParameterizedProfileDef>(const DB& db, const LIST& params, IfcParameterizedProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcParameterizedProfileDef"); }    do { // convert the 'Position' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcParameterizedProfileDef,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcParameterizedProfileDef to be a `IfcAxis2Placement2D`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAsymmetricIShapeProfileDef>(const DB& db, const LIST& params, IfcAsymmetricIShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAudioVisualAppliance>(const DB& db, const LIST& params, IfcAudioVisualAppliance* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAudioVisualApplianceType>(const DB& db, const LIST& params, IfcAudioVisualApplianceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlacement>(const DB& db, const LIST& params, IfcPlacement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlacement"); }    do { // convert the 'Location' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPlacement,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Location, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPlacement to be a `IfcCartesianPoint`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& params, IfcAxis1Placement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); }    do { // convert the 'Axis' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& params, IfcAxis2Placement2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); }    do { // convert the 'RefDirection' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcAxis2Placement3D>(const DB& db, const LIST& params, IfcAxis2Placement3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcAxis2Placement3D"); }    do { // convert the 'Axis' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement3D to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'RefDirection' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefDirection, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcAxis2Placement3D to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurve>(const DB& db, const LIST& params, IfcCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundedCurve>(const DB& db, const LIST& params, IfcBoundedCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params, IfcBSplineCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); }    do { // convert the 'Degree' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Degree, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `IfcInteger`")); }
-    } while(0);
-    do { // convert the 'ControlPointsList' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->ControlPointsList, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'CurveForm' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->CurveForm, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
-    } while(0);
-    do { // convert the 'ClosedCurve' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->ClosedCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `IfcLogical`")); }
-    } while(0);
-    do { // convert the 'SelfIntersect' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `IfcLogical`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBSplineCurveWithKnots>(const DB& db, const LIST& params, IfcBSplineCurveWithKnots* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBSplineCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurface>(const DB& db, const LIST& params, IfcSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundedSurface>(const DB& db, const LIST& params, IfcBoundedSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBSplineSurface>(const DB& db, const LIST& params, IfcBSplineSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBSplineSurfaceWithKnots>(const DB& db, const LIST& params, IfcBSplineSurfaceWithKnots* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBSplineSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElement>(const DB& db, const LIST& params, IfcBuildingElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcBuildingElement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBeam>(const DB& db, const LIST& params, IfcBeam* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBeamStandardCase>(const DB& db, const LIST& params, IfcBeamStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBeam*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementType>(const DB& db, const LIST& params, IfcBuildingElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBeamType>(const DB& db, const LIST& params, IfcBeamType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPresentationItem>(const DB& db, const LIST& params, IfcPresentationItem* in)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCsgPrimitive3D>(const DB& db, const LIST& params, IfcCsgPrimitive3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBlock>(const DB& db, const LIST& params, IfcBlock* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoiler>(const DB& db, const LIST& params, IfcBoiler* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoilerType>(const DB& db, const LIST& params, IfcBoilerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBooleanResult>(const DB& db, const LIST& params, IfcBooleanResult* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanResult"); }    do { // convert the 'Operator' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Operator, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBooleanResult to be a `IfcBooleanOperator`")); }
-    } while(0);
-    do { // convert the 'FirstOperand' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->FirstOperand, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
-    } while(0);
-    do { // convert the 'SecondOperand' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBooleanResult,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->SecondOperand, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBooleanResult to be a `IfcBooleanOperand`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBooleanClippingResult>(const DB& db, const LIST& params, IfcBooleanClippingResult* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBooleanResult*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcBooleanClippingResult"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeCurve>(const DB& db, const LIST& params, IfcCompositeCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCompositeCurve"); }    do { // convert the 'Segments' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Segments, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurve to be a `LIST [1:?] OF IfcCompositeCurveSegment`")); }
-    } while(0);
-    do { // convert the 'SelfIntersect' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurve,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->SelfIntersect, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurve to be a `IfcLogical`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeCurveOnSurface>(const DB& db, const LIST& params, IfcCompositeCurveOnSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundaryCurve>(const DB& db, const LIST& params, IfcBoundaryCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurveOnSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params, IfcBoundingBox* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); }    do { // convert the 'Corner' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Corner, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'XDim' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->XDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'YDim' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->YDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'ZDim' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ZDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHalfSpaceSolid>(const DB& db, const LIST& params, IfcHalfSpaceSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcHalfSpaceSolid"); }    do { // convert the 'BaseSurface' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->BaseSurface, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcHalfSpaceSolid to be a `IfcSurface`")); }
-    } while(0);
-    do { // convert the 'AgreementFlag' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcHalfSpaceSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->AgreementFlag, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcHalfSpaceSolid to be a `IfcBoolean`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBoxedHalfSpace>(const DB& db, const LIST& params, IfcBoxedHalfSpace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialElement>(const DB& db, const LIST& params, IfcSpatialElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcSpatialElement"); }    do { // convert the 'LongName' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialElement,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSpatialElement to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialStructureElement>(const DB& db, const LIST& params, IfcSpatialStructureElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialElement*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSpatialStructureElement"); }    do { // convert the 'CompositionType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSpatialStructureElement,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->CompositionType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSpatialStructureElement to be a `IfcElementCompositionEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuilding>(const DB& db, const LIST& params, IfcBuilding* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-	if (params.GetSize() < 12) { throw STEP::TypeError("expected 12 arguments to IfcBuilding"); }    do { // convert the 'ElevationOfRefHeight' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfRefHeight, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcBuilding to be a `IfcLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'ElevationOfTerrain' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationOfTerrain, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcBuilding to be a `IfcLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'BuildingAddress' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->BuildingAddress, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcBuilding to be a `IfcPostalAddress`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementComponent>(const DB& db, const LIST& params, IfcElementComponent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementPart>(const DB& db, const LIST& params, IfcBuildingElementPart* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementComponentType>(const DB& db, const LIST& params, IfcElementComponentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementPartType>(const DB& db, const LIST& params, IfcBuildingElementPartType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementProxy>(const DB& db, const LIST& params, IfcBuildingElementProxy* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingElementProxyType>(const DB& db, const LIST& params, IfcBuildingElementProxyType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingStorey>(const DB& db, const LIST& params, IfcBuildingStorey* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSystem>(const DB& db, const LIST& params, IfcSystem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBuildingSystem>(const DB& db, const LIST& params, IfcBuildingSystem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBurner>(const DB& db, const LIST& params, IfcBurner* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcBurnerType>(const DB& db, const LIST& params, IfcBurnerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCShapeProfileDef>(const DB& db, const LIST& params, IfcCShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowFitting>(const DB& db, const LIST& params, IfcFlowFitting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableCarrierFitting>(const DB& db, const LIST& params, IfcCableCarrierFitting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowFittingType>(const DB& db, const LIST& params, IfcFlowFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableCarrierFittingType>(const DB& db, const LIST& params, IfcCableCarrierFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowSegment>(const DB& db, const LIST& params, IfcFlowSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableCarrierSegment>(const DB& db, const LIST& params, IfcCableCarrierSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowSegmentType>(const DB& db, const LIST& params, IfcFlowSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableCarrierSegmentType>(const DB& db, const LIST& params, IfcCableCarrierSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableFitting>(const DB& db, const LIST& params, IfcCableFitting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableFittingType>(const DB& db, const LIST& params, IfcCableFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableSegment>(const DB& db, const LIST& params, IfcCableSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCableSegmentType>(const DB& db, const LIST& params, IfcCableSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPoint>(const DB& db, const LIST& params, IfcPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& params, IfcCartesianPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); }    do { // convert the 'Coordinates' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Coordinates, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianPointList>(const DB& db, const LIST& params, IfcCartesianPointList* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianPointList2D>(const DB& db, const LIST& params, IfcCartesianPointList2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianPointList*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianPointList3D>(const DB& db, const LIST& params, IfcCartesianPointList3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianPointList*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator>(const DB& db, const LIST& params, IfcCartesianTransformationOperator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCartesianTransformationOperator"); }    do { // convert the 'Axis1' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis1, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'Axis2' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCartesianTransformationOperator to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'LocalOrigin' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->LocalOrigin, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCartesianTransformationOperator to be a `IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'Scale' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator,4>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCartesianTransformationOperator to be a `IfcReal`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator2D>(const DB& db, const LIST& params, IfcCartesianTransformationOperator2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator2DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator2DnonUniform* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator2D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator3D>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCartesianTransformationOperator3D"); }    do { // convert the 'Axis3' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCartesianTransformationOperator3D,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Axis3, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCartesianTransformationOperator3D to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3DnonUniform* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator3D*>(in));
-	if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); }    do { // convert the 'Scale2' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `IfcReal`")); }
-    } while(0);
-    do { // convert the 'Scale3' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Scale3, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `IfcReal`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCenterLineProfileDef>(const DB& db, const LIST& params, IfcCenterLineProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcArbitraryOpenProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcChiller>(const DB& db, const LIST& params, IfcChiller* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcChillerType>(const DB& db, const LIST& params, IfcChillerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcChimney>(const DB& db, const LIST& params, IfcChimney* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcChimneyType>(const DB& db, const LIST& params, IfcChimneyType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConic>(const DB& db, const LIST& params, IfcConic* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConic"); }    do { // convert the 'Position' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConic,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConic to be a `IfcAxis2Placement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcCircle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); }    do { // convert the 'Radius' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Radius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCircleProfileDef>(const DB& db, const LIST& params, IfcCircleProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcCircleProfileDef"); }    do { // convert the 'Radius' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCircleProfileDef,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Radius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcCircleProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCircleHollowProfileDef>(const DB& db, const LIST& params, IfcCircleHollowProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCircleProfileDef*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcCircleHollowProfileDef"); }    do { // convert the 'WallThickness' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->WallThickness, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcCircleHollowProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCivilElement>(const DB& db, const LIST& params, IfcCivilElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCivilElementType>(const DB& db, const LIST& params, IfcCivilElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConnectedFaceSet>(const DB& db, const LIST& params, IfcConnectedFaceSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcConnectedFaceSet"); }    do { // convert the 'CfsFaces' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConnectedFaceSet,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CfsFaces, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcConnectedFaceSet to be a `SET [1:?] OF IfcFace`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcClosedShell>(const DB& db, const LIST& params, IfcClosedShell* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcClosedShell"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoil>(const DB& db, const LIST& params, IfcCoil* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoilType>(const DB& db, const LIST& params, IfcCoilType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST& params, IfcColourSpecification* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcColourSpecification"); }    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, IfcColourRgb* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); }    do { // convert the 'Red' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Red, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-    do { // convert the 'Green' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Green, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-    do { // convert the 'Blue' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Blue, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColumn>(const DB& db, const LIST& params, IfcColumn* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColumnStandardCase>(const DB& db, const LIST& params, IfcColumnStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcColumn*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcColumnType>(const DB& db, const LIST& params, IfcColumnType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCommunicationsAppliance>(const DB& db, const LIST& params, IfcCommunicationsAppliance* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCommunicationsApplianceType>(const DB& db, const LIST& params, IfcCommunicationsApplianceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyAbstraction>(const DB& db, const LIST& params, IfcPropertyAbstraction* in)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProperty>(const DB& db, const LIST& params, IfcProperty* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertyAbstraction*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcProperty"); }    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProperty to be a `IfcIdentifier`")); }
-    } while(0);
-    do { // convert the 'Description' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProperty,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProperty to be a `IfcText`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& params, IfcComplexProperty* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); }    do { // convert the 'UsageName' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UsageName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
-    } while(0);
-    do { // convert the 'HasProperties' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyDefinition>(const DB& db, const LIST& params, IfcPropertyDefinition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyDefinition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeCurveSegment>(const DB& db, const LIST& params, IfcCompositeCurveSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcCompositeCurveSegment"); }    do { // convert the 'Transition' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Transition, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCompositeCurveSegment to be a `IfcTransitionCode`")); }
-    } while(0);
-    do { // convert the 'SameSense' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->SameSense, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCompositeCurveSegment to be a `IfcBoolean`")); }
-    } while(0);
-    do { // convert the 'ParentCurve' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcCompositeCurveSegment,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->ParentCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcCompositeCurveSegment to be a `IfcCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompositeProfileDef>(const DB& db, const LIST& params, IfcCompositeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMovingDevice>(const DB& db, const LIST& params, IfcFlowMovingDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompressor>(const DB& db, const LIST& params, IfcCompressor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMovingDeviceType>(const DB& db, const LIST& params, IfcFlowMovingDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCompressorType>(const DB& db, const LIST& params, IfcCompressorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCondenser>(const DB& db, const LIST& params, IfcCondenser* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCondenserType>(const DB& db, const LIST& params, IfcCondenserType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcResource>(const DB& db, const LIST& params, IfcResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionResource>(const DB& db, const LIST& params, IfcConstructionResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionEquipmentResource>(const DB& db, const LIST& params, IfcConstructionEquipmentResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTypeResource>(const DB& db, const LIST& params, IfcTypeResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionResourceType>(const DB& db, const LIST& params, IfcConstructionResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionEquipmentResourceType>(const DB& db, const LIST& params, IfcConstructionEquipmentResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionMaterialResource>(const DB& db, const LIST& params, IfcConstructionMaterialResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionMaterialResourceType>(const DB& db, const LIST& params, IfcConstructionMaterialResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionProductResource>(const DB& db, const LIST& params, IfcConstructionProductResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConstructionProductResourceType>(const DB& db, const LIST& params, IfcConstructionProductResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcContext>(const DB& db, const LIST& params, IfcContext* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectDefinition*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcContext"); }    do { // convert the 'ObjectType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ObjectType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcContext to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'LongName' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LongName, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcContext to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Phase' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Phase, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcContext to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'RepresentationContexts' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationContexts, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcContext to be a `SET [1:?] OF IfcRepresentationContext`")); }
-    } while(0);
-    do { // convert the 'UnitsInContext' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcContext,5>::aux_is_derived[4]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->UnitsInContext, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcContext to be a `IfcUnitAssignment`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcNamedUnit>(const DB& db, const LIST& params, IfcNamedUnit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcNamedUnit"); }    do { // convert the 'Dimensions' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Dimensions, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcNamedUnit to be a `IfcDimensionalExponents`")); }
-    } while(0);
-    do { // convert the 'UnitType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcNamedUnit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->UnitType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcNamedUnit to be a `IfcUnitEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcContextDependentUnit>(const DB& db, const LIST& params, IfcContextDependentUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcController>(const DB& db, const LIST& params, IfcController* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcControllerType>(const DB& db, const LIST& params, IfcControllerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST& params, IfcConversionBasedUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); }    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConversionBasedUnit,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'ConversionFactor' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcConversionBasedUnit,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->ConversionFactor, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcConversionBasedUnitWithOffset>(const DB& db, const LIST& params, IfcConversionBasedUnitWithOffset* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConversionBasedUnit*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCooledBeam>(const DB& db, const LIST& params, IfcCooledBeam* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCooledBeamType>(const DB& db, const LIST& params, IfcCooledBeamType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoolingTower>(const DB& db, const LIST& params, IfcCoolingTower* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoolingTowerType>(const DB& db, const LIST& params, IfcCoolingTowerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCostItem>(const DB& db, const LIST& params, IfcCostItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCostSchedule>(const DB& db, const LIST& params, IfcCostSchedule* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCovering>(const DB& db, const LIST& params, IfcCovering* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCoveringType>(const DB& db, const LIST& params, IfcCoveringType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCrewResource>(const DB& db, const LIST& params, IfcCrewResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCrewResourceType>(const DB& db, const LIST& params, IfcCrewResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCsgSolid>(const DB& db, const LIST& params, IfcCsgSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurtainWall>(const DB& db, const LIST& params, IfcCurtainWall* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurtainWallType>(const DB& db, const LIST& params, IfcCurtainWallType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurveBoundedPlane>(const DB& db, const LIST& params, IfcCurveBoundedPlane* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCurveBoundedSurface>(const DB& db, const LIST& params, IfcCurveBoundedSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPresentationStyle>(const DB& db, const LIST& params, IfcPresentationStyle* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyle"); }    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcPresentationStyle,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyle to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementarySurface>(const DB& db, const LIST& params, IfcElementarySurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcElementarySurface"); }    do { // convert the 'Position' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcElementarySurface,1>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcElementarySurface to be a `IfcAxis2Placement3D`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcCylindricalSurface>(const DB& db, const LIST& params, IfcCylindricalSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDamper>(const DB& db, const LIST& params, IfcDamper* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDamperType>(const DB& db, const LIST& params, IfcDamperType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDerivedProfileDef>(const DB& db, const LIST& params, IfcDerivedProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDirection>(const DB& db, const LIST& params, IfcDirection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcDirection"); }    do { // convert the 'DirectionRatios' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->DirectionRatios, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcDirection to be a `LIST [2:3] OF IfcReal`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDiscreteAccessory>(const DB& db, const LIST& params, IfcDiscreteAccessory* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDiscreteAccessoryType>(const DB& db, const LIST& params, IfcDiscreteAccessoryType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionChamberElement>(const DB& db, const LIST& params, IfcDistributionChamberElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionChamberElementType>(const DB& db, const LIST& params, IfcDistributionChamberElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionSystem>(const DB& db, const LIST& params, IfcDistributionSystem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionCircuit>(const DB& db, const LIST& params, IfcDistributionCircuit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPort>(const DB& db, const LIST& params, IfcPort* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDistributionPort>(const DB& db, const LIST& params, IfcDistributionPort* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPort*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDoor>(const DB& db, const LIST& params, IfcDoor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-	if (params.GetSize() < 13) { throw STEP::TypeError("expected 13 arguments to IfcDoor"); }    do { // convert the 'OverallHeight' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallHeight, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'OverallWidth' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OverallWidth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcDoor to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'PredefinedType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PredefinedType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcDoor to be a `IfcDoorTypeEnum`")); }
-    } while(0);
-    do { // convert the 'OperationType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->OperationType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcDoor to be a `IfcDoorTypeOperationEnum`")); }
-    } while(0);
-    do { // convert the 'UserDefinedOperationType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcDoor,5>::aux_is_derived[4]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->UserDefinedOperationType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcDoor to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertySetDefinition>(const DB& db, const LIST& params, IfcPropertySetDefinition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertyDefinition*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySetDefinition"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDoorStandardCase>(const DB& db, const LIST& params, IfcDoorStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDoor*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDoorStyle>(const DB& db, const LIST& params, IfcDoorStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDoorType>(const DB& db, const LIST& params, IfcDoorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctFitting>(const DB& db, const LIST& params, IfcDuctFitting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctFittingType>(const DB& db, const LIST& params, IfcDuctFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctSegment>(const DB& db, const LIST& params, IfcDuctSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctSegmentType>(const DB& db, const LIST& params, IfcDuctSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTreatmentDevice>(const DB& db, const LIST& params, IfcFlowTreatmentDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctSilencer>(const DB& db, const LIST& params, IfcDuctSilencer* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowTreatmentDeviceType>(const DB& db, const LIST& params, IfcFlowTreatmentDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcDuctSilencerType>(const DB& db, const LIST& params, IfcDuctSilencerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdge>(const DB& db, const LIST& params, IfcEdge* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdgeCurve>(const DB& db, const LIST& params, IfcEdgeCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLoop>(const DB& db, const LIST& params, IfcLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEdgeLoop>(const DB& db, const LIST& params, IfcEdgeLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricAppliance>(const DB& db, const LIST& params, IfcElectricAppliance* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricApplianceType>(const DB& db, const LIST& params, IfcElectricApplianceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricDistributionBoard>(const DB& db, const LIST& params, IfcElectricDistributionBoard* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricDistributionBoardType>(const DB& db, const LIST& params, IfcElectricDistributionBoardType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowStorageDevice>(const DB& db, const LIST& params, IfcFlowStorageDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricFlowStorageDevice>(const DB& db, const LIST& params, IfcElectricFlowStorageDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowStorageDeviceType>(const DB& db, const LIST& params, IfcFlowStorageDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricFlowStorageDeviceType>(const DB& db, const LIST& params, IfcElectricFlowStorageDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricGenerator>(const DB& db, const LIST& params, IfcElectricGenerator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricGeneratorType>(const DB& db, const LIST& params, IfcElectricGeneratorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricMotor>(const DB& db, const LIST& params, IfcElectricMotor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricMotorType>(const DB& db, const LIST& params, IfcElectricMotorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricTimeControl>(const DB& db, const LIST& params, IfcElectricTimeControl* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElectricTimeControlType>(const DB& db, const LIST& params, IfcElectricTimeControlType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementAssembly>(const DB& db, const LIST& params, IfcElementAssembly* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementAssemblyType>(const DB& db, const LIST& params, IfcElementAssemblyType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcQuantitySet>(const DB& db, const LIST& params, IfcQuantitySet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcQuantitySet"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& params, IfcElementQuantity* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcQuantitySet*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); }    do { // convert the 'MethodOfMeasurement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Quantities' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Quantities, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, IfcEllipse* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); }    do { // convert the 'SemiAxis1' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis1, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'SemiAxis2' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SemiAxis2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEllipseProfileDef>(const DB& db, const LIST& params, IfcEllipseProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEngine>(const DB& db, const LIST& params, IfcEngine* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEngineType>(const DB& db, const LIST& params, IfcEngineType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvaporativeCooler>(const DB& db, const LIST& params, IfcEvaporativeCooler* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvaporativeCoolerType>(const DB& db, const LIST& params, IfcEvaporativeCoolerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvaporator>(const DB& db, const LIST& params, IfcEvaporator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvaporatorType>(const DB& db, const LIST& params, IfcEvaporatorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProcess>(const DB& db, const LIST& params, IfcProcess* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEvent>(const DB& db, const LIST& params, IfcEvent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTypeProcess>(const DB& db, const LIST& params, IfcTypeProcess* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeObject*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcEventType>(const DB& db, const LIST& params, IfcEventType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcExternalSpatialStructureElement>(const DB& db, const LIST& params, IfcExternalSpatialStructureElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcExternalSpatialElement>(const DB& db, const LIST& params, IfcExternalSpatialElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcExternalSpatialStructureElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptAreaSolid>(const DB& db, const LIST& params, IfcSweptAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSweptAreaSolid"); }    do { // convert the 'SweptArea' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SweptArea, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptAreaSolid to be a `IfcProfileDef`")); }
-    } while(0);
-    do { // convert the 'Position' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptAreaSolid,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptAreaSolid to be a `IfcAxis2Placement3D`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& params, IfcExtrudedAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); }    do { // convert the 'ExtrudedDirection' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcExtrudedAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ExtrudedDirection, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'Depth' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcExtrudedAreaSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Depth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcExtrudedAreaSolidTapered>(const DB& db, const LIST& params, IfcExtrudedAreaSolidTapered* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcExtrudedAreaSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIST& params, IfcFaceBasedSurfaceModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); }    do { // convert the 'FbsmFaces' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->FbsmFaces, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, IfcFaceBound* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); }    do { // convert the 'Bound' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Bound, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
-    } while(0);
-    do { // convert the 'Orientation' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Orientation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `IfcBoolean`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFaceOuterBound>(const DB& db, const LIST& params, IfcFaceOuterBound* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFaceBound*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceOuterBound"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFacetedBrep>(const DB& db, const LIST& params, IfcFacetedBrep* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFacetedBrepWithVoids>(const DB& db, const LIST& params, IfcFacetedBrepWithVoids* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFacetedBrep*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFan>(const DB& db, const LIST& params, IfcFan* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFanType>(const DB& db, const LIST& params, IfcFanType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFastener>(const DB& db, const LIST& params, IfcFastener* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFastenerType>(const DB& db, const LIST& params, IfcFastenerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFeatureElement>(const DB& db, const LIST& params, IfcFeatureElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcFeatureElement"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFeatureElementAddition>(const DB& db, const LIST& params, IfcFeatureElementAddition* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFeatureElementSubtraction>(const DB& db, const LIST& params, IfcFeatureElementSubtraction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
-	if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcFeatureElementSubtraction"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFillAreaStyleHatching>(const DB& db, const LIST& params, IfcFillAreaStyleHatching* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFillAreaStyleTiles>(const DB& db, const LIST& params, IfcFillAreaStyleTiles* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFilter>(const DB& db, const LIST& params, IfcFilter* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFilterType>(const DB& db, const LIST& params, IfcFilterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFireSuppressionTerminal>(const DB& db, const LIST& params, IfcFireSuppressionTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFireSuppressionTerminalType>(const DB& db, const LIST& params, IfcFireSuppressionTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFixedReferenceSweptAreaSolid>(const DB& db, const LIST& params, IfcFixedReferenceSweptAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowInstrument>(const DB& db, const LIST& params, IfcFlowInstrument* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowInstrumentType>(const DB& db, const LIST& params, IfcFlowInstrumentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMeter>(const DB& db, const LIST& params, IfcFlowMeter* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFlowMeterType>(const DB& db, const LIST& params, IfcFlowMeterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFooting>(const DB& db, const LIST& params, IfcFooting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFootingType>(const DB& db, const LIST& params, IfcFootingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnishingElement>(const DB& db, const LIST& params, IfcFurnishingElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnishingElementType>(const DB& db, const LIST& params, IfcFurnishingElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurniture>(const DB& db, const LIST& params, IfcFurniture* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcFurnitureType>(const DB& db, const LIST& params, IfcFurnitureType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeographicElement>(const DB& db, const LIST& params, IfcGeographicElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeographicElementType>(const DB& db, const LIST& params, IfcGeographicElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricSet>(const DB& db, const LIST& params, IfcGeometricSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricCurveSet>(const DB& db, const LIST& params, IfcGeometricCurveSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricSet*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIST& params, IfcRepresentationContext* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationContext"); }    do { // convert the 'ContextIdentifier' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextIdentifier, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'ContextType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ContextType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db, const LIST& params, IfcGeometricRepresentationContext* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationContext*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); }    do { // convert the 'CoordinateSpaceDimension' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
-    } while(0);
-    do { // convert the 'Precision' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Precision, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `IfcReal`")); }
-    } while(0);
-    do { // convert the 'WorldCoordinateSystem' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
-    } while(0);
-    do { // convert the 'TrueNorth' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TrueNorth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGeometricRepresentationSubContext>(const DB& db, const LIST& params, IfcGeometricRepresentationSubContext* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationContext*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGrid>(const DB& db, const LIST& params, IfcGrid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcObjectPlacement>(const DB& db, const LIST& params, IfcObjectPlacement* in)
-{
-	size_t base = 0;
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcGridPlacement>(const DB& db, const LIST& params, IfcGridPlacement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectPlacement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHeatExchanger>(const DB& db, const LIST& params, IfcHeatExchanger* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHeatExchangerType>(const DB& db, const LIST& params, IfcHeatExchangerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHumidifier>(const DB& db, const LIST& params, IfcHumidifier* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcHumidifierType>(const DB& db, const LIST& params, IfcHumidifierType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcIShapeProfileDef>(const DB& db, const LIST& params, IfcIShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-	if (params.GetSize() < 10) { throw STEP::TypeError("expected 10 arguments to IfcIShapeProfileDef"); }    do { // convert the 'OverallWidth' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->OverallWidth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'OverallDepth' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->OverallDepth, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'WebThickness' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->WebThickness, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'FlangeThickness' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->FlangeThickness, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcIShapeProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'FilletRadius' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FilletRadius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcIShapeProfileDef to be a `IfcNonNegativeLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'FlangeEdgeRadius' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FlangeEdgeRadius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcIShapeProfileDef to be a `IfcNonNegativeLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'FlangeSlope' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->FlangeSlope, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcIShapeProfileDef to be a `IfcPlaneAngleMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcIndexedPolyCurve>(const DB& db, const LIST& params, IfcIndexedPolyCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTessellatedItem>(const DB& db, const LIST& params, IfcTessellatedItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcIndexedPolygonalFace>(const DB& db, const LIST& params, IfcIndexedPolygonalFace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTessellatedItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcIndexedPolygonalFaceWithVoids>(const DB& db, const LIST& params, IfcIndexedPolygonalFaceWithVoids* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcIndexedPolygonalFace*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcInterceptor>(const DB& db, const LIST& params, IfcInterceptor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcInterceptorType>(const DB& db, const LIST& params, IfcInterceptorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceCurve>(const DB& db, const LIST& params, IfcSurfaceCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcIntersectionCurve>(const DB& db, const LIST& params, IfcIntersectionCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurfaceCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcInventory>(const DB& db, const LIST& params, IfcInventory* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcJunctionBox>(const DB& db, const LIST& params, IfcJunctionBox* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcJunctionBoxType>(const DB& db, const LIST& params, IfcJunctionBoxType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLShapeProfileDef>(const DB& db, const LIST& params, IfcLShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLaborResource>(const DB& db, const LIST& params, IfcLaborResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLaborResourceType>(const DB& db, const LIST& params, IfcLaborResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLamp>(const DB& db, const LIST& params, IfcLamp* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLampType>(const DB& db, const LIST& params, IfcLampType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightFixture>(const DB& db, const LIST& params, IfcLightFixture* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightFixtureType>(const DB& db, const LIST& params, IfcLightFixtureType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSource>(const DB& db, const LIST& params, IfcLightSource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceAmbient>(const DB& db, const LIST& params, IfcLightSourceAmbient* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceDirectional>(const DB& db, const LIST& params, IfcLightSourceDirectional* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceGoniometric>(const DB& db, const LIST& params, IfcLightSourceGoniometric* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourcePositional>(const DB& db, const LIST& params, IfcLightSourcePositional* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLightSourceSpot>(const DB& db, const LIST& params, IfcLightSourceSpot* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLightSourcePositional*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLine>(const DB& db, const LIST& params, IfcLine* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLine"); }    do { // convert the 'Pnt' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Pnt, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLine to be a `IfcCartesianPoint`")); }
-    } while(0);
-    do { // convert the 'Dir' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Dir, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLine to be a `IfcVector`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcLocalPlacement>(const DB& db, const LIST& params, IfcLocalPlacement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcObjectPlacement*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcLocalPlacement"); }    do { // convert the 'PlacementRelTo' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PlacementRelTo, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcLocalPlacement to be a `IfcObjectPlacement`")); }
-    } while(0);
-    do { // convert the 'RelativePlacement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelativePlacement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcLocalPlacement to be a `IfcAxis2Placement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMappedItem>(const DB& db, const LIST& params, IfcMappedItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMappedItem"); }    do { // convert the 'MappingSource' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingSource, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMappedItem to be a `IfcRepresentationMap`")); }
-    } while(0);
-    do { // convert the 'MappingTarget' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingTarget, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMappedItem to be a `IfcCartesianTransformationOperator`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProductRepresentation>(const DB& db, const LIST& params, IfcProductRepresentation* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcProductRepresentation"); }    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcProductRepresentation to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Description' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Description, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcProductRepresentation to be a `IfcText`")); }
-    } while(0);
-    do { // convert the 'Representations' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcProductRepresentation,3>::aux_is_derived[2]=true; break; }
-        try { GenericConvert( in->Representations, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcProductRepresentation to be a `LIST [1:?] OF IfcRepresentation`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMaterialDefinitionRepresentation>(const DB& db, const LIST& params, IfcMaterialDefinitionRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& params, IfcMeasureWithUnit* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); }    do { // convert the 'ValueComponent' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ValueComponent, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
-    } while(0);
-    do { // convert the 'UnitComponent' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->UnitComponent, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMechanicalFastener>(const DB& db, const LIST& params, IfcMechanicalFastener* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMechanicalFastenerType>(const DB& db, const LIST& params, IfcMechanicalFastenerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMedicalDevice>(const DB& db, const LIST& params, IfcMedicalDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMedicalDeviceType>(const DB& db, const LIST& params, IfcMedicalDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMember>(const DB& db, const LIST& params, IfcMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMemberStandardCase>(const DB& db, const LIST& params, IfcMemberStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMemberType>(const DB& db, const LIST& params, IfcMemberType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMirroredProfileDef>(const DB& db, const LIST& params, IfcMirroredProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDerivedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMotorConnection>(const DB& db, const LIST& params, IfcMotorConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcMotorConnectionType>(const DB& db, const LIST& params, IfcMotorConnectionType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOccupant>(const DB& db, const LIST& params, IfcOccupant* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcActor*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOffsetCurve2D>(const DB& db, const LIST& params, IfcOffsetCurve2D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOffsetCurve3D>(const DB& db, const LIST& params, IfcOffsetCurve3D* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOpenShell>(const DB& db, const LIST& params, IfcOpenShell* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOpeningElement>(const DB& db, const LIST& params, IfcOpeningElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcOpeningElement"); }    do { // convert the 'PredefinedType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcOpeningElement,1>::aux_is_derived[0]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PredefinedType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcOpeningElement to be a `IfcOpeningElementTypeEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOpeningStandardCase>(const DB& db, const LIST& params, IfcOpeningStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcOpeningElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOrientedEdge>(const DB& db, const LIST& params, IfcOrientedEdge* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOuterBoundaryCurve>(const DB& db, const LIST& params, IfcOuterBoundaryCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundaryCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOutlet>(const DB& db, const LIST& params, IfcOutlet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcOutletType>(const DB& db, const LIST& params, IfcOutletType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPath>(const DB& db, const LIST& params, IfcPath* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPcurve>(const DB& db, const LIST& params, IfcPcurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPerformanceHistory>(const DB& db, const LIST& params, IfcPerformanceHistory* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPermit>(const DB& db, const LIST& params, IfcPermit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPile>(const DB& db, const LIST& params, IfcPile* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPileType>(const DB& db, const LIST& params, IfcPileType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPipeFitting>(const DB& db, const LIST& params, IfcPipeFitting* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFitting*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPipeFittingType>(const DB& db, const LIST& params, IfcPipeFittingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPipeSegment>(const DB& db, const LIST& params, IfcPipeSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegment*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPipeSegmentType>(const DB& db, const LIST& params, IfcPipeSegmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlanarExtent>(const DB& db, const LIST& params, IfcPlanarExtent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlanarBox>(const DB& db, const LIST& params, IfcPlanarBox* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlanarExtent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlane>(const DB& db, const LIST& params, IfcPlane* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPlane"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlate>(const DB& db, const LIST& params, IfcPlate* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlateStandardCase>(const DB& db, const LIST& params, IfcPlateStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPlate*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPlateType>(const DB& db, const LIST& params, IfcPlateType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPointOnCurve>(const DB& db, const LIST& params, IfcPointOnCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPointOnSurface>(const DB& db, const LIST& params, IfcPointOnSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, IfcPolyLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); }    do { // convert the 'Polygon' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Polygon, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolygonalBoundedHalfSpace>(const DB& db, const LIST& params, IfcPolygonalBoundedHalfSpace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPolygonalBoundedHalfSpace"); }    do { // convert the 'Position' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Position, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPolygonalBoundedHalfSpace to be a `IfcAxis2Placement3D`")); }
-    } while(0);
-    do { // convert the 'PolygonalBoundary' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->PolygonalBoundary, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPolygonalBoundedHalfSpace to be a `IfcBoundedCurve`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTessellatedFaceSet>(const DB& db, const LIST& params, IfcTessellatedFaceSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTessellatedItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolygonalFaceSet>(const DB& db, const LIST& params, IfcPolygonalFaceSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTessellatedFaceSet*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPolyline>(const DB& db, const LIST& params, IfcPolyline* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyline"); }    do { // convert the 'Points' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Points, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyline to be a `LIST [2:?] OF IfcCartesianPoint`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, const LIST& params, IfcPresentationStyleAssignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); }    do { // convert the 'Styles' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProcedure>(const DB& db, const LIST& params, IfcProcedure* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProcedureType>(const DB& db, const LIST& params, IfcProcedureType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProductDefinitionShape>(const DB& db, const LIST& params, IfcProductDefinitionShape* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProject>(const DB& db, const LIST& params, IfcProject* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcContext*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcProject"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectLibrary>(const DB& db, const LIST& params, IfcProjectLibrary* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcContext*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectOrder>(const DB& db, const LIST& params, IfcProjectOrder* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProjectionElement>(const DB& db, const LIST& params, IfcProjectionElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementAddition*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSimpleProperty>(const DB& db, const LIST& params, IfcSimpleProperty* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSimpleProperty"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyBoundedValue>(const DB& db, const LIST& params, IfcPropertyBoundedValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyEnumeratedValue>(const DB& db, const LIST& params, IfcPropertyEnumeratedValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyListValue>(const DB& db, const LIST& params, IfcPropertyListValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertyListValue"); }    do { // convert the 'ListValues' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ListValues, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertyListValue to be a `LIST [1:?] OF IfcValue`")); }
-    } while(0);
-    do { // convert the 'Unit' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertyListValue to be a `IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyReferenceValue>(const DB& db, const LIST& params, IfcPropertyReferenceValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params, IfcPropertySet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); }    do { // convert the 'HasProperties' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->HasProperties, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertySingleValue>(const DB& db, const LIST& params, IfcPropertySingleValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcPropertySingleValue"); }    do { // convert the 'NominalValue' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->NominalValue, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcPropertySingleValue to be a `IfcValue`")); }
-    } while(0);
-    do { // convert the 'Unit' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Unit, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcPropertySingleValue to be a `IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPropertyTableValue>(const DB& db, const LIST& params, IfcPropertyTableValue* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProtectiveDevice>(const DB& db, const LIST& params, IfcProtectiveDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProtectiveDeviceTrippingUnit>(const DB& db, const LIST& params, IfcProtectiveDeviceTrippingUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProtectiveDeviceTrippingUnitType>(const DB& db, const LIST& params, IfcProtectiveDeviceTrippingUnitType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProtectiveDeviceType>(const DB& db, const LIST& params, IfcProtectiveDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcProxy>(const DB& db, const LIST& params, IfcProxy* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPump>(const DB& db, const LIST& params, IfcPump* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcPumpType>(const DB& db, const LIST& params, IfcPumpType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRailing>(const DB& db, const LIST& params, IfcRailing* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRailingType>(const DB& db, const LIST& params, IfcRailingType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRamp>(const DB& db, const LIST& params, IfcRamp* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRampFlight>(const DB& db, const LIST& params, IfcRampFlight* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRampFlightType>(const DB& db, const LIST& params, IfcRampFlightType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRampType>(const DB& db, const LIST& params, IfcRampType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRationalBSplineCurveWithKnots>(const DB& db, const LIST& params, IfcRationalBSplineCurveWithKnots* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBSplineCurveWithKnots*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRationalBSplineSurfaceWithKnots>(const DB& db, const LIST& params, IfcRationalBSplineSurfaceWithKnots* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBSplineSurfaceWithKnots*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangleProfileDef>(const DB& db, const LIST& params, IfcRectangleProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcRectangleProfileDef"); }    do { // convert the 'XDim' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->XDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'YDim' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRectangleProfileDef,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->YDim, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRectangleProfileDef to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangleHollowProfileDef>(const DB& db, const LIST& params, IfcRectangleHollowProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangularPyramid>(const DB& db, const LIST& params, IfcRectangularPyramid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRectangularTrimmedSurface>(const DB& db, const LIST& params, IfcRectangularTrimmedSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingElement>(const DB& db, const LIST& params, IfcReinforcingElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingBar>(const DB& db, const LIST& params, IfcReinforcingBar* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingElementType>(const DB& db, const LIST& params, IfcReinforcingElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingBarType>(const DB& db, const LIST& params, IfcReinforcingBarType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingMesh>(const DB& db, const LIST& params, IfcReinforcingMesh* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReinforcingMeshType>(const DB& db, const LIST& params, IfcReinforcingMeshType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelationship>(const DB& db, const LIST& params, IfcRelationship* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRoot*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelationship"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelDecomposes>(const DB& db, const LIST& params, IfcRelDecomposes* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelDecomposes"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelAggregates>(const DB& db, const LIST& params, IfcRelAggregates* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelAggregates"); }    do { // convert the 'RelatingObject' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingObject, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelAggregates to be a `IfcObjectDefinition`")); }
-    } while(0);
-    do { // convert the 'RelatedObjects' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelAggregates to be a `SET [1:?] OF IfcObjectDefinition`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelConnects>(const DB& db, const LIST& params, IfcRelConnects* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelConnects"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelContainedInSpatialStructure>(const DB& db, const LIST& params, IfcRelContainedInSpatialStructure* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelContainedInSpatialStructure"); }    do { // convert the 'RelatedElements' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedElements, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelContainedInSpatialStructure to be a `SET [1:?] OF IfcProduct`")); }
-    } while(0);
-    do { // convert the 'RelatingStructure' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingStructure, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelContainedInSpatialStructure to be a `IfcSpatialElement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelDefines>(const DB& db, const LIST& params, IfcRelDefines* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelationship*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRelDefines"); }	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelDefinesByProperties>(const DB& db, const LIST& params, IfcRelDefinesByProperties* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelDefines*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelDefinesByProperties"); }    do { // convert the 'RelatedObjects' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedObjects, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelDefinesByProperties to be a `SET [1:?] OF IfcObjectDefinition`")); }
-    } while(0);
-    do { // convert the 'RelatingPropertyDefinition' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingPropertyDefinition, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelDefinesByProperties to be a `IfcPropertySetDefinitionSelect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelFillsElement>(const DB& db, const LIST& params, IfcRelFillsElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelFillsElement"); }    do { // convert the 'RelatingOpeningElement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingOpeningElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelFillsElement to be a `IfcOpeningElement`")); }
-    } while(0);
-    do { // convert the 'RelatedBuildingElement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedBuildingElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelFillsElement to be a `IfcElement`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& params, IfcRelVoidsElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
-	if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); }    do { // convert the 'RelatingBuildingElement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
-    } while(0);
-    do { // convert the 'RelatedOpeningElement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcReparametrisedCompositeCurveSegment>(const DB& db, const LIST& params, IfcReparametrisedCompositeCurveSegment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCompositeCurveSegment*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentation>(const DB& db, const LIST& params, IfcRepresentation* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRepresentation"); }    do { // convert the 'ContextOfItems' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->ContextOfItems, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentation to be a `IfcRepresentationContext`")); }
-    } while(0);
-    do { // convert the 'RepresentationIdentifier' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationIdentifier, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentation to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'RepresentationType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RepresentationType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRepresentation to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'Items' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentation,4>::aux_is_derived[3]=true; break; }
-        try { GenericConvert( in->Items, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRepresentation to be a `SET [1:?] OF IfcRepresentationItem`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& params, IfcRepresentationMap* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); }    do { // convert the 'MappingOrigin' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappingOrigin, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
-    } while(0);
-    do { // convert the 'MappedRepresentation' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MappedRepresentation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRevolvedAreaSolid>(const DB& db, const LIST& params, IfcRevolvedAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcRevolvedAreaSolid"); }    do { // convert the 'Axis' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRevolvedAreaSolid,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Axis, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcRevolvedAreaSolid to be a `IfcAxis1Placement`")); }
-    } while(0);
-    do { // convert the 'Angle' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRevolvedAreaSolid,2>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Angle, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcRevolvedAreaSolid to be a `IfcPlaneAngleMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRevolvedAreaSolidTapered>(const DB& db, const LIST& params, IfcRevolvedAreaSolidTapered* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRevolvedAreaSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRightCircularCone>(const DB& db, const LIST& params, IfcRightCircularCone* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRightCircularCylinder>(const DB& db, const LIST& params, IfcRightCircularCylinder* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoof>(const DB& db, const LIST& params, IfcRoof* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoofType>(const DB& db, const LIST& params, IfcRoofType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcRoundedRectangleProfileDef>(const DB& db, const LIST& params, IfcRoundedRectangleProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcSIUnit* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
-	if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); }    do { // convert the 'Prefix' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Prefix, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
-    } while(0);
-    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSanitaryTerminal>(const DB& db, const LIST& params, IfcSanitaryTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSanitaryTerminalType>(const DB& db, const LIST& params, IfcSanitaryTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSeamCurve>(const DB& db, const LIST& params, IfcSeamCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurfaceCurve*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSectionedSpine>(const DB& db, const LIST& params, IfcSectionedSpine* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSensor>(const DB& db, const LIST& params, IfcSensor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSensorType>(const DB& db, const LIST& params, IfcSensorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShadingDevice>(const DB& db, const LIST& params, IfcShadingDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShadingDeviceType>(const DB& db, const LIST& params, IfcShadingDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShapeModel>(const DB& db, const LIST& params, IfcShapeModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShapeRepresentation>(const DB& db, const LIST& params, IfcShapeRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LIST& params, IfcShellBasedSurfaceModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); }    do { // convert the 'SbsmBoundary' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SbsmBoundary, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSite* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-	if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); }    do { // convert the 'RefLatitude' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLatitude, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
-    } while(0);
-    do { // convert the 'RefLongitude' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefLongitude, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
-    } while(0);
-    do { // convert the 'RefElevation' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->RefElevation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'LandTitleNumber' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->LandTitleNumber, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
-    } while(0);
-    do { // convert the 'SiteAddress' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SiteAddress, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSlab>(const DB& db, const LIST& params, IfcSlab* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSlabElementedCase>(const DB& db, const LIST& params, IfcSlabElementedCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSlab*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSlabStandardCase>(const DB& db, const LIST& params, IfcSlabStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSlab*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSlabType>(const DB& db, const LIST& params, IfcSlabType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSolarDevice>(const DB& db, const LIST& params, IfcSolarDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSolarDeviceType>(const DB& db, const LIST& params, IfcSolarDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSpace* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
-	if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); }    do { // convert the 'PredefinedType' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->PredefinedType, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcSpaceTypeEnum`")); }
-    } while(0);
-    do { // convert the 'ElevationWithFlooring' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpaceHeater>(const DB& db, const LIST& params, IfcSpaceHeater* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpaceHeaterType>(const DB& db, const LIST& params, IfcSpaceHeaterType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialElementType>(const DB& db, const LIST& params, IfcSpatialElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialStructureElementType>(const DB& db, const LIST& params, IfcSpatialStructureElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpaceType>(const DB& db, const LIST& params, IfcSpaceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialZone>(const DB& db, const LIST& params, IfcSpatialZone* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSpatialZoneType>(const DB& db, const LIST& params, IfcSpatialZoneType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSpatialElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSphere>(const DB& db, const LIST& params, IfcSphere* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSphericalSurface>(const DB& db, const LIST& params, IfcSphericalSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStackTerminal>(const DB& db, const LIST& params, IfcStackTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStackTerminalType>(const DB& db, const LIST& params, IfcStackTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStair>(const DB& db, const LIST& params, IfcStair* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStairFlight>(const DB& db, const LIST& params, IfcStairFlight* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStairFlightType>(const DB& db, const LIST& params, IfcStairFlightType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStairType>(const DB& db, const LIST& params, IfcStairType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralActivity>(const DB& db, const LIST& params, IfcStructuralActivity* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralAction>(const DB& db, const LIST& params, IfcStructuralAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralAnalysisModel>(const DB& db, const LIST& params, IfcStructuralAnalysisModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralItem>(const DB& db, const LIST& params, IfcStructuralItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralConnection>(const DB& db, const LIST& params, IfcStructuralConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveAction>(const DB& db, const LIST& params, IfcStructuralCurveAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveConnection>(const DB& db, const LIST& params, IfcStructuralCurveConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralMember>(const DB& db, const LIST& params, IfcStructuralMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveMember>(const DB& db, const LIST& params, IfcStructuralCurveMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveMemberVarying>(const DB& db, const LIST& params, IfcStructuralCurveMemberVarying* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralCurveMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralReaction>(const DB& db, const LIST& params, IfcStructuralReaction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralCurveReaction>(const DB& db, const LIST& params, IfcStructuralCurveReaction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralLinearAction>(const DB& db, const LIST& params, IfcStructuralLinearAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralCurveAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralLoadGroup>(const DB& db, const LIST& params, IfcStructuralLoadGroup* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralLoadCase>(const DB& db, const LIST& params, IfcStructuralLoadCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralLoadGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceAction>(const DB& db, const LIST& params, IfcStructuralSurfaceAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPlanarAction>(const DB& db, const LIST& params, IfcStructuralPlanarAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralSurfaceAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPointAction>(const DB& db, const LIST& params, IfcStructuralPointAction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPointConnection>(const DB& db, const LIST& params, IfcStructuralPointConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralPointReaction>(const DB& db, const LIST& params, IfcStructuralPointReaction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralResultGroup>(const DB& db, const LIST& params, IfcStructuralResultGroup* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceConnection>(const DB& db, const LIST& params, IfcStructuralSurfaceConnection* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralConnection*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceMember>(const DB& db, const LIST& params, IfcStructuralSurfaceMember* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceMemberVarying>(const DB& db, const LIST& params, IfcStructuralSurfaceMemberVarying* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralSurfaceMember*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStructuralSurfaceReaction>(const DB& db, const LIST& params, IfcStructuralSurfaceReaction* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStyleModel>(const DB& db, const LIST& params, IfcStyleModel* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentation*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStyledItem>(const DB& db, const LIST& params, IfcStyledItem* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcRepresentationItem*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcStyledItem"); }    do { // convert the 'Item' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Item, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcStyledItem to be a `IfcRepresentationItem`")); }
-    } while(0);
-    do { // convert the 'Styles' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcStyledItem to be a `SET [1:?] OF IfcStyleAssignmentSelect`")); }
-    } while(0);
-    do { // convert the 'Name' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Name, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcStyledItem to be a `IfcLabel`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcStyledRepresentation>(const DB& db, const LIST& params, IfcStyledRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcStyleModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSubContractResource>(const DB& db, const LIST& params, IfcSubContractResource* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSubContractResourceType>(const DB& db, const LIST& params, IfcSubContractResourceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcConstructionResourceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSubedge>(const DB& db, const LIST& params, IfcSubedge* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceCurveSweptAreaSolid>(const DB& db, const LIST& params, IfcSurfaceCurveSweptAreaSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceFeature>(const DB& db, const LIST& params, IfcSurfaceFeature* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptSurface>(const DB& db, const LIST& params, IfcSweptSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceOfLinearExtrusion>(const DB& db, const LIST& params, IfcSurfaceOfLinearExtrusion* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceOfRevolution>(const DB& db, const LIST& params, IfcSurfaceOfRevolution* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params, IfcSurfaceStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
-	if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); }    do { // convert the 'Side' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Side, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
-    } while(0);
-    do { // convert the 'Styles' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Styles, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyleShading>(const DB& db, const LIST& params, IfcSurfaceStyleShading* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcSurfaceStyleShading"); }    do { // convert the 'SurfaceColour' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,2>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->SurfaceColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleShading to be a `IfcColourRgb`")); }
-    } while(0);
-    do { // convert the 'Transparency' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSurfaceStyleShading,2>::aux_is_derived[1]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->Transparency, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleShading to be a `IfcNormalisedRatioMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIST& params, IfcSurfaceStyleRendering* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSurfaceStyleShading*>(in));
-	if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); }    do { // convert the 'DiffuseColour' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'TransmissionColour' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->TransmissionColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'DiffuseTransmissionColour' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'ReflectionColour' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->ReflectionColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'SpecularColour' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularColour, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
-    } while(0);
-    do { // convert the 'SpecularHighlight' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->SpecularHighlight, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
-    } while(0);
-    do { // convert the 'ReflectanceMethod' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->ReflectanceMethod, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const LIST& params, IfcSurfaceStyleWithTextures* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcPresentationItem*>(in));
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); }    do { // convert the 'Textures' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Textures, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptDiskSolid>(const DB& db, const LIST& params, IfcSweptDiskSolid* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcSweptDiskSolid"); }    do { // convert the 'Directrix' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[0]=true; break; }
-        try { GenericConvert( in->Directrix, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSweptDiskSolid to be a `IfcCurve`")); }
-    } while(0);
-    do { // convert the 'Radius' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[1]=true; break; }
-        try { GenericConvert( in->Radius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'InnerRadius' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[2]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->InnerRadius, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSweptDiskSolid to be a `IfcPositiveLengthMeasure`")); }
-    } while(0);
-    do { // convert the 'StartParam' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[3]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->StartParam, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
-    } while(0);
-    do { // convert the 'EndParam' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcSweptDiskSolid,5>::aux_is_derived[4]=true; break; }
-        if (dynamic_cast<const UNSET*>(&*arg)) break;
-        try { GenericConvert( in->EndParam, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSweptDiskSolid to be a `IfcParameterValue`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSweptDiskSolidPolygonal>(const DB& db, const LIST& params, IfcSweptDiskSolidPolygonal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSweptDiskSolid*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSwitchingDevice>(const DB& db, const LIST& params, IfcSwitchingDevice* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSwitchingDeviceType>(const DB& db, const LIST& params, IfcSwitchingDeviceType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSystemFurnitureElement>(const DB& db, const LIST& params, IfcSystemFurnitureElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcSystemFurnitureElementType>(const DB& db, const LIST& params, IfcSystemFurnitureElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTShapeProfileDef>(const DB& db, const LIST& params, IfcTShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTank>(const DB& db, const LIST& params, IfcTank* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTankType>(const DB& db, const LIST& params, IfcTankType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTask>(const DB& db, const LIST& params, IfcTask* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTaskType>(const DB& db, const LIST& params, IfcTaskType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProcess*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTendon>(const DB& db, const LIST& params, IfcTendon* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTendonAnchor>(const DB& db, const LIST& params, IfcTendonAnchor* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTendonAnchorType>(const DB& db, const LIST& params, IfcTendonAnchorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTendonType>(const DB& db, const LIST& params, IfcTendonType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcReinforcingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTextLiteral>(const DB& db, const LIST& params, IfcTextLiteral* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTextLiteralWithExtent>(const DB& db, const LIST& params, IfcTextLiteralWithExtent* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTextLiteral*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTopologyRepresentation>(const DB& db, const LIST& params, IfcTopologyRepresentation* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcToroidalSurface>(const DB& db, const LIST& params, IfcToroidalSurface* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementarySurface*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransformer>(const DB& db, const LIST& params, IfcTransformer* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransformerType>(const DB& db, const LIST& params, IfcTransformerType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransportElement>(const DB& db, const LIST& params, IfcTransportElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTransportElementType>(const DB& db, const LIST& params, IfcTransportElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTrapeziumProfileDef>(const DB& db, const LIST& params, IfcTrapeziumProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTriangulatedFaceSet>(const DB& db, const LIST& params, IfcTriangulatedFaceSet* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTessellatedFaceSet*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTrimmedCurve>(const DB& db, const LIST& params, IfcTrimmedCurve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
-	if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcTrimmedCurve"); }    do { // convert the 'BasisCurve' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->BasisCurve, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcTrimmedCurve to be a `IfcCurve`")); }
-    } while(0);
-    do { // convert the 'Trim1' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim1, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
-    } while(0);
-    do { // convert the 'Trim2' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Trim2, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcTrimmedCurve to be a `SET [1:2] OF IfcTrimmingSelect`")); }
-    } while(0);
-    do { // convert the 'SenseAgreement' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->SenseAgreement, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcTrimmedCurve to be a `IfcBoolean`")); }
-    } while(0);
-    do { // convert the 'MasterRepresentation' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->MasterRepresentation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcTrimmedCurve to be a `IfcTrimmingPreference`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTubeBundle>(const DB& db, const LIST& params, IfcTubeBundle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcTubeBundleType>(const DB& db, const LIST& params, IfcTubeBundleType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUShapeProfileDef>(const DB& db, const LIST& params, IfcUShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& params, IfcUnitAssignment* in)
-{
-	size_t base = 0;
-	if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); }    do { // convert the 'Units' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Units, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitaryControlElement>(const DB& db, const LIST& params, IfcUnitaryControlElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitaryControlElementType>(const DB& db, const LIST& params, IfcUnitaryControlElementType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitaryEquipment>(const DB& db, const LIST& params, IfcUnitaryEquipment* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDevice*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcUnitaryEquipmentType>(const DB& db, const LIST& params, IfcUnitaryEquipmentType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcValve>(const DB& db, const LIST& params, IfcValve* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcValveType>(const DB& db, const LIST& params, IfcValveType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcVector* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
-	if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); }    do { // convert the 'Orientation' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Orientation, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
-    } while(0);
-    do { // convert the 'Magnitude' argument
-        boost::shared_ptr<const DataType> arg = params[base++];
-        try { GenericConvert( in->Magnitude, arg, db ); break; }
-        catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
-    } while(0);
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVertex>(const DB& db, const LIST& params, IfcVertex* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVertexLoop>(const DB& db, const LIST& params, IfcVertexLoop* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVertexPoint>(const DB& db, const LIST& params, IfcVertexPoint* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcVertex*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVibrationIsolator>(const DB& db, const LIST& params, IfcVibrationIsolator* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVibrationIsolatorType>(const DB& db, const LIST& params, IfcVibrationIsolatorType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVirtualElement>(const DB& db, const LIST& params, IfcVirtualElement* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcVoidingFeature>(const DB& db, const LIST& params, IfcVoidingFeature* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWall>(const DB& db, const LIST& params, IfcWall* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWallElementedCase>(const DB& db, const LIST& params, IfcWallElementedCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWall*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWallStandardCase>(const DB& db, const LIST& params, IfcWallStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWall*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWallType>(const DB& db, const LIST& params, IfcWallType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWasteTerminal>(const DB& db, const LIST& params, IfcWasteTerminal* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminal*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWasteTerminalType>(const DB& db, const LIST& params, IfcWasteTerminalType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWindow>(const DB& db, const LIST& params, IfcWindow* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWindowStandardCase>(const DB& db, const LIST& params, IfcWindowStandardCase* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWindow*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWindowStyle>(const DB& db, const LIST& params, IfcWindowStyle* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWindowType>(const DB& db, const LIST& params, IfcWindowType* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkCalendar>(const DB& db, const LIST& params, IfcWorkCalendar* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkControl>(const DB& db, const LIST& params, IfcWorkControl* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkPlan>(const DB& db, const LIST& params, IfcWorkPlan* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcWorkSchedule>(const DB& db, const LIST& params, IfcWorkSchedule* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcZShapeProfileDef>(const DB& db, const LIST& params, IfcZShapeProfileDef* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-// -----------------------------------------------------------------------------------------------------------
-template <> size_t GenericFill<IfcZone>(const DB& db, const LIST& params, IfcZone* in)
-{
-	size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
-// this data structure is not used yet, so there is no code generated to fill its members
-	return base;
-}
-
-} // ! STEP
-} // ! Assimp
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.h
deleted file mode 100644
index abf0219..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCReaderGen_4.h
+++ /dev/null
@@ -1,5452 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, ASSIMP Development Team
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the ASSIMP team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the ASSIMP Development Team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** MACHINE-GENERATED by scripts/ICFImporter/CppGenerator.py */
-
-#ifndef INCLUDED_IFC_READER_GEN_H
-#define INCLUDED_IFC_READER_GEN_H
-
-#include "STEPFile.h"
-
-namespace Assimp {
-namespace IFC {
-namespace Schema_4 {
-
-	using namespace STEP;
-	using namespace STEP::EXPRESS;
-
-
-	struct NotImplemented : public ObjectHelper<NotImplemented,0> {
-
-	};
-
-
-	// ******************************************************************************
-	// IFC Custom data types
-	// ******************************************************************************
-
-
-    // C++ wrapper type for IfcStrippedOptional
-    typedef BOOLEAN IfcStrippedOptional;
-    // C++ wrapper type for IfcAbsorbedDoseMeasure
-    typedef REAL IfcAbsorbedDoseMeasure;
-    // C++ wrapper type for IfcAccelerationMeasure
-    typedef REAL IfcAccelerationMeasure;
-    // C++ wrapper type for IfcAmountOfSubstanceMeasure
-    typedef REAL IfcAmountOfSubstanceMeasure;
-    // C++ wrapper type for IfcAngularVelocityMeasure
-    typedef REAL IfcAngularVelocityMeasure;
-    // C++ wrapper type for IfcArcIndex
-    typedef ListOf< INTEGER, 3, 3 > IfcArcIndex;
-    // C++ wrapper type for IfcAreaDensityMeasure
-    typedef REAL IfcAreaDensityMeasure;
-    // C++ wrapper type for IfcAreaMeasure
-    typedef REAL IfcAreaMeasure;
-    // C++ wrapper type for IfcBoolean
-    typedef BOOLEAN IfcBoolean;
-    // C++ wrapper type for IfcBoxAlignment
-    typedef STRING IfcBoxAlignment;
-    // C++ wrapper type for IfcCardinalPointReference
-    typedef INTEGER IfcCardinalPointReference;
-    // C++ wrapper type for IfcCompoundPlaneAngleMeasure
-    typedef ListOf< INTEGER, 3, 4 > IfcCompoundPlaneAngleMeasure;
-    // C++ wrapper type for IfcContextDependentMeasure
-    typedef REAL IfcContextDependentMeasure;
-    // C++ wrapper type for IfcCountMeasure
-    typedef NUMBER IfcCountMeasure;
-    // C++ wrapper type for IfcCurvatureMeasure
-    typedef REAL IfcCurvatureMeasure;
-    // C++ wrapper type for IfcDate
-    typedef STRING IfcDate;
-    // C++ wrapper type for IfcDateTime
-    typedef STRING IfcDateTime;
-    // C++ wrapper type for IfcDayInMonthNumber
-    typedef INTEGER IfcDayInMonthNumber;
-    // C++ wrapper type for IfcDayInWeekNumber
-    typedef INTEGER IfcDayInWeekNumber;
-    // C++ wrapper type for IfcDescriptiveMeasure
-    typedef STRING IfcDescriptiveMeasure;
-    // C++ wrapper type for IfcDimensionCount
-    typedef INTEGER IfcDimensionCount;
-    // C++ wrapper type for IfcDoseEquivalentMeasure
-    typedef REAL IfcDoseEquivalentMeasure;
-    // C++ wrapper type for IfcDuration
-    typedef STRING IfcDuration;
-    // C++ wrapper type for IfcDynamicViscosityMeasure
-    typedef REAL IfcDynamicViscosityMeasure;
-    // C++ wrapper type for IfcElectricCapacitanceMeasure
-    typedef REAL IfcElectricCapacitanceMeasure;
-    // C++ wrapper type for IfcElectricChargeMeasure
-    typedef REAL IfcElectricChargeMeasure;
-    // C++ wrapper type for IfcElectricConductanceMeasure
-    typedef REAL IfcElectricConductanceMeasure;
-    // C++ wrapper type for IfcElectricCurrentMeasure
-    typedef REAL IfcElectricCurrentMeasure;
-    // C++ wrapper type for IfcElectricResistanceMeasure
-    typedef REAL IfcElectricResistanceMeasure;
-    // C++ wrapper type for IfcElectricVoltageMeasure
-    typedef REAL IfcElectricVoltageMeasure;
-    // C++ wrapper type for IfcEnergyMeasure
-    typedef REAL IfcEnergyMeasure;
-    // C++ wrapper type for IfcFontStyle
-    typedef STRING IfcFontStyle;
-    // C++ wrapper type for IfcFontVariant
-    typedef STRING IfcFontVariant;
-    // C++ wrapper type for IfcFontWeight
-    typedef STRING IfcFontWeight;
-    // C++ wrapper type for IfcForceMeasure
-    typedef REAL IfcForceMeasure;
-    // C++ wrapper type for IfcFrequencyMeasure
-    typedef REAL IfcFrequencyMeasure;
-    // C++ wrapper type for IfcGloballyUniqueId
-    typedef STRING IfcGloballyUniqueId;
-    // C++ wrapper type for IfcHeatFluxDensityMeasure
-    typedef REAL IfcHeatFluxDensityMeasure;
-    // C++ wrapper type for IfcHeatingValueMeasure
-    typedef REAL IfcHeatingValueMeasure;
-    // C++ wrapper type for IfcIdentifier
-    typedef STRING IfcIdentifier;
-    // C++ wrapper type for IfcIlluminanceMeasure
-    typedef REAL IfcIlluminanceMeasure;
-    // C++ wrapper type for IfcInductanceMeasure
-    typedef REAL IfcInductanceMeasure;
-    // C++ wrapper type for IfcInteger
-    typedef INTEGER IfcInteger;
-    // C++ wrapper type for IfcIntegerCountRateMeasure
-    typedef INTEGER IfcIntegerCountRateMeasure;
-    // C++ wrapper type for IfcIonConcentrationMeasure
-    typedef REAL IfcIonConcentrationMeasure;
-    // C++ wrapper type for IfcIsothermalMoistureCapacityMeasure
-    typedef REAL IfcIsothermalMoistureCapacityMeasure;
-    // C++ wrapper type for IfcKinematicViscosityMeasure
-    typedef REAL IfcKinematicViscosityMeasure;
-    // C++ wrapper type for IfcLabel
-    typedef STRING IfcLabel;
-    // C++ wrapper type for IfcLanguageId
-    typedef STRING IfcLanguageId;
-    // C++ wrapper type for IfcLengthMeasure
-    typedef REAL IfcLengthMeasure;
-    // C++ wrapper type for IfcLineIndex
-    typedef ListOf< INTEGER, 2, 0 > IfcLineIndex;
-    // C++ wrapper type for IfcLinearForceMeasure
-    typedef REAL IfcLinearForceMeasure;
-    // C++ wrapper type for IfcLinearMomentMeasure
-    typedef REAL IfcLinearMomentMeasure;
-    // C++ wrapper type for IfcLinearStiffnessMeasure
-    typedef REAL IfcLinearStiffnessMeasure;
-    // C++ wrapper type for IfcLinearVelocityMeasure
-    typedef REAL IfcLinearVelocityMeasure;
-    // C++ wrapper type for IfcLogical
-    typedef LOGICAL IfcLogical;
-    // C++ wrapper type for IfcLuminousFluxMeasure
-    typedef REAL IfcLuminousFluxMeasure;
-    // C++ wrapper type for IfcLuminousIntensityDistributionMeasure
-    typedef REAL IfcLuminousIntensityDistributionMeasure;
-    // C++ wrapper type for IfcLuminousIntensityMeasure
-    typedef REAL IfcLuminousIntensityMeasure;
-    // C++ wrapper type for IfcMagneticFluxDensityMeasure
-    typedef REAL IfcMagneticFluxDensityMeasure;
-    // C++ wrapper type for IfcMagneticFluxMeasure
-    typedef REAL IfcMagneticFluxMeasure;
-    // C++ wrapper type for IfcMassDensityMeasure
-    typedef REAL IfcMassDensityMeasure;
-    // C++ wrapper type for IfcMassFlowRateMeasure
-    typedef REAL IfcMassFlowRateMeasure;
-    // C++ wrapper type for IfcMassMeasure
-    typedef REAL IfcMassMeasure;
-    // C++ wrapper type for IfcMassPerLengthMeasure
-    typedef REAL IfcMassPerLengthMeasure;
-    // C++ wrapper type for IfcModulusOfElasticityMeasure
-    typedef REAL IfcModulusOfElasticityMeasure;
-    // C++ wrapper type for IfcModulusOfLinearSubgradeReactionMeasure
-    typedef REAL IfcModulusOfLinearSubgradeReactionMeasure;
-    // C++ wrapper type for IfcModulusOfRotationalSubgradeReactionMeasure
-    typedef REAL IfcModulusOfRotationalSubgradeReactionMeasure;
-    // C++ wrapper type for IfcModulusOfSubgradeReactionMeasure
-    typedef REAL IfcModulusOfSubgradeReactionMeasure;
-    // C++ wrapper type for IfcMoistureDiffusivityMeasure
-    typedef REAL IfcMoistureDiffusivityMeasure;
-    // C++ wrapper type for IfcMolecularWeightMeasure
-    typedef REAL IfcMolecularWeightMeasure;
-    // C++ wrapper type for IfcMomentOfInertiaMeasure
-    typedef REAL IfcMomentOfInertiaMeasure;
-    // C++ wrapper type for IfcMonetaryMeasure
-    typedef REAL IfcMonetaryMeasure;
-    // C++ wrapper type for IfcMonthInYearNumber
-    typedef INTEGER IfcMonthInYearNumber;
-    // C++ wrapper type for IfcNonNegativeLengthMeasure
-    typedef REAL IfcNonNegativeLengthMeasure;
-    // C++ wrapper type for IfcNormalisedRatioMeasure
-    typedef REAL IfcNormalisedRatioMeasure;
-    // C++ wrapper type for IfcNumericMeasure
-    typedef NUMBER IfcNumericMeasure;
-    // C++ wrapper type for IfcPHMeasure
-    typedef REAL IfcPHMeasure;
-    // C++ wrapper type for IfcParameterValue
-    typedef REAL IfcParameterValue;
-    // C++ wrapper type for IfcPlanarForceMeasure
-    typedef REAL IfcPlanarForceMeasure;
-    // C++ wrapper type for IfcPlaneAngleMeasure
-    typedef REAL IfcPlaneAngleMeasure;
-    // C++ wrapper type for IfcPositiveInteger
-    typedef INTEGER IfcPositiveInteger;
-    // C++ wrapper type for IfcPositiveLengthMeasure
-    typedef REAL IfcPositiveLengthMeasure;
-    // C++ wrapper type for IfcPositivePlaneAngleMeasure
-    typedef REAL IfcPositivePlaneAngleMeasure;
-    // C++ wrapper type for IfcPositiveRatioMeasure
-    typedef REAL IfcPositiveRatioMeasure;
-    // C++ wrapper type for IfcPowerMeasure
-    typedef REAL IfcPowerMeasure;
-    // C++ wrapper type for IfcPresentableText
-    typedef STRING IfcPresentableText;
-    // C++ wrapper type for IfcPressureMeasure
-    typedef REAL IfcPressureMeasure;
-    // C++ wrapper type for IfcRadioActivityMeasure
-    typedef REAL IfcRadioActivityMeasure;
-    // C++ wrapper type for IfcRatioMeasure
-    typedef REAL IfcRatioMeasure;
-    // C++ wrapper type for IfcReal
-    typedef REAL IfcReal;
-    // C++ wrapper type for IfcRotationalFrequencyMeasure
-    typedef REAL IfcRotationalFrequencyMeasure;
-    // C++ wrapper type for IfcRotationalMassMeasure
-    typedef REAL IfcRotationalMassMeasure;
-    // C++ wrapper type for IfcRotationalStiffnessMeasure
-    typedef REAL IfcRotationalStiffnessMeasure;
-    // C++ wrapper type for IfcSectionModulusMeasure
-    typedef REAL IfcSectionModulusMeasure;
-    // C++ wrapper type for IfcSectionalAreaIntegralMeasure
-    typedef REAL IfcSectionalAreaIntegralMeasure;
-    // C++ wrapper type for IfcShearModulusMeasure
-    typedef REAL IfcShearModulusMeasure;
-    // C++ wrapper type for IfcSolidAngleMeasure
-    typedef REAL IfcSolidAngleMeasure;
-    // C++ wrapper type for IfcSoundPowerLevelMeasure
-    typedef REAL IfcSoundPowerLevelMeasure;
-    // C++ wrapper type for IfcSoundPowerMeasure
-    typedef REAL IfcSoundPowerMeasure;
-    // C++ wrapper type for IfcSoundPressureLevelMeasure
-    typedef REAL IfcSoundPressureLevelMeasure;
-    // C++ wrapper type for IfcSoundPressureMeasure
-    typedef REAL IfcSoundPressureMeasure;
-    // C++ wrapper type for IfcSpecificHeatCapacityMeasure
-    typedef REAL IfcSpecificHeatCapacityMeasure;
-    // C++ wrapper type for IfcSpecularExponent
-    typedef REAL IfcSpecularExponent;
-    // C++ wrapper type for IfcSpecularRoughness
-    typedef REAL IfcSpecularRoughness;
-    // C++ wrapper type for IfcTemperatureGradientMeasure
-    typedef REAL IfcTemperatureGradientMeasure;
-    // C++ wrapper type for IfcTemperatureRateOfChangeMeasure
-    typedef REAL IfcTemperatureRateOfChangeMeasure;
-    // C++ wrapper type for IfcText
-    typedef STRING IfcText;
-    // C++ wrapper type for IfcTextAlignment
-    typedef STRING IfcTextAlignment;
-    // C++ wrapper type for IfcTextDecoration
-    typedef STRING IfcTextDecoration;
-    // C++ wrapper type for IfcTextFontName
-    typedef STRING IfcTextFontName;
-    // C++ wrapper type for IfcTextTransformation
-    typedef STRING IfcTextTransformation;
-    // C++ wrapper type for IfcThermalAdmittanceMeasure
-    typedef REAL IfcThermalAdmittanceMeasure;
-    // C++ wrapper type for IfcThermalConductivityMeasure
-    typedef REAL IfcThermalConductivityMeasure;
-    // C++ wrapper type for IfcThermalExpansionCoefficientMeasure
-    typedef REAL IfcThermalExpansionCoefficientMeasure;
-    // C++ wrapper type for IfcThermalResistanceMeasure
-    typedef REAL IfcThermalResistanceMeasure;
-    // C++ wrapper type for IfcThermalTransmittanceMeasure
-    typedef REAL IfcThermalTransmittanceMeasure;
-    // C++ wrapper type for IfcThermodynamicTemperatureMeasure
-    typedef REAL IfcThermodynamicTemperatureMeasure;
-    // C++ wrapper type for IfcTime
-    typedef STRING IfcTime;
-    // C++ wrapper type for IfcTimeMeasure
-    typedef REAL IfcTimeMeasure;
-    // C++ wrapper type for IfcTimeStamp
-    typedef INTEGER IfcTimeStamp;
-    // C++ wrapper type for IfcTorqueMeasure
-    typedef REAL IfcTorqueMeasure;
-    // C++ wrapper type for IfcURIReference
-    typedef STRING IfcURIReference;
-    // C++ wrapper type for IfcVaporPermeabilityMeasure
-    typedef REAL IfcVaporPermeabilityMeasure;
-    // C++ wrapper type for IfcVolumeMeasure
-    typedef REAL IfcVolumeMeasure;
-    // C++ wrapper type for IfcVolumetricFlowRateMeasure
-    typedef REAL IfcVolumetricFlowRateMeasure;
-    // C++ wrapper type for IfcWarpingConstantMeasure
-    typedef REAL IfcWarpingConstantMeasure;
-    // C++ wrapper type for IfcWarpingMomentMeasure
-    typedef REAL IfcWarpingMomentMeasure;
-    // C++ wrapper type for IfcActionRequestTypeEnum
-    typedef ENUMERATION IfcActionRequestTypeEnum;
-    // C++ wrapper type for IfcActionSourceTypeEnum
-    typedef ENUMERATION IfcActionSourceTypeEnum;
-    // C++ wrapper type for IfcActionTypeEnum
-    typedef ENUMERATION IfcActionTypeEnum;
-    // C++ wrapper type for IfcActuatorTypeEnum
-    typedef ENUMERATION IfcActuatorTypeEnum;
-    // C++ wrapper type for IfcAddressTypeEnum
-    typedef ENUMERATION IfcAddressTypeEnum;
-    // C++ wrapper type for IfcAirTerminalBoxTypeEnum
-    typedef ENUMERATION IfcAirTerminalBoxTypeEnum;
-    // C++ wrapper type for IfcAirTerminalTypeEnum
-    typedef ENUMERATION IfcAirTerminalTypeEnum;
-    // C++ wrapper type for IfcAirToAirHeatRecoveryTypeEnum
-    typedef ENUMERATION IfcAirToAirHeatRecoveryTypeEnum;
-    // C++ wrapper type for IfcAlarmTypeEnum
-    typedef ENUMERATION IfcAlarmTypeEnum;
-    // C++ wrapper type for IfcAnalysisModelTypeEnum
-    typedef ENUMERATION IfcAnalysisModelTypeEnum;
-    // C++ wrapper type for IfcAnalysisTheoryTypeEnum
-    typedef ENUMERATION IfcAnalysisTheoryTypeEnum;
-    // C++ wrapper type for IfcArithmeticOperatorEnum
-    typedef ENUMERATION IfcArithmeticOperatorEnum;
-    // C++ wrapper type for IfcAssemblyPlaceEnum
-    typedef ENUMERATION IfcAssemblyPlaceEnum;
-    // C++ wrapper type for IfcAudioVisualApplianceTypeEnum
-    typedef ENUMERATION IfcAudioVisualApplianceTypeEnum;
-    // C++ wrapper type for IfcBSplineCurveForm
-    typedef ENUMERATION IfcBSplineCurveForm;
-    // C++ wrapper type for IfcBSplineSurfaceForm
-    typedef ENUMERATION IfcBSplineSurfaceForm;
-    // C++ wrapper type for IfcBeamTypeEnum
-    typedef ENUMERATION IfcBeamTypeEnum;
-    // C++ wrapper type for IfcBenchmarkEnum
-    typedef ENUMERATION IfcBenchmarkEnum;
-    // C++ wrapper type for IfcBoilerTypeEnum
-    typedef ENUMERATION IfcBoilerTypeEnum;
-    // C++ wrapper type for IfcBooleanOperator
-    typedef ENUMERATION IfcBooleanOperator;
-    // C++ wrapper type for IfcBuildingElementPartTypeEnum
-    typedef ENUMERATION IfcBuildingElementPartTypeEnum;
-    // C++ wrapper type for IfcBuildingElementProxyTypeEnum
-    typedef ENUMERATION IfcBuildingElementProxyTypeEnum;
-    // C++ wrapper type for IfcBuildingSystemTypeEnum
-    typedef ENUMERATION IfcBuildingSystemTypeEnum;
-    // C++ wrapper type for IfcBurnerTypeEnum
-    typedef ENUMERATION IfcBurnerTypeEnum;
-    // C++ wrapper type for IfcCableCarrierFittingTypeEnum
-    typedef ENUMERATION IfcCableCarrierFittingTypeEnum;
-    // C++ wrapper type for IfcCableCarrierSegmentTypeEnum
-    typedef ENUMERATION IfcCableCarrierSegmentTypeEnum;
-    // C++ wrapper type for IfcCableFittingTypeEnum
-    typedef ENUMERATION IfcCableFittingTypeEnum;
-    // C++ wrapper type for IfcCableSegmentTypeEnum
-    typedef ENUMERATION IfcCableSegmentTypeEnum;
-    // C++ wrapper type for IfcChangeActionEnum
-    typedef ENUMERATION IfcChangeActionEnum;
-    // C++ wrapper type for IfcChillerTypeEnum
-    typedef ENUMERATION IfcChillerTypeEnum;
-    // C++ wrapper type for IfcChimneyTypeEnum
-    typedef ENUMERATION IfcChimneyTypeEnum;
-    // C++ wrapper type for IfcCoilTypeEnum
-    typedef ENUMERATION IfcCoilTypeEnum;
-    // C++ wrapper type for IfcColumnTypeEnum
-    typedef ENUMERATION IfcColumnTypeEnum;
-    // C++ wrapper type for IfcCommunicationsApplianceTypeEnum
-    typedef ENUMERATION IfcCommunicationsApplianceTypeEnum;
-    // C++ wrapper type for IfcComplexPropertyTemplateTypeEnum
-    typedef ENUMERATION IfcComplexPropertyTemplateTypeEnum;
-    // C++ wrapper type for IfcCompressorTypeEnum
-    typedef ENUMERATION IfcCompressorTypeEnum;
-    // C++ wrapper type for IfcCondenserTypeEnum
-    typedef ENUMERATION IfcCondenserTypeEnum;
-    // C++ wrapper type for IfcConnectionTypeEnum
-    typedef ENUMERATION IfcConnectionTypeEnum;
-    // C++ wrapper type for IfcConstraintEnum
-    typedef ENUMERATION IfcConstraintEnum;
-    // C++ wrapper type for IfcConstructionEquipmentResourceTypeEnum
-    typedef ENUMERATION IfcConstructionEquipmentResourceTypeEnum;
-    // C++ wrapper type for IfcConstructionMaterialResourceTypeEnum
-    typedef ENUMERATION IfcConstructionMaterialResourceTypeEnum;
-    // C++ wrapper type for IfcConstructionProductResourceTypeEnum
-    typedef ENUMERATION IfcConstructionProductResourceTypeEnum;
-    // C++ wrapper type for IfcControllerTypeEnum
-    typedef ENUMERATION IfcControllerTypeEnum;
-    // C++ wrapper type for IfcCooledBeamTypeEnum
-    typedef ENUMERATION IfcCooledBeamTypeEnum;
-    // C++ wrapper type for IfcCoolingTowerTypeEnum
-    typedef ENUMERATION IfcCoolingTowerTypeEnum;
-    // C++ wrapper type for IfcCostItemTypeEnum
-    typedef ENUMERATION IfcCostItemTypeEnum;
-    // C++ wrapper type for IfcCostScheduleTypeEnum
-    typedef ENUMERATION IfcCostScheduleTypeEnum;
-    // C++ wrapper type for IfcCoveringTypeEnum
-    typedef ENUMERATION IfcCoveringTypeEnum;
-    // C++ wrapper type for IfcCrewResourceTypeEnum
-    typedef ENUMERATION IfcCrewResourceTypeEnum;
-    // C++ wrapper type for IfcCurtainWallTypeEnum
-    typedef ENUMERATION IfcCurtainWallTypeEnum;
-    // C++ wrapper type for IfcCurveInterpolationEnum
-    typedef ENUMERATION IfcCurveInterpolationEnum;
-    // C++ wrapper type for IfcDamperTypeEnum
-    typedef ENUMERATION IfcDamperTypeEnum;
-    // C++ wrapper type for IfcDataOriginEnum
-    typedef ENUMERATION IfcDataOriginEnum;
-    // C++ wrapper type for IfcDerivedUnitEnum
-    typedef ENUMERATION IfcDerivedUnitEnum;
-    // C++ wrapper type for IfcDirectionSenseEnum
-    typedef ENUMERATION IfcDirectionSenseEnum;
-    // C++ wrapper type for IfcDiscreteAccessoryTypeEnum
-    typedef ENUMERATION IfcDiscreteAccessoryTypeEnum;
-    // C++ wrapper type for IfcDistributionChamberElementTypeEnum
-    typedef ENUMERATION IfcDistributionChamberElementTypeEnum;
-    // C++ wrapper type for IfcDistributionPortTypeEnum
-    typedef ENUMERATION IfcDistributionPortTypeEnum;
-    // C++ wrapper type for IfcDistributionSystemEnum
-    typedef ENUMERATION IfcDistributionSystemEnum;
-    // C++ wrapper type for IfcDocumentConfidentialityEnum
-    typedef ENUMERATION IfcDocumentConfidentialityEnum;
-    // C++ wrapper type for IfcDocumentStatusEnum
-    typedef ENUMERATION IfcDocumentStatusEnum;
-    // C++ wrapper type for IfcDoorPanelOperationEnum
-    typedef ENUMERATION IfcDoorPanelOperationEnum;
-    // C++ wrapper type for IfcDoorPanelPositionEnum
-    typedef ENUMERATION IfcDoorPanelPositionEnum;
-    // C++ wrapper type for IfcDoorStyleConstructionEnum
-    typedef ENUMERATION IfcDoorStyleConstructionEnum;
-    // C++ wrapper type for IfcDoorStyleOperationEnum
-    typedef ENUMERATION IfcDoorStyleOperationEnum;
-    // C++ wrapper type for IfcDoorTypeEnum
-    typedef ENUMERATION IfcDoorTypeEnum;
-    // C++ wrapper type for IfcDoorTypeOperationEnum
-    typedef ENUMERATION IfcDoorTypeOperationEnum;
-    // C++ wrapper type for IfcDuctFittingTypeEnum
-    typedef ENUMERATION IfcDuctFittingTypeEnum;
-    // C++ wrapper type for IfcDuctSegmentTypeEnum
-    typedef ENUMERATION IfcDuctSegmentTypeEnum;
-    // C++ wrapper type for IfcDuctSilencerTypeEnum
-    typedef ENUMERATION IfcDuctSilencerTypeEnum;
-    // C++ wrapper type for IfcElectricApplianceTypeEnum
-    typedef ENUMERATION IfcElectricApplianceTypeEnum;
-    // C++ wrapper type for IfcElectricDistributionBoardTypeEnum
-    typedef ENUMERATION IfcElectricDistributionBoardTypeEnum;
-    // C++ wrapper type for IfcElectricFlowStorageDeviceTypeEnum
-    typedef ENUMERATION IfcElectricFlowStorageDeviceTypeEnum;
-    // C++ wrapper type for IfcElectricGeneratorTypeEnum
-    typedef ENUMERATION IfcElectricGeneratorTypeEnum;
-    // C++ wrapper type for IfcElectricMotorTypeEnum
-    typedef ENUMERATION IfcElectricMotorTypeEnum;
-    // C++ wrapper type for IfcElectricTimeControlTypeEnum
-    typedef ENUMERATION IfcElectricTimeControlTypeEnum;
-    // C++ wrapper type for IfcElementAssemblyTypeEnum
-    typedef ENUMERATION IfcElementAssemblyTypeEnum;
-    // C++ wrapper type for IfcElementCompositionEnum
-    typedef ENUMERATION IfcElementCompositionEnum;
-    // C++ wrapper type for IfcEngineTypeEnum
-    typedef ENUMERATION IfcEngineTypeEnum;
-    // C++ wrapper type for IfcEvaporativeCoolerTypeEnum
-    typedef ENUMERATION IfcEvaporativeCoolerTypeEnum;
-    // C++ wrapper type for IfcEvaporatorTypeEnum
-    typedef ENUMERATION IfcEvaporatorTypeEnum;
-    // C++ wrapper type for IfcEventTriggerTypeEnum
-    typedef ENUMERATION IfcEventTriggerTypeEnum;
-    // C++ wrapper type for IfcEventTypeEnum
-    typedef ENUMERATION IfcEventTypeEnum;
-    // C++ wrapper type for IfcExternalSpatialElementTypeEnum
-    typedef ENUMERATION IfcExternalSpatialElementTypeEnum;
-    // C++ wrapper type for IfcFanTypeEnum
-    typedef ENUMERATION IfcFanTypeEnum;
-    // C++ wrapper type for IfcFastenerTypeEnum
-    typedef ENUMERATION IfcFastenerTypeEnum;
-    // C++ wrapper type for IfcFilterTypeEnum
-    typedef ENUMERATION IfcFilterTypeEnum;
-    // C++ wrapper type for IfcFireSuppressionTerminalTypeEnum
-    typedef ENUMERATION IfcFireSuppressionTerminalTypeEnum;
-    // C++ wrapper type for IfcFlowDirectionEnum
-    typedef ENUMERATION IfcFlowDirectionEnum;
-    // C++ wrapper type for IfcFlowInstrumentTypeEnum
-    typedef ENUMERATION IfcFlowInstrumentTypeEnum;
-    // C++ wrapper type for IfcFlowMeterTypeEnum
-    typedef ENUMERATION IfcFlowMeterTypeEnum;
-    // C++ wrapper type for IfcFootingTypeEnum
-    typedef ENUMERATION IfcFootingTypeEnum;
-    // C++ wrapper type for IfcFurnitureTypeEnum
-    typedef ENUMERATION IfcFurnitureTypeEnum;
-    // C++ wrapper type for IfcGeographicElementTypeEnum
-    typedef ENUMERATION IfcGeographicElementTypeEnum;
-    // C++ wrapper type for IfcGeometricProjectionEnum
-    typedef ENUMERATION IfcGeometricProjectionEnum;
-    // C++ wrapper type for IfcGlobalOrLocalEnum
-    typedef ENUMERATION IfcGlobalOrLocalEnum;
-    // C++ wrapper type for IfcGridTypeEnum
-    typedef ENUMERATION IfcGridTypeEnum;
-    // C++ wrapper type for IfcHeatExchangerTypeEnum
-    typedef ENUMERATION IfcHeatExchangerTypeEnum;
-    // C++ wrapper type for IfcHumidifierTypeEnum
-    typedef ENUMERATION IfcHumidifierTypeEnum;
-    // C++ wrapper type for IfcInterceptorTypeEnum
-    typedef ENUMERATION IfcInterceptorTypeEnum;
-    // C++ wrapper type for IfcInternalOrExternalEnum
-    typedef ENUMERATION IfcInternalOrExternalEnum;
-    // C++ wrapper type for IfcInventoryTypeEnum
-    typedef ENUMERATION IfcInventoryTypeEnum;
-    // C++ wrapper type for IfcJunctionBoxTypeEnum
-    typedef ENUMERATION IfcJunctionBoxTypeEnum;
-    // C++ wrapper type for IfcKnotType
-    typedef ENUMERATION IfcKnotType;
-    // C++ wrapper type for IfcLaborResourceTypeEnum
-    typedef ENUMERATION IfcLaborResourceTypeEnum;
-    // C++ wrapper type for IfcLampTypeEnum
-    typedef ENUMERATION IfcLampTypeEnum;
-    // C++ wrapper type for IfcLayerSetDirectionEnum
-    typedef ENUMERATION IfcLayerSetDirectionEnum;
-    // C++ wrapper type for IfcLightDistributionCurveEnum
-    typedef ENUMERATION IfcLightDistributionCurveEnum;
-    // C++ wrapper type for IfcLightEmissionSourceEnum
-    typedef ENUMERATION IfcLightEmissionSourceEnum;
-    // C++ wrapper type for IfcLightFixtureTypeEnum
-    typedef ENUMERATION IfcLightFixtureTypeEnum;
-    // C++ wrapper type for IfcLoadGroupTypeEnum
-    typedef ENUMERATION IfcLoadGroupTypeEnum;
-    // C++ wrapper type for IfcLogicalOperatorEnum
-    typedef ENUMERATION IfcLogicalOperatorEnum;
-    // C++ wrapper type for IfcMechanicalFastenerTypeEnum
-    typedef ENUMERATION IfcMechanicalFastenerTypeEnum;
-    // C++ wrapper type for IfcMedicalDeviceTypeEnum
-    typedef ENUMERATION IfcMedicalDeviceTypeEnum;
-    // C++ wrapper type for IfcMemberTypeEnum
-    typedef ENUMERATION IfcMemberTypeEnum;
-    // C++ wrapper type for IfcMotorConnectionTypeEnum
-    typedef ENUMERATION IfcMotorConnectionTypeEnum;
-    // C++ wrapper type for IfcNullStyle
-    typedef ENUMERATION IfcNullStyle;
-    // C++ wrapper type for IfcObjectTypeEnum
-    typedef ENUMERATION IfcObjectTypeEnum;
-    // C++ wrapper type for IfcObjectiveEnum
-    typedef ENUMERATION IfcObjectiveEnum;
-    // C++ wrapper type for IfcOccupantTypeEnum
-    typedef ENUMERATION IfcOccupantTypeEnum;
-    // C++ wrapper type for IfcOpeningElementTypeEnum
-    typedef ENUMERATION IfcOpeningElementTypeEnum;
-    // C++ wrapper type for IfcOutletTypeEnum
-    typedef ENUMERATION IfcOutletTypeEnum;
-    // C++ wrapper type for IfcPerformanceHistoryTypeEnum
-    typedef ENUMERATION IfcPerformanceHistoryTypeEnum;
-    // C++ wrapper type for IfcPermeableCoveringOperationEnum
-    typedef ENUMERATION IfcPermeableCoveringOperationEnum;
-    // C++ wrapper type for IfcPermitTypeEnum
-    typedef ENUMERATION IfcPermitTypeEnum;
-    // C++ wrapper type for IfcPhysicalOrVirtualEnum
-    typedef ENUMERATION IfcPhysicalOrVirtualEnum;
-    // C++ wrapper type for IfcPileConstructionEnum
-    typedef ENUMERATION IfcPileConstructionEnum;
-    // C++ wrapper type for IfcPileTypeEnum
-    typedef ENUMERATION IfcPileTypeEnum;
-    // C++ wrapper type for IfcPipeFittingTypeEnum
-    typedef ENUMERATION IfcPipeFittingTypeEnum;
-    // C++ wrapper type for IfcPipeSegmentTypeEnum
-    typedef ENUMERATION IfcPipeSegmentTypeEnum;
-    // C++ wrapper type for IfcPlateTypeEnum
-    typedef ENUMERATION IfcPlateTypeEnum;
-    // C++ wrapper type for IfcPreferredSurfaceCurveRepresentation
-    typedef ENUMERATION IfcPreferredSurfaceCurveRepresentation;
-    // C++ wrapper type for IfcProcedureTypeEnum
-    typedef ENUMERATION IfcProcedureTypeEnum;
-    // C++ wrapper type for IfcProfileTypeEnum
-    typedef ENUMERATION IfcProfileTypeEnum;
-    // C++ wrapper type for IfcProjectOrderTypeEnum
-    typedef ENUMERATION IfcProjectOrderTypeEnum;
-    // C++ wrapper type for IfcProjectedOrTrueLengthEnum
-    typedef ENUMERATION IfcProjectedOrTrueLengthEnum;
-    // C++ wrapper type for IfcProjectionElementTypeEnum
-    typedef ENUMERATION IfcProjectionElementTypeEnum;
-    // C++ wrapper type for IfcPropertySetTemplateTypeEnum
-    typedef ENUMERATION IfcPropertySetTemplateTypeEnum;
-    // C++ wrapper type for IfcProtectiveDeviceTrippingUnitTypeEnum
-    typedef ENUMERATION IfcProtectiveDeviceTrippingUnitTypeEnum;
-    // C++ wrapper type for IfcProtectiveDeviceTypeEnum
-    typedef ENUMERATION IfcProtectiveDeviceTypeEnum;
-    // C++ wrapper type for IfcPumpTypeEnum
-    typedef ENUMERATION IfcPumpTypeEnum;
-    // C++ wrapper type for IfcRailingTypeEnum
-    typedef ENUMERATION IfcRailingTypeEnum;
-    // C++ wrapper type for IfcRampFlightTypeEnum
-    typedef ENUMERATION IfcRampFlightTypeEnum;
-    // C++ wrapper type for IfcRampTypeEnum
-    typedef ENUMERATION IfcRampTypeEnum;
-    // C++ wrapper type for IfcRecurrenceTypeEnum
-    typedef ENUMERATION IfcRecurrenceTypeEnum;
-    // C++ wrapper type for IfcReflectanceMethodEnum
-    typedef ENUMERATION IfcReflectanceMethodEnum;
-    // C++ wrapper type for IfcReinforcingBarRoleEnum
-    typedef ENUMERATION IfcReinforcingBarRoleEnum;
-    // C++ wrapper type for IfcReinforcingBarSurfaceEnum
-    typedef ENUMERATION IfcReinforcingBarSurfaceEnum;
-    // C++ wrapper type for IfcReinforcingBarTypeEnum
-    typedef ENUMERATION IfcReinforcingBarTypeEnum;
-    // C++ wrapper type for IfcReinforcingMeshTypeEnum
-    typedef ENUMERATION IfcReinforcingMeshTypeEnum;
-    // C++ wrapper type for IfcRoleEnum
-    typedef ENUMERATION IfcRoleEnum;
-    // C++ wrapper type for IfcRoofTypeEnum
-    typedef ENUMERATION IfcRoofTypeEnum;
-    // C++ wrapper type for IfcSIPrefix
-    typedef ENUMERATION IfcSIPrefix;
-    // C++ wrapper type for IfcSIUnitName
-    typedef ENUMERATION IfcSIUnitName;
-    // C++ wrapper type for IfcSanitaryTerminalTypeEnum
-    typedef ENUMERATION IfcSanitaryTerminalTypeEnum;
-    // C++ wrapper type for IfcSectionTypeEnum
-    typedef ENUMERATION IfcSectionTypeEnum;
-    // C++ wrapper type for IfcSensorTypeEnum
-    typedef ENUMERATION IfcSensorTypeEnum;
-    // C++ wrapper type for IfcSequenceEnum
-    typedef ENUMERATION IfcSequenceEnum;
-    // C++ wrapper type for IfcShadingDeviceTypeEnum
-    typedef ENUMERATION IfcShadingDeviceTypeEnum;
-    // C++ wrapper type for IfcSimplePropertyTemplateTypeEnum
-    typedef ENUMERATION IfcSimplePropertyTemplateTypeEnum;
-    // C++ wrapper type for IfcSlabTypeEnum
-    typedef ENUMERATION IfcSlabTypeEnum;
-    // C++ wrapper type for IfcSolarDeviceTypeEnum
-    typedef ENUMERATION IfcSolarDeviceTypeEnum;
-    // C++ wrapper type for IfcSpaceHeaterTypeEnum
-    typedef ENUMERATION IfcSpaceHeaterTypeEnum;
-    // C++ wrapper type for IfcSpaceTypeEnum
-    typedef ENUMERATION IfcSpaceTypeEnum;
-    // C++ wrapper type for IfcSpatialZoneTypeEnum
-    typedef ENUMERATION IfcSpatialZoneTypeEnum;
-    // C++ wrapper type for IfcStackTerminalTypeEnum
-    typedef ENUMERATION IfcStackTerminalTypeEnum;
-    // C++ wrapper type for IfcStairFlightTypeEnum
-    typedef ENUMERATION IfcStairFlightTypeEnum;
-    // C++ wrapper type for IfcStairTypeEnum
-    typedef ENUMERATION IfcStairTypeEnum;
-    // C++ wrapper type for IfcStateEnum
-    typedef ENUMERATION IfcStateEnum;
-    // C++ wrapper type for IfcStructuralCurveActivityTypeEnum
-    typedef ENUMERATION IfcStructuralCurveActivityTypeEnum;
-    // C++ wrapper type for IfcStructuralCurveMemberTypeEnum
-    typedef ENUMERATION IfcStructuralCurveMemberTypeEnum;
-    // C++ wrapper type for IfcStructuralSurfaceActivityTypeEnum
-    typedef ENUMERATION IfcStructuralSurfaceActivityTypeEnum;
-    // C++ wrapper type for IfcStructuralSurfaceMemberTypeEnum
-    typedef ENUMERATION IfcStructuralSurfaceMemberTypeEnum;
-    // C++ wrapper type for IfcSubContractResourceTypeEnum
-    typedef ENUMERATION IfcSubContractResourceTypeEnum;
-    // C++ wrapper type for IfcSurfaceFeatureTypeEnum
-    typedef ENUMERATION IfcSurfaceFeatureTypeEnum;
-    // C++ wrapper type for IfcSurfaceSide
-    typedef ENUMERATION IfcSurfaceSide;
-    // C++ wrapper type for IfcSwitchingDeviceTypeEnum
-    typedef ENUMERATION IfcSwitchingDeviceTypeEnum;
-    // C++ wrapper type for IfcSystemFurnitureElementTypeEnum
-    typedef ENUMERATION IfcSystemFurnitureElementTypeEnum;
-    // C++ wrapper type for IfcTankTypeEnum
-    typedef ENUMERATION IfcTankTypeEnum;
-    // C++ wrapper type for IfcTaskDurationEnum
-    typedef ENUMERATION IfcTaskDurationEnum;
-    // C++ wrapper type for IfcTaskTypeEnum
-    typedef ENUMERATION IfcTaskTypeEnum;
-    // C++ wrapper type for IfcTendonAnchorTypeEnum
-    typedef ENUMERATION IfcTendonAnchorTypeEnum;
-    // C++ wrapper type for IfcTendonTypeEnum
-    typedef ENUMERATION IfcTendonTypeEnum;
-    // C++ wrapper type for IfcTextPath
-    typedef ENUMERATION IfcTextPath;
-    // C++ wrapper type for IfcTimeSeriesDataTypeEnum
-    typedef ENUMERATION IfcTimeSeriesDataTypeEnum;
-    // C++ wrapper type for IfcTransformerTypeEnum
-    typedef ENUMERATION IfcTransformerTypeEnum;
-    // C++ wrapper type for IfcTransitionCode
-    typedef ENUMERATION IfcTransitionCode;
-    // C++ wrapper type for IfcTransportElementTypeEnum
-    typedef ENUMERATION IfcTransportElementTypeEnum;
-    // C++ wrapper type for IfcTrimmingPreference
-    typedef ENUMERATION IfcTrimmingPreference;
-    // C++ wrapper type for IfcTubeBundleTypeEnum
-    typedef ENUMERATION IfcTubeBundleTypeEnum;
-    // C++ wrapper type for IfcUnitEnum
-    typedef ENUMERATION IfcUnitEnum;
-    // C++ wrapper type for IfcUnitaryControlElementTypeEnum
-    typedef ENUMERATION IfcUnitaryControlElementTypeEnum;
-    // C++ wrapper type for IfcUnitaryEquipmentTypeEnum
-    typedef ENUMERATION IfcUnitaryEquipmentTypeEnum;
-    // C++ wrapper type for IfcValveTypeEnum
-    typedef ENUMERATION IfcValveTypeEnum;
-    // C++ wrapper type for IfcVibrationIsolatorTypeEnum
-    typedef ENUMERATION IfcVibrationIsolatorTypeEnum;
-    // C++ wrapper type for IfcVoidingFeatureTypeEnum
-    typedef ENUMERATION IfcVoidingFeatureTypeEnum;
-    // C++ wrapper type for IfcWallTypeEnum
-    typedef ENUMERATION IfcWallTypeEnum;
-    // C++ wrapper type for IfcWasteTerminalTypeEnum
-    typedef ENUMERATION IfcWasteTerminalTypeEnum;
-    // C++ wrapper type for IfcWindowPanelOperationEnum
-    typedef ENUMERATION IfcWindowPanelOperationEnum;
-    // C++ wrapper type for IfcWindowPanelPositionEnum
-    typedef ENUMERATION IfcWindowPanelPositionEnum;
-    // C++ wrapper type for IfcWindowStyleConstructionEnum
-    typedef ENUMERATION IfcWindowStyleConstructionEnum;
-    // C++ wrapper type for IfcWindowStyleOperationEnum
-    typedef ENUMERATION IfcWindowStyleOperationEnum;
-    // C++ wrapper type for IfcWindowTypeEnum
-    typedef ENUMERATION IfcWindowTypeEnum;
-    // C++ wrapper type for IfcWindowTypePartitioningEnum
-    typedef ENUMERATION IfcWindowTypePartitioningEnum;
-    // C++ wrapper type for IfcWorkCalendarTypeEnum
-    typedef ENUMERATION IfcWorkCalendarTypeEnum;
-    // C++ wrapper type for IfcWorkPlanTypeEnum
-    typedef ENUMERATION IfcWorkPlanTypeEnum;
-    // C++ wrapper type for IfcWorkScheduleTypeEnum
-    typedef ENUMERATION IfcWorkScheduleTypeEnum;
-    // C++ wrapper type for IfcActorSelect
-    typedef SELECT IfcActorSelect;
-    // C++ wrapper type for IfcAppliedValueSelect
-    typedef SELECT IfcAppliedValueSelect;
-    // C++ wrapper type for IfcAxis2Placement
-    typedef SELECT IfcAxis2Placement;
-    // C++ wrapper type for IfcBendingParameterSelect
-    typedef SELECT IfcBendingParameterSelect;
-    // C++ wrapper type for IfcBooleanOperand
-    typedef SELECT IfcBooleanOperand;
-    // C++ wrapper type for IfcClassificationReferenceSelect
-    typedef SELECT IfcClassificationReferenceSelect;
-    // C++ wrapper type for IfcClassificationSelect
-    typedef SELECT IfcClassificationSelect;
-    // C++ wrapper type for IfcColour
-    typedef SELECT IfcColour;
-    // C++ wrapper type for IfcColourOrFactor
-    typedef SELECT IfcColourOrFactor;
-    // C++ wrapper type for IfcCoordinateReferenceSystemSelect
-    typedef SELECT IfcCoordinateReferenceSystemSelect;
-    // C++ wrapper type for IfcCsgSelect
-    typedef SELECT IfcCsgSelect;
-    // C++ wrapper type for IfcCurveFontOrScaledCurveFontSelect
-    typedef SELECT IfcCurveFontOrScaledCurveFontSelect;
-    // C++ wrapper type for IfcCurveOnSurface
-    typedef SELECT IfcCurveOnSurface;
-    // C++ wrapper type for IfcCurveOrEdgeCurve
-    typedef SELECT IfcCurveOrEdgeCurve;
-    // C++ wrapper type for IfcCurveStyleFontSelect
-    typedef SELECT IfcCurveStyleFontSelect;
-    // C++ wrapper type for IfcDefinitionSelect
-    typedef SELECT IfcDefinitionSelect;
-    // C++ wrapper type for IfcDerivedMeasureValue
-    typedef SELECT IfcDerivedMeasureValue;
-    // C++ wrapper type for IfcDocumentSelect
-    typedef SELECT IfcDocumentSelect;
-    // C++ wrapper type for IfcFillStyleSelect
-    typedef SELECT IfcFillStyleSelect;
-    // C++ wrapper type for IfcGeometricSetSelect
-    typedef SELECT IfcGeometricSetSelect;
-    // C++ wrapper type for IfcGridPlacementDirectionSelect
-    typedef SELECT IfcGridPlacementDirectionSelect;
-    // C++ wrapper type for IfcHatchLineDistanceSelect
-    typedef SELECT IfcHatchLineDistanceSelect;
-    // C++ wrapper type for IfcLayeredItem
-    typedef SELECT IfcLayeredItem;
-    // C++ wrapper type for IfcLibrarySelect
-    typedef SELECT IfcLibrarySelect;
-    // C++ wrapper type for IfcLightDistributionDataSourceSelect
-    typedef SELECT IfcLightDistributionDataSourceSelect;
-    // C++ wrapper type for IfcMaterialSelect
-    typedef SELECT IfcMaterialSelect;
-    // C++ wrapper type for IfcMeasureValue
-    typedef SELECT IfcMeasureValue;
-    // C++ wrapper type for IfcMetricValueSelect
-    typedef SELECT IfcMetricValueSelect;
-    // C++ wrapper type for IfcModulusOfRotationalSubgradeReactionSelect
-    typedef SELECT IfcModulusOfRotationalSubgradeReactionSelect;
-    // C++ wrapper type for IfcModulusOfSubgradeReactionSelect
-    typedef SELECT IfcModulusOfSubgradeReactionSelect;
-    // C++ wrapper type for IfcModulusOfTranslationalSubgradeReactionSelect
-    typedef SELECT IfcModulusOfTranslationalSubgradeReactionSelect;
-    // C++ wrapper type for IfcObjectReferenceSelect
-    typedef SELECT IfcObjectReferenceSelect;
-    // C++ wrapper type for IfcPointOrVertexPoint
-    typedef SELECT IfcPointOrVertexPoint;
-    // C++ wrapper type for IfcPresentationStyleSelect
-    typedef SELECT IfcPresentationStyleSelect;
-    // C++ wrapper type for IfcProcessSelect
-    typedef SELECT IfcProcessSelect;
-    // C++ wrapper type for IfcProductRepresentationSelect
-    typedef SELECT IfcProductRepresentationSelect;
-    // C++ wrapper type for IfcProductSelect
-    typedef SELECT IfcProductSelect;
-    // C++ wrapper type for IfcPropertySetDefinitionSelect
-    typedef SELECT IfcPropertySetDefinitionSelect;
-    // C++ wrapper type for IfcResourceObjectSelect
-    typedef SELECT IfcResourceObjectSelect;
-    // C++ wrapper type for IfcResourceSelect
-    typedef SELECT IfcResourceSelect;
-    // C++ wrapper type for IfcRotationalStiffnessSelect
-    typedef SELECT IfcRotationalStiffnessSelect;
-    // C++ wrapper type for IfcSegmentIndexSelect
-    typedef SELECT IfcSegmentIndexSelect;
-    // C++ wrapper type for IfcShell
-    typedef SELECT IfcShell;
-    // C++ wrapper type for IfcSimpleValue
-    typedef SELECT IfcSimpleValue;
-    // C++ wrapper type for IfcSizeSelect
-    typedef SELECT IfcSizeSelect;
-    // C++ wrapper type for IfcSolidOrShell
-    typedef SELECT IfcSolidOrShell;
-    // C++ wrapper type for IfcSpaceBoundarySelect
-    typedef SELECT IfcSpaceBoundarySelect;
-    // C++ wrapper type for IfcSpecularHighlightSelect
-    typedef SELECT IfcSpecularHighlightSelect;
-    // C++ wrapper type for IfcStructuralActivityAssignmentSelect
-    typedef SELECT IfcStructuralActivityAssignmentSelect;
-    // C++ wrapper type for IfcStyleAssignmentSelect
-    typedef SELECT IfcStyleAssignmentSelect;
-    // C++ wrapper type for IfcSurfaceOrFaceSurface
-    typedef SELECT IfcSurfaceOrFaceSurface;
-    // C++ wrapper type for IfcSurfaceStyleElementSelect
-    typedef SELECT IfcSurfaceStyleElementSelect;
-    // C++ wrapper type for IfcTextFontSelect
-    typedef SELECT IfcTextFontSelect;
-    // C++ wrapper type for IfcTimeOrRatioSelect
-    typedef SELECT IfcTimeOrRatioSelect;
-    // C++ wrapper type for IfcTranslationalStiffnessSelect
-    typedef SELECT IfcTranslationalStiffnessSelect;
-    // C++ wrapper type for IfcTrimmingSelect
-    typedef SELECT IfcTrimmingSelect;
-    // C++ wrapper type for IfcUnit
-    typedef SELECT IfcUnit;
-    // C++ wrapper type for IfcValue
-    typedef SELECT IfcValue;
-    // C++ wrapper type for IfcVectorOrDirection
-    typedef SELECT IfcVectorOrDirection;
-    // C++ wrapper type for IfcWarpingStiffnessSelect
-    typedef SELECT IfcWarpingStiffnessSelect;
-
-
-	// ******************************************************************************
-	// IFC Entities
-	// ******************************************************************************
-
-	struct IfcRoot;
-	struct IfcObjectDefinition;
-	struct IfcObject;
-	struct IfcControl;
-	struct IfcActionRequest;
-	struct IfcActor;
-	typedef NotImplemented IfcActorRole; // (not currently used by Assimp)
-	struct IfcProduct;
-	struct IfcElement;
-	struct IfcDistributionElement;
-	struct IfcDistributionControlElement;
-	struct IfcActuator;
-	struct IfcTypeObject;
-	struct IfcTypeProduct;
-	struct IfcElementType;
-	struct IfcDistributionElementType;
-	struct IfcDistributionControlElementType;
-	struct IfcActuatorType;
-	typedef NotImplemented IfcAddress; // (not currently used by Assimp)
-	struct IfcRepresentationItem;
-	struct IfcGeometricRepresentationItem;
-	struct IfcSolidModel;
-	struct IfcManifoldSolidBrep;
-	struct IfcAdvancedBrep;
-	struct IfcAdvancedBrepWithVoids;
-	struct IfcTopologicalRepresentationItem;
-	struct IfcFace;
-	struct IfcFaceSurface;
-	struct IfcAdvancedFace;
-	struct IfcDistributionFlowElement;
-	struct IfcFlowTerminal;
-	struct IfcAirTerminal;
-	struct IfcFlowController;
-	struct IfcAirTerminalBox;
-	struct IfcDistributionFlowElementType;
-	struct IfcFlowControllerType;
-	struct IfcAirTerminalBoxType;
-	struct IfcFlowTerminalType;
-	struct IfcAirTerminalType;
-	struct IfcEnergyConversionDevice;
-	struct IfcAirToAirHeatRecovery;
-	struct IfcEnergyConversionDeviceType;
-	struct IfcAirToAirHeatRecoveryType;
-	struct IfcAlarm;
-	struct IfcAlarmType;
-	struct IfcAnnotation;
-	struct IfcAnnotationFillArea;
-	typedef NotImplemented IfcApplication; // (not currently used by Assimp)
-	typedef NotImplemented IfcAppliedValue; // (not currently used by Assimp)
-	typedef NotImplemented IfcApproval; // (not currently used by Assimp)
-	typedef NotImplemented IfcResourceLevelRelationship; // (not currently used by Assimp)
-	typedef NotImplemented IfcApprovalRelationship; // (not currently used by Assimp)
-	struct IfcProfileDef;
-	struct IfcArbitraryClosedProfileDef;
-	struct IfcArbitraryOpenProfileDef;
-	struct IfcArbitraryProfileDefWithVoids;
-	struct IfcGroup;
-	struct IfcAsset;
-	struct IfcParameterizedProfileDef;
-	struct IfcAsymmetricIShapeProfileDef;
-	struct IfcAudioVisualAppliance;
-	struct IfcAudioVisualApplianceType;
-	struct IfcPlacement;
-	struct IfcAxis1Placement;
-	struct IfcAxis2Placement2D;
-	struct IfcAxis2Placement3D;
-	struct IfcCurve;
-	struct IfcBoundedCurve;
-	struct IfcBSplineCurve;
-	struct IfcBSplineCurveWithKnots;
-	struct IfcSurface;
-	struct IfcBoundedSurface;
-	struct IfcBSplineSurface;
-	struct IfcBSplineSurfaceWithKnots;
-	struct IfcBuildingElement;
-	struct IfcBeam;
-	struct IfcBeamStandardCase;
-	struct IfcBuildingElementType;
-	struct IfcBeamType;
-	struct IfcPresentationItem;
-	typedef NotImplemented IfcSurfaceTexture; // (not currently used by Assimp)
-	typedef NotImplemented IfcBlobTexture; // (not currently used by Assimp)
-	struct IfcCsgPrimitive3D;
-	struct IfcBlock;
-	struct IfcBoiler;
-	struct IfcBoilerType;
-	struct IfcBooleanResult;
-	struct IfcBooleanClippingResult;
-	typedef NotImplemented IfcBoundaryCondition; // (not currently used by Assimp)
-	struct IfcCompositeCurve;
-	struct IfcCompositeCurveOnSurface;
-	struct IfcBoundaryCurve;
-	typedef NotImplemented IfcBoundaryEdgeCondition; // (not currently used by Assimp)
-	typedef NotImplemented IfcBoundaryFaceCondition; // (not currently used by Assimp)
-	typedef NotImplemented IfcBoundaryNodeCondition; // (not currently used by Assimp)
-	typedef NotImplemented IfcBoundaryNodeConditionWarping; // (not currently used by Assimp)
-	struct IfcBoundingBox;
-	struct IfcHalfSpaceSolid;
-	struct IfcBoxedHalfSpace;
-	struct IfcSpatialElement;
-	struct IfcSpatialStructureElement;
-	struct IfcBuilding;
-	struct IfcElementComponent;
-	struct IfcBuildingElementPart;
-	struct IfcElementComponentType;
-	struct IfcBuildingElementPartType;
-	struct IfcBuildingElementProxy;
-	struct IfcBuildingElementProxyType;
-	struct IfcBuildingStorey;
-	struct IfcSystem;
-	struct IfcBuildingSystem;
-	struct IfcBurner;
-	struct IfcBurnerType;
-	struct IfcCShapeProfileDef;
-	struct IfcFlowFitting;
-	struct IfcCableCarrierFitting;
-	struct IfcFlowFittingType;
-	struct IfcCableCarrierFittingType;
-	struct IfcFlowSegment;
-	struct IfcCableCarrierSegment;
-	struct IfcFlowSegmentType;
-	struct IfcCableCarrierSegmentType;
-	struct IfcCableFitting;
-	struct IfcCableFittingType;
-	struct IfcCableSegment;
-	struct IfcCableSegmentType;
-	struct IfcPoint;
-	struct IfcCartesianPoint;
-	struct IfcCartesianPointList;
-	struct IfcCartesianPointList2D;
-	struct IfcCartesianPointList3D;
-	struct IfcCartesianTransformationOperator;
-	struct IfcCartesianTransformationOperator2D;
-	struct IfcCartesianTransformationOperator2DnonUniform;
-	struct IfcCartesianTransformationOperator3D;
-	struct IfcCartesianTransformationOperator3DnonUniform;
-	struct IfcCenterLineProfileDef;
-	struct IfcChiller;
-	struct IfcChillerType;
-	struct IfcChimney;
-	struct IfcChimneyType;
-	struct IfcConic;
-	struct IfcCircle;
-	struct IfcCircleProfileDef;
-	struct IfcCircleHollowProfileDef;
-	struct IfcCivilElement;
-	struct IfcCivilElementType;
-	typedef NotImplemented IfcExternalInformation; // (not currently used by Assimp)
-	typedef NotImplemented IfcClassification; // (not currently used by Assimp)
-	typedef NotImplemented IfcExternalReference; // (not currently used by Assimp)
-	typedef NotImplemented IfcClassificationReference; // (not currently used by Assimp)
-	struct IfcConnectedFaceSet;
-	struct IfcClosedShell;
-	struct IfcCoil;
-	struct IfcCoilType;
-	struct IfcColourSpecification;
-	struct IfcColourRgb;
-	typedef NotImplemented IfcColourRgbList; // (not currently used by Assimp)
-	struct IfcColumn;
-	struct IfcColumnStandardCase;
-	struct IfcColumnType;
-	struct IfcCommunicationsAppliance;
-	struct IfcCommunicationsApplianceType;
-	struct IfcPropertyAbstraction;
-	struct IfcProperty;
-	struct IfcComplexProperty;
-	struct IfcPropertyDefinition;
-	typedef NotImplemented IfcPropertyTemplateDefinition; // (not currently used by Assimp)
-	typedef NotImplemented IfcPropertyTemplate; // (not currently used by Assimp)
-	typedef NotImplemented IfcComplexPropertyTemplate; // (not currently used by Assimp)
-	struct IfcCompositeCurveSegment;
-	struct IfcCompositeProfileDef;
-	struct IfcFlowMovingDevice;
-	struct IfcCompressor;
-	struct IfcFlowMovingDeviceType;
-	struct IfcCompressorType;
-	struct IfcCondenser;
-	struct IfcCondenserType;
-	typedef NotImplemented IfcConnectionGeometry; // (not currently used by Assimp)
-	typedef NotImplemented IfcConnectionCurveGeometry; // (not currently used by Assimp)
-	typedef NotImplemented IfcConnectionPointGeometry; // (not currently used by Assimp)
-	typedef NotImplemented IfcConnectionPointEccentricity; // (not currently used by Assimp)
-	typedef NotImplemented IfcConnectionSurfaceGeometry; // (not currently used by Assimp)
-	typedef NotImplemented IfcConnectionVolumeGeometry; // (not currently used by Assimp)
-	typedef NotImplemented IfcConstraint; // (not currently used by Assimp)
-	struct IfcResource;
-	struct IfcConstructionResource;
-	struct IfcConstructionEquipmentResource;
-	struct IfcTypeResource;
-	struct IfcConstructionResourceType;
-	struct IfcConstructionEquipmentResourceType;
-	struct IfcConstructionMaterialResource;
-	struct IfcConstructionMaterialResourceType;
-	struct IfcConstructionProductResource;
-	struct IfcConstructionProductResourceType;
-	struct IfcContext;
-	struct IfcNamedUnit;
-	struct IfcContextDependentUnit;
-	struct IfcController;
-	struct IfcControllerType;
-	struct IfcConversionBasedUnit;
-	struct IfcConversionBasedUnitWithOffset;
-	struct IfcCooledBeam;
-	struct IfcCooledBeamType;
-	struct IfcCoolingTower;
-	struct IfcCoolingTowerType;
-	typedef NotImplemented IfcCoordinateOperation; // (not currently used by Assimp)
-	typedef NotImplemented IfcCoordinateReferenceSystem; // (not currently used by Assimp)
-	struct IfcCostItem;
-	struct IfcCostSchedule;
-	typedef NotImplemented IfcCostValue; // (not currently used by Assimp)
-	struct IfcCovering;
-	struct IfcCoveringType;
-	struct IfcCrewResource;
-	struct IfcCrewResourceType;
-	struct IfcCsgSolid;
-	typedef NotImplemented IfcCurrencyRelationship; // (not currently used by Assimp)
-	struct IfcCurtainWall;
-	struct IfcCurtainWallType;
-	struct IfcCurveBoundedPlane;
-	struct IfcCurveBoundedSurface;
-	struct IfcPresentationStyle;
-	typedef NotImplemented IfcCurveStyle; // (not currently used by Assimp)
-	typedef NotImplemented IfcCurveStyleFont; // (not currently used by Assimp)
-	typedef NotImplemented IfcCurveStyleFontAndScaling; // (not currently used by Assimp)
-	typedef NotImplemented IfcCurveStyleFontPattern; // (not currently used by Assimp)
-	struct IfcElementarySurface;
-	struct IfcCylindricalSurface;
-	struct IfcDamper;
-	struct IfcDamperType;
-	struct IfcDerivedProfileDef;
-	typedef NotImplemented IfcDerivedUnit; // (not currently used by Assimp)
-	typedef NotImplemented IfcDerivedUnitElement; // (not currently used by Assimp)
-	typedef NotImplemented IfcDimensionalExponents; // (not currently used by Assimp)
-	struct IfcDirection;
-	struct IfcDiscreteAccessory;
-	struct IfcDiscreteAccessoryType;
-	struct IfcDistributionChamberElement;
-	struct IfcDistributionChamberElementType;
-	struct IfcDistributionSystem;
-	struct IfcDistributionCircuit;
-	struct IfcPort;
-	struct IfcDistributionPort;
-	typedef NotImplemented IfcDocumentInformation; // (not currently used by Assimp)
-	typedef NotImplemented IfcDocumentInformationRelationship; // (not currently used by Assimp)
-	typedef NotImplemented IfcDocumentReference; // (not currently used by Assimp)
-	struct IfcDoor;
-	struct IfcPropertySetDefinition;
-	typedef NotImplemented IfcPreDefinedPropertySet; // (not currently used by Assimp)
-	typedef NotImplemented IfcDoorLiningProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcDoorPanelProperties; // (not currently used by Assimp)
-	struct IfcDoorStandardCase;
-	struct IfcDoorStyle;
-	struct IfcDoorType;
-	typedef NotImplemented IfcPreDefinedItem; // (not currently used by Assimp)
-	typedef NotImplemented IfcPreDefinedColour; // (not currently used by Assimp)
-	typedef NotImplemented IfcDraughtingPreDefinedColour; // (not currently used by Assimp)
-	typedef NotImplemented IfcPreDefinedCurveFont; // (not currently used by Assimp)
-	typedef NotImplemented IfcDraughtingPreDefinedCurveFont; // (not currently used by Assimp)
-	struct IfcDuctFitting;
-	struct IfcDuctFittingType;
-	struct IfcDuctSegment;
-	struct IfcDuctSegmentType;
-	struct IfcFlowTreatmentDevice;
-	struct IfcDuctSilencer;
-	struct IfcFlowTreatmentDeviceType;
-	struct IfcDuctSilencerType;
-	struct IfcEdge;
-	struct IfcEdgeCurve;
-	struct IfcLoop;
-	struct IfcEdgeLoop;
-	struct IfcElectricAppliance;
-	struct IfcElectricApplianceType;
-	struct IfcElectricDistributionBoard;
-	struct IfcElectricDistributionBoardType;
-	struct IfcFlowStorageDevice;
-	struct IfcElectricFlowStorageDevice;
-	struct IfcFlowStorageDeviceType;
-	struct IfcElectricFlowStorageDeviceType;
-	struct IfcElectricGenerator;
-	struct IfcElectricGeneratorType;
-	struct IfcElectricMotor;
-	struct IfcElectricMotorType;
-	struct IfcElectricTimeControl;
-	struct IfcElectricTimeControlType;
-	struct IfcElementAssembly;
-	struct IfcElementAssemblyType;
-	struct IfcQuantitySet;
-	struct IfcElementQuantity;
-	struct IfcEllipse;
-	struct IfcEllipseProfileDef;
-	struct IfcEngine;
-	struct IfcEngineType;
-	struct IfcEvaporativeCooler;
-	struct IfcEvaporativeCoolerType;
-	struct IfcEvaporator;
-	struct IfcEvaporatorType;
-	struct IfcProcess;
-	struct IfcEvent;
-	typedef NotImplemented IfcSchedulingTime; // (not currently used by Assimp)
-	typedef NotImplemented IfcEventTime; // (not currently used by Assimp)
-	struct IfcTypeProcess;
-	struct IfcEventType;
-	typedef NotImplemented IfcExtendedProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcExternalReferenceRelationship; // (not currently used by Assimp)
-	struct IfcExternalSpatialStructureElement;
-	struct IfcExternalSpatialElement;
-	typedef NotImplemented IfcExternallyDefinedHatchStyle; // (not currently used by Assimp)
-	typedef NotImplemented IfcExternallyDefinedSurfaceStyle; // (not currently used by Assimp)
-	typedef NotImplemented IfcExternallyDefinedTextFont; // (not currently used by Assimp)
-	struct IfcSweptAreaSolid;
-	struct IfcExtrudedAreaSolid;
-	struct IfcExtrudedAreaSolidTapered;
-	struct IfcFaceBasedSurfaceModel;
-	struct IfcFaceBound;
-	struct IfcFaceOuterBound;
-	struct IfcFacetedBrep;
-	struct IfcFacetedBrepWithVoids;
-	typedef NotImplemented IfcStructuralConnectionCondition; // (not currently used by Assimp)
-	typedef NotImplemented IfcFailureConnectionCondition; // (not currently used by Assimp)
-	struct IfcFan;
-	struct IfcFanType;
-	struct IfcFastener;
-	struct IfcFastenerType;
-	struct IfcFeatureElement;
-	struct IfcFeatureElementAddition;
-	struct IfcFeatureElementSubtraction;
-	typedef NotImplemented IfcFillAreaStyle; // (not currently used by Assimp)
-	struct IfcFillAreaStyleHatching;
-	struct IfcFillAreaStyleTiles;
-	struct IfcFilter;
-	struct IfcFilterType;
-	struct IfcFireSuppressionTerminal;
-	struct IfcFireSuppressionTerminalType;
-	struct IfcFixedReferenceSweptAreaSolid;
-	struct IfcFlowInstrument;
-	struct IfcFlowInstrumentType;
-	struct IfcFlowMeter;
-	struct IfcFlowMeterType;
-	struct IfcFooting;
-	struct IfcFootingType;
-	struct IfcFurnishingElement;
-	struct IfcFurnishingElementType;
-	struct IfcFurniture;
-	struct IfcFurnitureType;
-	struct IfcGeographicElement;
-	struct IfcGeographicElementType;
-	struct IfcGeometricSet;
-	struct IfcGeometricCurveSet;
-	struct IfcRepresentationContext;
-	struct IfcGeometricRepresentationContext;
-	struct IfcGeometricRepresentationSubContext;
-	struct IfcGrid;
-	typedef NotImplemented IfcGridAxis; // (not currently used by Assimp)
-	struct IfcObjectPlacement;
-	struct IfcGridPlacement;
-	struct IfcHeatExchanger;
-	struct IfcHeatExchangerType;
-	struct IfcHumidifier;
-	struct IfcHumidifierType;
-	struct IfcIShapeProfileDef;
-	typedef NotImplemented IfcImageTexture; // (not currently used by Assimp)
-	typedef NotImplemented IfcIndexedColourMap; // (not currently used by Assimp)
-	struct IfcIndexedPolyCurve;
-	struct IfcTessellatedItem;
-	struct IfcIndexedPolygonalFace;
-	struct IfcIndexedPolygonalFaceWithVoids;
-	typedef NotImplemented IfcTextureCoordinate; // (not currently used by Assimp)
-	typedef NotImplemented IfcIndexedTextureMap; // (not currently used by Assimp)
-	typedef NotImplemented IfcIndexedTriangleTextureMap; // (not currently used by Assimp)
-	struct IfcInterceptor;
-	struct IfcInterceptorType;
-	struct IfcSurfaceCurve;
-	struct IfcIntersectionCurve;
-	struct IfcInventory;
-	typedef NotImplemented IfcTimeSeries; // (not currently used by Assimp)
-	typedef NotImplemented IfcIrregularTimeSeries; // (not currently used by Assimp)
-	typedef NotImplemented IfcIrregularTimeSeriesValue; // (not currently used by Assimp)
-	struct IfcJunctionBox;
-	struct IfcJunctionBoxType;
-	struct IfcLShapeProfileDef;
-	struct IfcLaborResource;
-	struct IfcLaborResourceType;
-	typedef NotImplemented IfcLagTime; // (not currently used by Assimp)
-	struct IfcLamp;
-	struct IfcLampType;
-	typedef NotImplemented IfcLibraryInformation; // (not currently used by Assimp)
-	typedef NotImplemented IfcLibraryReference; // (not currently used by Assimp)
-	typedef NotImplemented IfcLightDistributionData; // (not currently used by Assimp)
-	struct IfcLightFixture;
-	struct IfcLightFixtureType;
-	typedef NotImplemented IfcLightIntensityDistribution; // (not currently used by Assimp)
-	struct IfcLightSource;
-	struct IfcLightSourceAmbient;
-	struct IfcLightSourceDirectional;
-	struct IfcLightSourceGoniometric;
-	struct IfcLightSourcePositional;
-	struct IfcLightSourceSpot;
-	struct IfcLine;
-	struct IfcLocalPlacement;
-	typedef NotImplemented IfcMapConversion; // (not currently used by Assimp)
-	struct IfcMappedItem;
-	typedef NotImplemented IfcMaterialDefinition; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterial; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialClassificationRelationship; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialConstituent; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialConstituentSet; // (not currently used by Assimp)
-	struct IfcProductRepresentation;
-	struct IfcMaterialDefinitionRepresentation;
-	typedef NotImplemented IfcMaterialLayer; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialLayerSet; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialUsageDefinition; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialLayerSetUsage; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialLayerWithOffsets; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialList; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialProfile; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialProfileSet; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialProfileSetUsage; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialProfileSetUsageTapering; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialProfileWithOffsets; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcMaterialRelationship; // (not currently used by Assimp)
-	struct IfcMeasureWithUnit;
-	struct IfcMechanicalFastener;
-	struct IfcMechanicalFastenerType;
-	struct IfcMedicalDevice;
-	struct IfcMedicalDeviceType;
-	struct IfcMember;
-	struct IfcMemberStandardCase;
-	struct IfcMemberType;
-	typedef NotImplemented IfcMetric; // (not currently used by Assimp)
-	struct IfcMirroredProfileDef;
-	typedef NotImplemented IfcMonetaryUnit; // (not currently used by Assimp)
-	struct IfcMotorConnection;
-	struct IfcMotorConnectionType;
-	typedef NotImplemented IfcObjective; // (not currently used by Assimp)
-	struct IfcOccupant;
-	struct IfcOffsetCurve2D;
-	struct IfcOffsetCurve3D;
-	struct IfcOpenShell;
-	struct IfcOpeningElement;
-	struct IfcOpeningStandardCase;
-	typedef NotImplemented IfcOrganization; // (not currently used by Assimp)
-	typedef NotImplemented IfcOrganizationRelationship; // (not currently used by Assimp)
-	struct IfcOrientedEdge;
-	struct IfcOuterBoundaryCurve;
-	struct IfcOutlet;
-	struct IfcOutletType;
-	typedef NotImplemented IfcOwnerHistory; // (not currently used by Assimp)
-	struct IfcPath;
-	struct IfcPcurve;
-	struct IfcPerformanceHistory;
-	typedef NotImplemented IfcPermeableCoveringProperties; // (not currently used by Assimp)
-	struct IfcPermit;
-	typedef NotImplemented IfcPerson; // (not currently used by Assimp)
-	typedef NotImplemented IfcPersonAndOrganization; // (not currently used by Assimp)
-	typedef NotImplemented IfcPhysicalQuantity; // (not currently used by Assimp)
-	typedef NotImplemented IfcPhysicalComplexQuantity; // (not currently used by Assimp)
-	typedef NotImplemented IfcPhysicalSimpleQuantity; // (not currently used by Assimp)
-	struct IfcPile;
-	struct IfcPileType;
-	struct IfcPipeFitting;
-	struct IfcPipeFittingType;
-	struct IfcPipeSegment;
-	struct IfcPipeSegmentType;
-	typedef NotImplemented IfcPixelTexture; // (not currently used by Assimp)
-	struct IfcPlanarExtent;
-	struct IfcPlanarBox;
-	struct IfcPlane;
-	struct IfcPlate;
-	struct IfcPlateStandardCase;
-	struct IfcPlateType;
-	struct IfcPointOnCurve;
-	struct IfcPointOnSurface;
-	struct IfcPolyLoop;
-	struct IfcPolygonalBoundedHalfSpace;
-	struct IfcTessellatedFaceSet;
-	struct IfcPolygonalFaceSet;
-	struct IfcPolyline;
-	typedef NotImplemented IfcPostalAddress; // (not currently used by Assimp)
-	typedef NotImplemented IfcPreDefinedProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcPreDefinedTextFont; // (not currently used by Assimp)
-	typedef NotImplemented IfcPresentationLayerAssignment; // (not currently used by Assimp)
-	typedef NotImplemented IfcPresentationLayerWithStyle; // (not currently used by Assimp)
-	struct IfcPresentationStyleAssignment;
-	struct IfcProcedure;
-	struct IfcProcedureType;
-	struct IfcProductDefinitionShape;
-	typedef NotImplemented IfcProfileProperties; // (not currently used by Assimp)
-	struct IfcProject;
-	struct IfcProjectLibrary;
-	struct IfcProjectOrder;
-	typedef NotImplemented IfcProjectedCRS; // (not currently used by Assimp)
-	struct IfcProjectionElement;
-	struct IfcSimpleProperty;
-	struct IfcPropertyBoundedValue;
-	typedef NotImplemented IfcPropertyDependencyRelationship; // (not currently used by Assimp)
-	struct IfcPropertyEnumeratedValue;
-	typedef NotImplemented IfcPropertyEnumeration; // (not currently used by Assimp)
-	struct IfcPropertyListValue;
-	struct IfcPropertyReferenceValue;
-	struct IfcPropertySet;
-	typedef NotImplemented IfcPropertySetTemplate; // (not currently used by Assimp)
-	struct IfcPropertySingleValue;
-	struct IfcPropertyTableValue;
-	struct IfcProtectiveDevice;
-	struct IfcProtectiveDeviceTrippingUnit;
-	struct IfcProtectiveDeviceTrippingUnitType;
-	struct IfcProtectiveDeviceType;
-	struct IfcProxy;
-	struct IfcPump;
-	struct IfcPumpType;
-	typedef NotImplemented IfcQuantityArea; // (not currently used by Assimp)
-	typedef NotImplemented IfcQuantityCount; // (not currently used by Assimp)
-	typedef NotImplemented IfcQuantityLength; // (not currently used by Assimp)
-	typedef NotImplemented IfcQuantityTime; // (not currently used by Assimp)
-	typedef NotImplemented IfcQuantityVolume; // (not currently used by Assimp)
-	typedef NotImplemented IfcQuantityWeight; // (not currently used by Assimp)
-	struct IfcRailing;
-	struct IfcRailingType;
-	struct IfcRamp;
-	struct IfcRampFlight;
-	struct IfcRampFlightType;
-	struct IfcRampType;
-	struct IfcRationalBSplineCurveWithKnots;
-	struct IfcRationalBSplineSurfaceWithKnots;
-	struct IfcRectangleProfileDef;
-	struct IfcRectangleHollowProfileDef;
-	struct IfcRectangularPyramid;
-	struct IfcRectangularTrimmedSurface;
-	typedef NotImplemented IfcRecurrencePattern; // (not currently used by Assimp)
-	typedef NotImplemented IfcReference; // (not currently used by Assimp)
-	typedef NotImplemented IfcRegularTimeSeries; // (not currently used by Assimp)
-	typedef NotImplemented IfcReinforcementBarProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcReinforcementDefinitionProperties; // (not currently used by Assimp)
-	struct IfcReinforcingElement;
-	struct IfcReinforcingBar;
-	struct IfcReinforcingElementType;
-	struct IfcReinforcingBarType;
-	struct IfcReinforcingMesh;
-	struct IfcReinforcingMeshType;
-	struct IfcRelationship;
-	struct IfcRelDecomposes;
-	struct IfcRelAggregates;
-	typedef NotImplemented IfcRelAssigns; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToActor; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToControl; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToGroup; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToGroupByFactor; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToProcess; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToProduct; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssignsToResource; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociates; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociatesApproval; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociatesClassification; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociatesConstraint; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociatesDocument; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociatesLibrary; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelAssociatesMaterial; // (not currently used by Assimp)
-	struct IfcRelConnects;
-	typedef NotImplemented IfcRelConnectsElements; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsPathElements; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsPortToElement; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsPorts; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsStructuralActivity; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsStructuralMember; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsWithEccentricity; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelConnectsWithRealizingElements; // (not currently used by Assimp)
-	struct IfcRelContainedInSpatialStructure;
-	typedef NotImplemented IfcRelCoversBldgElements; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelCoversSpaces; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelDeclares; // (not currently used by Assimp)
-	struct IfcRelDefines;
-	typedef NotImplemented IfcRelDefinesByObject; // (not currently used by Assimp)
-	struct IfcRelDefinesByProperties;
-	typedef NotImplemented IfcRelDefinesByTemplate; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelDefinesByType; // (not currently used by Assimp)
-	struct IfcRelFillsElement;
-	typedef NotImplemented IfcRelFlowControlElements; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelInterferesElements; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelNests; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelProjectsElement; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelReferencedInSpatialStructure; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelSequence; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelServicesBuildings; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelSpaceBoundary; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelSpaceBoundary1stLevel; // (not currently used by Assimp)
-	typedef NotImplemented IfcRelSpaceBoundary2ndLevel; // (not currently used by Assimp)
-	struct IfcRelVoidsElement;
-	struct IfcReparametrisedCompositeCurveSegment;
-	struct IfcRepresentation;
-	struct IfcRepresentationMap;
-	typedef NotImplemented IfcResourceApprovalRelationship; // (not currently used by Assimp)
-	typedef NotImplemented IfcResourceConstraintRelationship; // (not currently used by Assimp)
-	typedef NotImplemented IfcResourceTime; // (not currently used by Assimp)
-	struct IfcRevolvedAreaSolid;
-	struct IfcRevolvedAreaSolidTapered;
-	struct IfcRightCircularCone;
-	struct IfcRightCircularCylinder;
-	struct IfcRoof;
-	struct IfcRoofType;
-	struct IfcRoundedRectangleProfileDef;
-	struct IfcSIUnit;
-	struct IfcSanitaryTerminal;
-	struct IfcSanitaryTerminalType;
-	struct IfcSeamCurve;
-	typedef NotImplemented IfcSectionProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcSectionReinforcementProperties; // (not currently used by Assimp)
-	struct IfcSectionedSpine;
-	struct IfcSensor;
-	struct IfcSensorType;
-	struct IfcShadingDevice;
-	struct IfcShadingDeviceType;
-	typedef NotImplemented IfcShapeAspect; // (not currently used by Assimp)
-	struct IfcShapeModel;
-	struct IfcShapeRepresentation;
-	struct IfcShellBasedSurfaceModel;
-	typedef NotImplemented IfcSimplePropertyTemplate; // (not currently used by Assimp)
-	struct IfcSite;
-	struct IfcSlab;
-	struct IfcSlabElementedCase;
-	struct IfcSlabStandardCase;
-	struct IfcSlabType;
-	typedef NotImplemented IfcSlippageConnectionCondition; // (not currently used by Assimp)
-	struct IfcSolarDevice;
-	struct IfcSolarDeviceType;
-	struct IfcSpace;
-	struct IfcSpaceHeater;
-	struct IfcSpaceHeaterType;
-	struct IfcSpatialElementType;
-	struct IfcSpatialStructureElementType;
-	struct IfcSpaceType;
-	struct IfcSpatialZone;
-	struct IfcSpatialZoneType;
-	struct IfcSphere;
-	struct IfcSphericalSurface;
-	struct IfcStackTerminal;
-	struct IfcStackTerminalType;
-	struct IfcStair;
-	struct IfcStairFlight;
-	struct IfcStairFlightType;
-	struct IfcStairType;
-	struct IfcStructuralActivity;
-	struct IfcStructuralAction;
-	struct IfcStructuralAnalysisModel;
-	struct IfcStructuralItem;
-	struct IfcStructuralConnection;
-	struct IfcStructuralCurveAction;
-	struct IfcStructuralCurveConnection;
-	struct IfcStructuralMember;
-	struct IfcStructuralCurveMember;
-	struct IfcStructuralCurveMemberVarying;
-	struct IfcStructuralReaction;
-	struct IfcStructuralCurveReaction;
-	struct IfcStructuralLinearAction;
-	typedef NotImplemented IfcStructuralLoad; // (not currently used by Assimp)
-	struct IfcStructuralLoadGroup;
-	struct IfcStructuralLoadCase;
-	typedef NotImplemented IfcStructuralLoadConfiguration; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadOrResult; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadStatic; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadLinearForce; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadPlanarForce; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadSingleDisplacement; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadSingleDisplacementDistortion; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadSingleForce; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadSingleForceWarping; // (not currently used by Assimp)
-	typedef NotImplemented IfcStructuralLoadTemperature; // (not currently used by Assimp)
-	struct IfcStructuralSurfaceAction;
-	struct IfcStructuralPlanarAction;
-	struct IfcStructuralPointAction;
-	struct IfcStructuralPointConnection;
-	struct IfcStructuralPointReaction;
-	struct IfcStructuralResultGroup;
-	struct IfcStructuralSurfaceConnection;
-	struct IfcStructuralSurfaceMember;
-	struct IfcStructuralSurfaceMemberVarying;
-	struct IfcStructuralSurfaceReaction;
-	struct IfcStyleModel;
-	struct IfcStyledItem;
-	struct IfcStyledRepresentation;
-	struct IfcSubContractResource;
-	struct IfcSubContractResourceType;
-	struct IfcSubedge;
-	struct IfcSurfaceCurveSweptAreaSolid;
-	struct IfcSurfaceFeature;
-	struct IfcSweptSurface;
-	struct IfcSurfaceOfLinearExtrusion;
-	struct IfcSurfaceOfRevolution;
-	typedef NotImplemented IfcSurfaceReinforcementArea; // (not currently used by Assimp)
-	struct IfcSurfaceStyle;
-	typedef NotImplemented IfcSurfaceStyleLighting; // (not currently used by Assimp)
-	typedef NotImplemented IfcSurfaceStyleRefraction; // (not currently used by Assimp)
-	struct IfcSurfaceStyleShading;
-	struct IfcSurfaceStyleRendering;
-	struct IfcSurfaceStyleWithTextures;
-	struct IfcSweptDiskSolid;
-	struct IfcSweptDiskSolidPolygonal;
-	struct IfcSwitchingDevice;
-	struct IfcSwitchingDeviceType;
-	struct IfcSystemFurnitureElement;
-	struct IfcSystemFurnitureElementType;
-	struct IfcTShapeProfileDef;
-	typedef NotImplemented IfcTable; // (not currently used by Assimp)
-	typedef NotImplemented IfcTableColumn; // (not currently used by Assimp)
-	typedef NotImplemented IfcTableRow; // (not currently used by Assimp)
-	struct IfcTank;
-	struct IfcTankType;
-	struct IfcTask;
-	typedef NotImplemented IfcTaskTime; // (not currently used by Assimp)
-	typedef NotImplemented IfcTaskTimeRecurring; // (not currently used by Assimp)
-	struct IfcTaskType;
-	typedef NotImplemented IfcTelecomAddress; // (not currently used by Assimp)
-	struct IfcTendon;
-	struct IfcTendonAnchor;
-	struct IfcTendonAnchorType;
-	struct IfcTendonType;
-	struct IfcTextLiteral;
-	struct IfcTextLiteralWithExtent;
-	typedef NotImplemented IfcTextStyle; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextStyleFontModel; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextStyleForDefinedFont; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextStyleTextModel; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextureCoordinateGenerator; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextureMap; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextureVertex; // (not currently used by Assimp)
-	typedef NotImplemented IfcTextureVertexList; // (not currently used by Assimp)
-	typedef NotImplemented IfcTimePeriod; // (not currently used by Assimp)
-	typedef NotImplemented IfcTimeSeriesValue; // (not currently used by Assimp)
-	struct IfcTopologyRepresentation;
-	struct IfcToroidalSurface;
-	struct IfcTransformer;
-	struct IfcTransformerType;
-	struct IfcTransportElement;
-	struct IfcTransportElementType;
-	struct IfcTrapeziumProfileDef;
-	struct IfcTriangulatedFaceSet;
-	struct IfcTrimmedCurve;
-	struct IfcTubeBundle;
-	struct IfcTubeBundleType;
-	struct IfcUShapeProfileDef;
-	struct IfcUnitAssignment;
-	struct IfcUnitaryControlElement;
-	struct IfcUnitaryControlElementType;
-	struct IfcUnitaryEquipment;
-	struct IfcUnitaryEquipmentType;
-	struct IfcValve;
-	struct IfcValveType;
-	struct IfcVector;
-	struct IfcVertex;
-	struct IfcVertexLoop;
-	struct IfcVertexPoint;
-	struct IfcVibrationIsolator;
-	struct IfcVibrationIsolatorType;
-	struct IfcVirtualElement;
-	typedef NotImplemented IfcVirtualGridIntersection; // (not currently used by Assimp)
-	struct IfcVoidingFeature;
-	struct IfcWall;
-	struct IfcWallElementedCase;
-	struct IfcWallStandardCase;
-	struct IfcWallType;
-	struct IfcWasteTerminal;
-	struct IfcWasteTerminalType;
-	struct IfcWindow;
-	typedef NotImplemented IfcWindowLiningProperties; // (not currently used by Assimp)
-	typedef NotImplemented IfcWindowPanelProperties; // (not currently used by Assimp)
-	struct IfcWindowStandardCase;
-	struct IfcWindowStyle;
-	struct IfcWindowType;
-	struct IfcWorkCalendar;
-	struct IfcWorkControl;
-	struct IfcWorkPlan;
-	struct IfcWorkSchedule;
-	typedef NotImplemented IfcWorkTime; // (not currently used by Assimp)
-	struct IfcZShapeProfileDef;
-	struct IfcZone;
-
-
-
-    // C++ wrapper for IfcRoot
-    struct IfcRoot :  ObjectHelper<IfcRoot,4> { IfcRoot() : Object("IfcRoot") {}
-		IfcGloballyUniqueId::Out GlobalId;
-		Maybe< Lazy< NotImplemented > > OwnerHistory;
-		Maybe< IfcLabel::Out > Name;
-		Maybe< IfcText::Out > Description;
-    };
-
-    // C++ wrapper for IfcObjectDefinition
-    struct IfcObjectDefinition : IfcRoot, ObjectHelper<IfcObjectDefinition,0> { IfcObjectDefinition() : Object("IfcObjectDefinition") {}
-
-    };
-
-    // C++ wrapper for IfcObject
-    struct IfcObject : IfcObjectDefinition, ObjectHelper<IfcObject,1> { IfcObject() : Object("IfcObject") {}
-		Maybe< IfcLabel::Out > ObjectType;
-    };
-
-    // C++ wrapper for IfcControl
-    struct IfcControl : IfcObject, ObjectHelper<IfcControl,1> { IfcControl() : Object("IfcControl") {}
-		Maybe< IfcIdentifier::Out > Identification;
-    };
-
-    // C++ wrapper for IfcActionRequest
-    struct IfcActionRequest : IfcControl, ObjectHelper<IfcActionRequest,3> { IfcActionRequest() : Object("IfcActionRequest") {}
-		Maybe< IfcActionRequestTypeEnum::Out > PredefinedType;
-		Maybe< IfcLabel::Out > Status;
-		Maybe< IfcText::Out > LongDescription;
-    };
-
-    // C++ wrapper for IfcActor
-    struct IfcActor : IfcObject, ObjectHelper<IfcActor,1> { IfcActor() : Object("IfcActor") {}
-		IfcActorSelect::Out TheActor;
-    };
-
-    // C++ wrapper for IfcProduct
-    struct IfcProduct : IfcObject, ObjectHelper<IfcProduct,2> { IfcProduct() : Object("IfcProduct") {}
-		Maybe< Lazy< IfcObjectPlacement > > ObjectPlacement;
-		Maybe< Lazy< IfcProductRepresentation > > Representation;
-    };
-
-    // C++ wrapper for IfcElement
-    struct IfcElement : IfcProduct, ObjectHelper<IfcElement,1> { IfcElement() : Object("IfcElement") {}
-		Maybe< IfcIdentifier::Out > Tag;
-    };
-
-    // C++ wrapper for IfcDistributionElement
-    struct IfcDistributionElement : IfcElement, ObjectHelper<IfcDistributionElement,0> { IfcDistributionElement() : Object("IfcDistributionElement") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionControlElement
-    struct IfcDistributionControlElement : IfcDistributionElement, ObjectHelper<IfcDistributionControlElement,0> { IfcDistributionControlElement() : Object("IfcDistributionControlElement") {}
-
-    };
-
-    // C++ wrapper for IfcActuator
-    struct IfcActuator : IfcDistributionControlElement, ObjectHelper<IfcActuator,1> { IfcActuator() : Object("IfcActuator") {}
-		Maybe< IfcActuatorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTypeObject
-    struct IfcTypeObject : IfcObjectDefinition, ObjectHelper<IfcTypeObject,2> { IfcTypeObject() : Object("IfcTypeObject") {}
-		Maybe< IfcIdentifier::Out > ApplicableOccurrence;
-		Maybe< ListOf< Lazy< IfcPropertySetDefinition >, 1, 0 > > HasPropertySets;
-    };
-
-    // C++ wrapper for IfcTypeProduct
-    struct IfcTypeProduct : IfcTypeObject, ObjectHelper<IfcTypeProduct,2> { IfcTypeProduct() : Object("IfcTypeProduct") {}
-		Maybe< ListOf< Lazy< IfcRepresentationMap >, 1, 0 > > RepresentationMaps;
-		Maybe< IfcLabel::Out > Tag;
-    };
-
-    // C++ wrapper for IfcElementType
-    struct IfcElementType : IfcTypeProduct, ObjectHelper<IfcElementType,1> { IfcElementType() : Object("IfcElementType") {}
-		Maybe< IfcLabel::Out > ElementType;
-    };
-
-    // C++ wrapper for IfcDistributionElementType
-    struct IfcDistributionElementType : IfcElementType, ObjectHelper<IfcDistributionElementType,0> { IfcDistributionElementType() : Object("IfcDistributionElementType") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionControlElementType
-    struct IfcDistributionControlElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionControlElementType,0> { IfcDistributionControlElementType() : Object("IfcDistributionControlElementType") {}
-
-    };
-
-    // C++ wrapper for IfcActuatorType
-    struct IfcActuatorType : IfcDistributionControlElementType, ObjectHelper<IfcActuatorType,1> { IfcActuatorType() : Object("IfcActuatorType") {}
-		IfcActuatorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRepresentationItem
-    struct IfcRepresentationItem :  ObjectHelper<IfcRepresentationItem,0> { IfcRepresentationItem() : Object("IfcRepresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcGeometricRepresentationItem
-    struct IfcGeometricRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcGeometricRepresentationItem,0> { IfcGeometricRepresentationItem() : Object("IfcGeometricRepresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcSolidModel
-    struct IfcSolidModel : IfcGeometricRepresentationItem, ObjectHelper<IfcSolidModel,0> { IfcSolidModel() : Object("IfcSolidModel") {}
-
-    };
-
-    // C++ wrapper for IfcManifoldSolidBrep
-    struct IfcManifoldSolidBrep : IfcSolidModel, ObjectHelper<IfcManifoldSolidBrep,1> { IfcManifoldSolidBrep() : Object("IfcManifoldSolidBrep") {}
-		Lazy< IfcClosedShell > Outer;
-    };
-
-    // C++ wrapper for IfcAdvancedBrep
-    struct IfcAdvancedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcAdvancedBrep,0> { IfcAdvancedBrep() : Object("IfcAdvancedBrep") {}
-
-    };
-
-    // C++ wrapper for IfcAdvancedBrepWithVoids
-    struct IfcAdvancedBrepWithVoids : IfcAdvancedBrep, ObjectHelper<IfcAdvancedBrepWithVoids,1> { IfcAdvancedBrepWithVoids() : Object("IfcAdvancedBrepWithVoids") {}
-		ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
-    };
-
-    // C++ wrapper for IfcTopologicalRepresentationItem
-    struct IfcTopologicalRepresentationItem : IfcRepresentationItem, ObjectHelper<IfcTopologicalRepresentationItem,0> { IfcTopologicalRepresentationItem() : Object("IfcTopologicalRepresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcFace
-    struct IfcFace : IfcTopologicalRepresentationItem, ObjectHelper<IfcFace,1> { IfcFace() : Object("IfcFace") {}
-		ListOf< Lazy< IfcFaceBound >, 1, 0 > Bounds;
-    };
-
-    // C++ wrapper for IfcFaceSurface
-    struct IfcFaceSurface : IfcFace, ObjectHelper<IfcFaceSurface,2> { IfcFaceSurface() : Object("IfcFaceSurface") {}
-		Lazy< IfcSurface > FaceSurface;
-		IfcBoolean::Out SameSense;
-    };
-
-    // C++ wrapper for IfcAdvancedFace
-    struct IfcAdvancedFace : IfcFaceSurface, ObjectHelper<IfcAdvancedFace,0> { IfcAdvancedFace() : Object("IfcAdvancedFace") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionFlowElement
-    struct IfcDistributionFlowElement : IfcDistributionElement, ObjectHelper<IfcDistributionFlowElement,0> { IfcDistributionFlowElement() : Object("IfcDistributionFlowElement") {}
-
-    };
-
-    // C++ wrapper for IfcFlowTerminal
-    struct IfcFlowTerminal : IfcDistributionFlowElement, ObjectHelper<IfcFlowTerminal,0> { IfcFlowTerminal() : Object("IfcFlowTerminal") {}
-
-    };
-
-    // C++ wrapper for IfcAirTerminal
-    struct IfcAirTerminal : IfcFlowTerminal, ObjectHelper<IfcAirTerminal,1> { IfcAirTerminal() : Object("IfcAirTerminal") {}
-		Maybe< IfcAirTerminalTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowController
-    struct IfcFlowController : IfcDistributionFlowElement, ObjectHelper<IfcFlowController,0> { IfcFlowController() : Object("IfcFlowController") {}
-
-    };
-
-    // C++ wrapper for IfcAirTerminalBox
-    struct IfcAirTerminalBox : IfcFlowController, ObjectHelper<IfcAirTerminalBox,1> { IfcAirTerminalBox() : Object("IfcAirTerminalBox") {}
-		Maybe< IfcAirTerminalBoxTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionFlowElementType
-    struct IfcDistributionFlowElementType : IfcDistributionElementType, ObjectHelper<IfcDistributionFlowElementType,0> { IfcDistributionFlowElementType() : Object("IfcDistributionFlowElementType") {}
-
-    };
-
-    // C++ wrapper for IfcFlowControllerType
-    struct IfcFlowControllerType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowControllerType,0> { IfcFlowControllerType() : Object("IfcFlowControllerType") {}
-
-    };
-
-    // C++ wrapper for IfcAirTerminalBoxType
-    struct IfcAirTerminalBoxType : IfcFlowControllerType, ObjectHelper<IfcAirTerminalBoxType,1> { IfcAirTerminalBoxType() : Object("IfcAirTerminalBoxType") {}
-		IfcAirTerminalBoxTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowTerminalType
-    struct IfcFlowTerminalType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTerminalType,0> { IfcFlowTerminalType() : Object("IfcFlowTerminalType") {}
-
-    };
-
-    // C++ wrapper for IfcAirTerminalType
-    struct IfcAirTerminalType : IfcFlowTerminalType, ObjectHelper<IfcAirTerminalType,1> { IfcAirTerminalType() : Object("IfcAirTerminalType") {}
-		IfcAirTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEnergyConversionDevice
-    struct IfcEnergyConversionDevice : IfcDistributionFlowElement, ObjectHelper<IfcEnergyConversionDevice,0> { IfcEnergyConversionDevice() : Object("IfcEnergyConversionDevice") {}
-
-    };
-
-    // C++ wrapper for IfcAirToAirHeatRecovery
-    struct IfcAirToAirHeatRecovery : IfcEnergyConversionDevice, ObjectHelper<IfcAirToAirHeatRecovery,1> { IfcAirToAirHeatRecovery() : Object("IfcAirToAirHeatRecovery") {}
-		Maybe< IfcAirToAirHeatRecoveryTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcEnergyConversionDeviceType
-    struct IfcEnergyConversionDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcEnergyConversionDeviceType,0> { IfcEnergyConversionDeviceType() : Object("IfcEnergyConversionDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcAirToAirHeatRecoveryType
-    struct IfcAirToAirHeatRecoveryType : IfcEnergyConversionDeviceType, ObjectHelper<IfcAirToAirHeatRecoveryType,1> { IfcAirToAirHeatRecoveryType() : Object("IfcAirToAirHeatRecoveryType") {}
-		IfcAirToAirHeatRecoveryTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcAlarm
-    struct IfcAlarm : IfcDistributionControlElement, ObjectHelper<IfcAlarm,1> { IfcAlarm() : Object("IfcAlarm") {}
-		Maybe< IfcAlarmTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcAlarmType
-    struct IfcAlarmType : IfcDistributionControlElementType, ObjectHelper<IfcAlarmType,1> { IfcAlarmType() : Object("IfcAlarmType") {}
-		IfcAlarmTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcAnnotation
-    struct IfcAnnotation : IfcProduct, ObjectHelper<IfcAnnotation,0> { IfcAnnotation() : Object("IfcAnnotation") {}
-
-    };
-
-    // C++ wrapper for IfcAnnotationFillArea
-    struct IfcAnnotationFillArea : IfcGeometricRepresentationItem, ObjectHelper<IfcAnnotationFillArea,2> { IfcAnnotationFillArea() : Object("IfcAnnotationFillArea") {}
-		Lazy< IfcCurve > OuterBoundary;
-		Maybe< ListOf< Lazy< IfcCurve >, 1, 0 > > InnerBoundaries;
-    };
-
-    // C++ wrapper for IfcProfileDef
-    struct IfcProfileDef :  ObjectHelper<IfcProfileDef,2> { IfcProfileDef() : Object("IfcProfileDef") {}
-		IfcProfileTypeEnum::Out ProfileType;
-		Maybe< IfcLabel::Out > ProfileName;
-    };
-
-    // C++ wrapper for IfcArbitraryClosedProfileDef
-    struct IfcArbitraryClosedProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryClosedProfileDef,1> { IfcArbitraryClosedProfileDef() : Object("IfcArbitraryClosedProfileDef") {}
-		Lazy< IfcCurve > OuterCurve;
-    };
-
-    // C++ wrapper for IfcArbitraryOpenProfileDef
-    struct IfcArbitraryOpenProfileDef : IfcProfileDef, ObjectHelper<IfcArbitraryOpenProfileDef,1> { IfcArbitraryOpenProfileDef() : Object("IfcArbitraryOpenProfileDef") {}
-		Lazy< IfcBoundedCurve > Curve;
-    };
-
-    // C++ wrapper for IfcArbitraryProfileDefWithVoids
-    struct IfcArbitraryProfileDefWithVoids : IfcArbitraryClosedProfileDef, ObjectHelper<IfcArbitraryProfileDefWithVoids,1> { IfcArbitraryProfileDefWithVoids() : Object("IfcArbitraryProfileDefWithVoids") {}
-		ListOf< Lazy< IfcCurve >, 1, 0 > InnerCurves;
-    };
-
-    // C++ wrapper for IfcGroup
-    struct IfcGroup : IfcObject, ObjectHelper<IfcGroup,0> { IfcGroup() : Object("IfcGroup") {}
-
-    };
-
-    // C++ wrapper for IfcAsset
-    struct IfcAsset : IfcGroup, ObjectHelper<IfcAsset,9> { IfcAsset() : Object("IfcAsset") {}
-		Maybe< IfcIdentifier::Out > Identification;
-		Maybe< Lazy< NotImplemented > > OriginalValue;
-		Maybe< Lazy< NotImplemented > > CurrentValue;
-		Maybe< Lazy< NotImplemented > > TotalReplacementCost;
-		Maybe< IfcActorSelect::Out > Owner;
-		Maybe< IfcActorSelect::Out > User;
-		Maybe< Lazy< NotImplemented > > ResponsiblePerson;
-		Maybe< IfcDate::Out > IncorporationDate;
-		Maybe< Lazy< NotImplemented > > DepreciatedValue;
-    };
-
-    // C++ wrapper for IfcParameterizedProfileDef
-    struct IfcParameterizedProfileDef : IfcProfileDef, ObjectHelper<IfcParameterizedProfileDef,1> { IfcParameterizedProfileDef() : Object("IfcParameterizedProfileDef") {}
-		Maybe< Lazy< IfcAxis2Placement2D > > Position;
-    };
-
-    // C++ wrapper for IfcAsymmetricIShapeProfileDef
-    struct IfcAsymmetricIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcAsymmetricIShapeProfileDef,12> { IfcAsymmetricIShapeProfileDef() : Object("IfcAsymmetricIShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out BottomFlangeWidth;
-		IfcPositiveLengthMeasure::Out OverallDepth;
-		IfcPositiveLengthMeasure::Out WebThickness;
-		IfcPositiveLengthMeasure::Out BottomFlangeThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > BottomFlangeFilletRadius;
-		IfcPositiveLengthMeasure::Out TopFlangeWidth;
-		Maybe< IfcPositiveLengthMeasure::Out > TopFlangeThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > TopFlangeFilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > BottomFlangeEdgeRadius;
-		Maybe< IfcPlaneAngleMeasure::Out > BottomFlangeSlope;
-		Maybe< IfcNonNegativeLengthMeasure::Out > TopFlangeEdgeRadius;
-		Maybe< IfcPlaneAngleMeasure::Out > TopFlangeSlope;
-    };
-
-    // C++ wrapper for IfcAudioVisualAppliance
-    struct IfcAudioVisualAppliance : IfcFlowTerminal, ObjectHelper<IfcAudioVisualAppliance,1> { IfcAudioVisualAppliance() : Object("IfcAudioVisualAppliance") {}
-		Maybe< IfcAudioVisualApplianceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcAudioVisualApplianceType
-    struct IfcAudioVisualApplianceType : IfcFlowTerminalType, ObjectHelper<IfcAudioVisualApplianceType,1> { IfcAudioVisualApplianceType() : Object("IfcAudioVisualApplianceType") {}
-		IfcAudioVisualApplianceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPlacement
-    struct IfcPlacement : IfcGeometricRepresentationItem, ObjectHelper<IfcPlacement,1> { IfcPlacement() : Object("IfcPlacement") {}
-		Lazy< IfcCartesianPoint > Location;
-    };
-
-    // C++ wrapper for IfcAxis1Placement
-    struct IfcAxis1Placement : IfcPlacement, ObjectHelper<IfcAxis1Placement,1> { IfcAxis1Placement() : Object("IfcAxis1Placement") {}
-		Maybe< Lazy< IfcDirection > > Axis;
-    };
-
-    // C++ wrapper for IfcAxis2Placement2D
-    struct IfcAxis2Placement2D : IfcPlacement, ObjectHelper<IfcAxis2Placement2D,1> { IfcAxis2Placement2D() : Object("IfcAxis2Placement2D") {}
-		Maybe< Lazy< IfcDirection > > RefDirection;
-    };
-
-    // C++ wrapper for IfcAxis2Placement3D
-    struct IfcAxis2Placement3D : IfcPlacement, ObjectHelper<IfcAxis2Placement3D,2> { IfcAxis2Placement3D() : Object("IfcAxis2Placement3D") {}
-		Maybe< Lazy< IfcDirection > > Axis;
-		Maybe< Lazy< IfcDirection > > RefDirection;
-    };
-
-    // C++ wrapper for IfcCurve
-    struct IfcCurve : IfcGeometricRepresentationItem, ObjectHelper<IfcCurve,0> { IfcCurve() : Object("IfcCurve") {}
-
-    };
-
-    // C++ wrapper for IfcBoundedCurve
-    struct IfcBoundedCurve : IfcCurve, ObjectHelper<IfcBoundedCurve,0> { IfcBoundedCurve() : Object("IfcBoundedCurve") {}
-
-    };
-
-    // C++ wrapper for IfcBSplineCurve
-    struct IfcBSplineCurve : IfcBoundedCurve, ObjectHelper<IfcBSplineCurve,5> { IfcBSplineCurve() : Object("IfcBSplineCurve") {}
-		IfcInteger::Out Degree;
-		ListOf< Lazy< IfcCartesianPoint >, 2, 0 > ControlPointsList;
-		IfcBSplineCurveForm::Out CurveForm;
-		IfcLogical::Out ClosedCurve;
-		IfcLogical::Out SelfIntersect;
-    };
-
-    // C++ wrapper for IfcBSplineCurveWithKnots
-    struct IfcBSplineCurveWithKnots : IfcBSplineCurve, ObjectHelper<IfcBSplineCurveWithKnots,3> { IfcBSplineCurveWithKnots() : Object("IfcBSplineCurveWithKnots") {}
-		ListOf< IfcInteger, 2, 0 >::Out KnotMultiplicities;
-		ListOf< IfcParameterValue, 2, 0 >::Out Knots;
-		IfcKnotType::Out KnotSpec;
-    };
-
-    // C++ wrapper for IfcSurface
-    struct IfcSurface : IfcGeometricRepresentationItem, ObjectHelper<IfcSurface,0> { IfcSurface() : Object("IfcSurface") {}
-
-    };
-
-    // C++ wrapper for IfcBoundedSurface
-    struct IfcBoundedSurface : IfcSurface, ObjectHelper<IfcBoundedSurface,0> { IfcBoundedSurface() : Object("IfcBoundedSurface") {}
-
-    };
-
-    // C++ wrapper for IfcBSplineSurface
-    struct IfcBSplineSurface : IfcBoundedSurface, ObjectHelper<IfcBSplineSurface,6> { IfcBSplineSurface() : Object("IfcBSplineSurface") {}
-		IfcInteger::Out UDegree;
-		IfcInteger::Out VDegree;
-		IfcBSplineSurfaceForm::Out SurfaceForm;
-		IfcLogical::Out UClosed;
-		IfcLogical::Out VClosed;
-		IfcLogical::Out SelfIntersect;
-    };
-
-    // C++ wrapper for IfcBSplineSurfaceWithKnots
-    struct IfcBSplineSurfaceWithKnots : IfcBSplineSurface, ObjectHelper<IfcBSplineSurfaceWithKnots,5> { IfcBSplineSurfaceWithKnots() : Object("IfcBSplineSurfaceWithKnots") {}
-		ListOf< IfcInteger, 2, 0 >::Out UMultiplicities;
-		ListOf< IfcInteger, 2, 0 >::Out VMultiplicities;
-		ListOf< IfcParameterValue, 2, 0 >::Out UKnots;
-		ListOf< IfcParameterValue, 2, 0 >::Out VKnots;
-		IfcKnotType::Out KnotSpec;
-    };
-
-    // C++ wrapper for IfcBuildingElement
-    struct IfcBuildingElement : IfcElement, ObjectHelper<IfcBuildingElement,0> { IfcBuildingElement() : Object("IfcBuildingElement") {}
-
-    };
-
-    // C++ wrapper for IfcBeam
-    struct IfcBeam : IfcBuildingElement, ObjectHelper<IfcBeam,1> { IfcBeam() : Object("IfcBeam") {}
-		Maybe< IfcBeamTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcBeamStandardCase
-    struct IfcBeamStandardCase : IfcBeam, ObjectHelper<IfcBeamStandardCase,0> { IfcBeamStandardCase() : Object("IfcBeamStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingElementType
-    struct IfcBuildingElementType : IfcElementType, ObjectHelper<IfcBuildingElementType,0> { IfcBuildingElementType() : Object("IfcBuildingElementType") {}
-
-    };
-
-    // C++ wrapper for IfcBeamType
-    struct IfcBeamType : IfcBuildingElementType, ObjectHelper<IfcBeamType,1> { IfcBeamType() : Object("IfcBeamType") {}
-		IfcBeamTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPresentationItem
-    struct IfcPresentationItem :  ObjectHelper<IfcPresentationItem,0> { IfcPresentationItem() : Object("IfcPresentationItem") {}
-
-    };
-
-    // C++ wrapper for IfcCsgPrimitive3D
-    struct IfcCsgPrimitive3D : IfcGeometricRepresentationItem, ObjectHelper<IfcCsgPrimitive3D,1> { IfcCsgPrimitive3D() : Object("IfcCsgPrimitive3D") {}
-		Lazy< IfcAxis2Placement3D > Position;
-    };
-
-    // C++ wrapper for IfcBlock
-    struct IfcBlock : IfcCsgPrimitive3D, ObjectHelper<IfcBlock,3> { IfcBlock() : Object("IfcBlock") {}
-		IfcPositiveLengthMeasure::Out XLength;
-		IfcPositiveLengthMeasure::Out YLength;
-		IfcPositiveLengthMeasure::Out ZLength;
-    };
-
-    // C++ wrapper for IfcBoiler
-    struct IfcBoiler : IfcEnergyConversionDevice, ObjectHelper<IfcBoiler,1> { IfcBoiler() : Object("IfcBoiler") {}
-		Maybe< IfcBoilerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcBoilerType
-    struct IfcBoilerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBoilerType,1> { IfcBoilerType() : Object("IfcBoilerType") {}
-		IfcBoilerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcBooleanResult
-    struct IfcBooleanResult : IfcGeometricRepresentationItem, ObjectHelper<IfcBooleanResult,3> { IfcBooleanResult() : Object("IfcBooleanResult") {}
-		IfcBooleanOperator::Out Operator;
-		IfcBooleanOperand::Out FirstOperand;
-		IfcBooleanOperand::Out SecondOperand;
-    };
-
-    // C++ wrapper for IfcBooleanClippingResult
-    struct IfcBooleanClippingResult : IfcBooleanResult, ObjectHelper<IfcBooleanClippingResult,0> { IfcBooleanClippingResult() : Object("IfcBooleanClippingResult") {}
-
-    };
-
-    // C++ wrapper for IfcCompositeCurve
-    struct IfcCompositeCurve : IfcBoundedCurve, ObjectHelper<IfcCompositeCurve,2> { IfcCompositeCurve() : Object("IfcCompositeCurve") {}
-		ListOf< Lazy< IfcCompositeCurveSegment >, 1, 0 > Segments;
-		IfcLogical::Out SelfIntersect;
-    };
-
-    // C++ wrapper for IfcCompositeCurveOnSurface
-    struct IfcCompositeCurveOnSurface : IfcCompositeCurve, ObjectHelper<IfcCompositeCurveOnSurface,0> { IfcCompositeCurveOnSurface() : Object("IfcCompositeCurveOnSurface") {}
-
-    };
-
-    // C++ wrapper for IfcBoundaryCurve
-    struct IfcBoundaryCurve : IfcCompositeCurveOnSurface, ObjectHelper<IfcBoundaryCurve,0> { IfcBoundaryCurve() : Object("IfcBoundaryCurve") {}
-
-    };
-
-    // C++ wrapper for IfcBoundingBox
-    struct IfcBoundingBox : IfcGeometricRepresentationItem, ObjectHelper<IfcBoundingBox,4> { IfcBoundingBox() : Object("IfcBoundingBox") {}
-		Lazy< IfcCartesianPoint > Corner;
-		IfcPositiveLengthMeasure::Out XDim;
-		IfcPositiveLengthMeasure::Out YDim;
-		IfcPositiveLengthMeasure::Out ZDim;
-    };
-
-    // C++ wrapper for IfcHalfSpaceSolid
-    struct IfcHalfSpaceSolid : IfcGeometricRepresentationItem, ObjectHelper<IfcHalfSpaceSolid,2> { IfcHalfSpaceSolid() : Object("IfcHalfSpaceSolid") {}
-		Lazy< IfcSurface > BaseSurface;
-		IfcBoolean::Out AgreementFlag;
-    };
-
-    // C++ wrapper for IfcBoxedHalfSpace
-    struct IfcBoxedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcBoxedHalfSpace,1> { IfcBoxedHalfSpace() : Object("IfcBoxedHalfSpace") {}
-		Lazy< IfcBoundingBox > Enclosure;
-    };
-
-    // C++ wrapper for IfcSpatialElement
-    struct IfcSpatialElement : IfcProduct, ObjectHelper<IfcSpatialElement,1> { IfcSpatialElement() : Object("IfcSpatialElement") {}
-		Maybe< IfcLabel::Out > LongName;
-    };
-
-    // C++ wrapper for IfcSpatialStructureElement
-    struct IfcSpatialStructureElement : IfcSpatialElement, ObjectHelper<IfcSpatialStructureElement,1> { IfcSpatialStructureElement() : Object("IfcSpatialStructureElement") {}
-		Maybe< IfcElementCompositionEnum::Out > CompositionType;
-    };
-
-    // C++ wrapper for IfcBuilding
-    struct IfcBuilding : IfcSpatialStructureElement, ObjectHelper<IfcBuilding,3> { IfcBuilding() : Object("IfcBuilding") {}
-		Maybe< IfcLengthMeasure::Out > ElevationOfRefHeight;
-		Maybe< IfcLengthMeasure::Out > ElevationOfTerrain;
-		Maybe< Lazy< NotImplemented > > BuildingAddress;
-    };
-
-    // C++ wrapper for IfcElementComponent
-    struct IfcElementComponent : IfcElement, ObjectHelper<IfcElementComponent,0> { IfcElementComponent() : Object("IfcElementComponent") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingElementPart
-    struct IfcBuildingElementPart : IfcElementComponent, ObjectHelper<IfcBuildingElementPart,1> { IfcBuildingElementPart() : Object("IfcBuildingElementPart") {}
-		Maybe< IfcBuildingElementPartTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElementComponentType
-    struct IfcElementComponentType : IfcElementType, ObjectHelper<IfcElementComponentType,0> { IfcElementComponentType() : Object("IfcElementComponentType") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingElementPartType
-    struct IfcBuildingElementPartType : IfcElementComponentType, ObjectHelper<IfcBuildingElementPartType,1> { IfcBuildingElementPartType() : Object("IfcBuildingElementPartType") {}
-		IfcBuildingElementPartTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcBuildingElementProxy
-    struct IfcBuildingElementProxy : IfcBuildingElement, ObjectHelper<IfcBuildingElementProxy,1> { IfcBuildingElementProxy() : Object("IfcBuildingElementProxy") {}
-		Maybe< IfcBuildingElementProxyTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcBuildingElementProxyType
-    struct IfcBuildingElementProxyType : IfcBuildingElementType, ObjectHelper<IfcBuildingElementProxyType,1> { IfcBuildingElementProxyType() : Object("IfcBuildingElementProxyType") {}
-		IfcBuildingElementProxyTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcBuildingStorey
-    struct IfcBuildingStorey : IfcSpatialStructureElement, ObjectHelper<IfcBuildingStorey,1> { IfcBuildingStorey() : Object("IfcBuildingStorey") {}
-		Maybe< IfcLengthMeasure::Out > Elevation;
-    };
-
-    // C++ wrapper for IfcSystem
-    struct IfcSystem : IfcGroup, ObjectHelper<IfcSystem,0> { IfcSystem() : Object("IfcSystem") {}
-
-    };
-
-    // C++ wrapper for IfcBuildingSystem
-    struct IfcBuildingSystem : IfcSystem, ObjectHelper<IfcBuildingSystem,2> { IfcBuildingSystem() : Object("IfcBuildingSystem") {}
-		Maybe< IfcBuildingSystemTypeEnum::Out > PredefinedType;
-		Maybe< IfcLabel::Out > LongName;
-    };
-
-    // C++ wrapper for IfcBurner
-    struct IfcBurner : IfcEnergyConversionDevice, ObjectHelper<IfcBurner,1> { IfcBurner() : Object("IfcBurner") {}
-		Maybe< IfcBurnerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcBurnerType
-    struct IfcBurnerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcBurnerType,1> { IfcBurnerType() : Object("IfcBurnerType") {}
-		IfcBurnerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCShapeProfileDef
-    struct IfcCShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCShapeProfileDef,5> { IfcCShapeProfileDef() : Object("IfcCShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out Depth;
-		IfcPositiveLengthMeasure::Out Width;
-		IfcPositiveLengthMeasure::Out WallThickness;
-		IfcPositiveLengthMeasure::Out Girth;
-		Maybe< IfcNonNegativeLengthMeasure::Out > InternalFilletRadius;
-    };
-
-    // C++ wrapper for IfcFlowFitting
-    struct IfcFlowFitting : IfcDistributionFlowElement, ObjectHelper<IfcFlowFitting,0> { IfcFlowFitting() : Object("IfcFlowFitting") {}
-
-    };
-
-    // C++ wrapper for IfcCableCarrierFitting
-    struct IfcCableCarrierFitting : IfcFlowFitting, ObjectHelper<IfcCableCarrierFitting,1> { IfcCableCarrierFitting() : Object("IfcCableCarrierFitting") {}
-		Maybe< IfcCableCarrierFittingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowFittingType
-    struct IfcFlowFittingType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowFittingType,0> { IfcFlowFittingType() : Object("IfcFlowFittingType") {}
-
-    };
-
-    // C++ wrapper for IfcCableCarrierFittingType
-    struct IfcCableCarrierFittingType : IfcFlowFittingType, ObjectHelper<IfcCableCarrierFittingType,1> { IfcCableCarrierFittingType() : Object("IfcCableCarrierFittingType") {}
-		IfcCableCarrierFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowSegment
-    struct IfcFlowSegment : IfcDistributionFlowElement, ObjectHelper<IfcFlowSegment,0> { IfcFlowSegment() : Object("IfcFlowSegment") {}
-
-    };
-
-    // C++ wrapper for IfcCableCarrierSegment
-    struct IfcCableCarrierSegment : IfcFlowSegment, ObjectHelper<IfcCableCarrierSegment,1> { IfcCableCarrierSegment() : Object("IfcCableCarrierSegment") {}
-		Maybe< IfcCableCarrierSegmentTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowSegmentType
-    struct IfcFlowSegmentType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowSegmentType,0> { IfcFlowSegmentType() : Object("IfcFlowSegmentType") {}
-
-    };
-
-    // C++ wrapper for IfcCableCarrierSegmentType
-    struct IfcCableCarrierSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableCarrierSegmentType,1> { IfcCableCarrierSegmentType() : Object("IfcCableCarrierSegmentType") {}
-		IfcCableCarrierSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCableFitting
-    struct IfcCableFitting : IfcFlowFitting, ObjectHelper<IfcCableFitting,1> { IfcCableFitting() : Object("IfcCableFitting") {}
-		Maybe< IfcCableFittingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCableFittingType
-    struct IfcCableFittingType : IfcFlowFittingType, ObjectHelper<IfcCableFittingType,1> { IfcCableFittingType() : Object("IfcCableFittingType") {}
-		IfcCableFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCableSegment
-    struct IfcCableSegment : IfcFlowSegment, ObjectHelper<IfcCableSegment,1> { IfcCableSegment() : Object("IfcCableSegment") {}
-		Maybe< IfcCableSegmentTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCableSegmentType
-    struct IfcCableSegmentType : IfcFlowSegmentType, ObjectHelper<IfcCableSegmentType,1> { IfcCableSegmentType() : Object("IfcCableSegmentType") {}
-		IfcCableSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPoint
-    struct IfcPoint : IfcGeometricRepresentationItem, ObjectHelper<IfcPoint,0> { IfcPoint() : Object("IfcPoint") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianPoint
-    struct IfcCartesianPoint : IfcPoint, ObjectHelper<IfcCartesianPoint,1> { IfcCartesianPoint() : Object("IfcCartesianPoint") {}
-		ListOf< IfcLengthMeasure, 1, 3 >::Out Coordinates;
-    };
-
-    // C++ wrapper for IfcCartesianPointList
-    struct IfcCartesianPointList : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianPointList,0> { IfcCartesianPointList() : Object("IfcCartesianPointList") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianPointList2D
-    struct IfcCartesianPointList2D : IfcCartesianPointList, ObjectHelper<IfcCartesianPointList2D,0> { IfcCartesianPointList2D() : Object("IfcCartesianPointList2D") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianPointList3D
-    struct IfcCartesianPointList3D : IfcCartesianPointList, ObjectHelper<IfcCartesianPointList3D,0> { IfcCartesianPointList3D() : Object("IfcCartesianPointList3D") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator
-    struct IfcCartesianTransformationOperator : IfcGeometricRepresentationItem, ObjectHelper<IfcCartesianTransformationOperator,4> { IfcCartesianTransformationOperator() : Object("IfcCartesianTransformationOperator") {}
-		Maybe< Lazy< IfcDirection > > Axis1;
-		Maybe< Lazy< IfcDirection > > Axis2;
-		Lazy< IfcCartesianPoint > LocalOrigin;
-		Maybe< IfcReal::Out > Scale;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator2D
-    struct IfcCartesianTransformationOperator2D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator2D,0> { IfcCartesianTransformationOperator2D() : Object("IfcCartesianTransformationOperator2D") {}
-
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator2DnonUniform
-    struct IfcCartesianTransformationOperator2DnonUniform : IfcCartesianTransformationOperator2D, ObjectHelper<IfcCartesianTransformationOperator2DnonUniform,1> { IfcCartesianTransformationOperator2DnonUniform() : Object("IfcCartesianTransformationOperator2DnonUniform") {}
-		Maybe< IfcReal::Out > Scale2;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator3D
-    struct IfcCartesianTransformationOperator3D : IfcCartesianTransformationOperator, ObjectHelper<IfcCartesianTransformationOperator3D,1> { IfcCartesianTransformationOperator3D() : Object("IfcCartesianTransformationOperator3D") {}
-		Maybe< Lazy< IfcDirection > > Axis3;
-    };
-
-    // C++ wrapper for IfcCartesianTransformationOperator3DnonUniform
-    struct IfcCartesianTransformationOperator3DnonUniform : IfcCartesianTransformationOperator3D, ObjectHelper<IfcCartesianTransformationOperator3DnonUniform,2> { IfcCartesianTransformationOperator3DnonUniform() : Object("IfcCartesianTransformationOperator3DnonUniform") {}
-		Maybe< IfcReal::Out > Scale2;
-		Maybe< IfcReal::Out > Scale3;
-    };
-
-    // C++ wrapper for IfcCenterLineProfileDef
-    struct IfcCenterLineProfileDef : IfcArbitraryOpenProfileDef, ObjectHelper<IfcCenterLineProfileDef,1> { IfcCenterLineProfileDef() : Object("IfcCenterLineProfileDef") {}
-		IfcPositiveLengthMeasure::Out Thickness;
-    };
-
-    // C++ wrapper for IfcChiller
-    struct IfcChiller : IfcEnergyConversionDevice, ObjectHelper<IfcChiller,1> { IfcChiller() : Object("IfcChiller") {}
-		Maybe< IfcChillerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcChillerType
-    struct IfcChillerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcChillerType,1> { IfcChillerType() : Object("IfcChillerType") {}
-		IfcChillerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcChimney
-    struct IfcChimney : IfcBuildingElement, ObjectHelper<IfcChimney,1> { IfcChimney() : Object("IfcChimney") {}
-		Maybe< IfcChimneyTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcChimneyType
-    struct IfcChimneyType : IfcBuildingElementType, ObjectHelper<IfcChimneyType,1> { IfcChimneyType() : Object("IfcChimneyType") {}
-		IfcChimneyTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcConic
-    struct IfcConic : IfcCurve, ObjectHelper<IfcConic,1> { IfcConic() : Object("IfcConic") {}
-		IfcAxis2Placement::Out Position;
-    };
-
-    // C++ wrapper for IfcCircle
-    struct IfcCircle : IfcConic, ObjectHelper<IfcCircle,1> { IfcCircle() : Object("IfcCircle") {}
-		IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcCircleProfileDef
-    struct IfcCircleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcCircleProfileDef,1> { IfcCircleProfileDef() : Object("IfcCircleProfileDef") {}
-		IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcCircleHollowProfileDef
-    struct IfcCircleHollowProfileDef : IfcCircleProfileDef, ObjectHelper<IfcCircleHollowProfileDef,1> { IfcCircleHollowProfileDef() : Object("IfcCircleHollowProfileDef") {}
-		IfcPositiveLengthMeasure::Out WallThickness;
-    };
-
-    // C++ wrapper for IfcCivilElement
-    struct IfcCivilElement : IfcElement, ObjectHelper<IfcCivilElement,0> { IfcCivilElement() : Object("IfcCivilElement") {}
-
-    };
-
-    // C++ wrapper for IfcCivilElementType
-    struct IfcCivilElementType : IfcElementType, ObjectHelper<IfcCivilElementType,0> { IfcCivilElementType() : Object("IfcCivilElementType") {}
-
-    };
-
-    // C++ wrapper for IfcConnectedFaceSet
-    struct IfcConnectedFaceSet : IfcTopologicalRepresentationItem, ObjectHelper<IfcConnectedFaceSet,1> { IfcConnectedFaceSet() : Object("IfcConnectedFaceSet") {}
-		ListOf< Lazy< IfcFace >, 1, 0 > CfsFaces;
-    };
-
-    // C++ wrapper for IfcClosedShell
-    struct IfcClosedShell : IfcConnectedFaceSet, ObjectHelper<IfcClosedShell,0> { IfcClosedShell() : Object("IfcClosedShell") {}
-
-    };
-
-    // C++ wrapper for IfcCoil
-    struct IfcCoil : IfcEnergyConversionDevice, ObjectHelper<IfcCoil,1> { IfcCoil() : Object("IfcCoil") {}
-		Maybe< IfcCoilTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCoilType
-    struct IfcCoilType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoilType,1> { IfcCoilType() : Object("IfcCoilType") {}
-		IfcCoilTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcColourSpecification
-    struct IfcColourSpecification : IfcPresentationItem, ObjectHelper<IfcColourSpecification,1> { IfcColourSpecification() : Object("IfcColourSpecification") {}
-		Maybe< IfcLabel::Out > Name;
-    };
-
-    // C++ wrapper for IfcColourRgb
-    struct IfcColourRgb : IfcColourSpecification, ObjectHelper<IfcColourRgb,3> { IfcColourRgb() : Object("IfcColourRgb") {}
-		IfcNormalisedRatioMeasure::Out Red;
-		IfcNormalisedRatioMeasure::Out Green;
-		IfcNormalisedRatioMeasure::Out Blue;
-    };
-
-    // C++ wrapper for IfcColumn
-    struct IfcColumn : IfcBuildingElement, ObjectHelper<IfcColumn,1> { IfcColumn() : Object("IfcColumn") {}
-		Maybe< IfcColumnTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcColumnStandardCase
-    struct IfcColumnStandardCase : IfcColumn, ObjectHelper<IfcColumnStandardCase,0> { IfcColumnStandardCase() : Object("IfcColumnStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcColumnType
-    struct IfcColumnType : IfcBuildingElementType, ObjectHelper<IfcColumnType,1> { IfcColumnType() : Object("IfcColumnType") {}
-		IfcColumnTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCommunicationsAppliance
-    struct IfcCommunicationsAppliance : IfcFlowTerminal, ObjectHelper<IfcCommunicationsAppliance,1> { IfcCommunicationsAppliance() : Object("IfcCommunicationsAppliance") {}
-		Maybe< IfcCommunicationsApplianceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCommunicationsApplianceType
-    struct IfcCommunicationsApplianceType : IfcFlowTerminalType, ObjectHelper<IfcCommunicationsApplianceType,1> { IfcCommunicationsApplianceType() : Object("IfcCommunicationsApplianceType") {}
-		IfcCommunicationsApplianceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPropertyAbstraction
-    struct IfcPropertyAbstraction :  ObjectHelper<IfcPropertyAbstraction,0> { IfcPropertyAbstraction() : Object("IfcPropertyAbstraction") {}
-
-    };
-
-    // C++ wrapper for IfcProperty
-    struct IfcProperty : IfcPropertyAbstraction, ObjectHelper<IfcProperty,2> { IfcProperty() : Object("IfcProperty") {}
-		IfcIdentifier::Out Name;
-		Maybe< IfcText::Out > Description;
-    };
-
-    // C++ wrapper for IfcComplexProperty
-    struct IfcComplexProperty : IfcProperty, ObjectHelper<IfcComplexProperty,2> { IfcComplexProperty() : Object("IfcComplexProperty") {}
-		IfcIdentifier::Out UsageName;
-		ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
-    };
-
-    // C++ wrapper for IfcPropertyDefinition
-    struct IfcPropertyDefinition : IfcRoot, ObjectHelper<IfcPropertyDefinition,0> { IfcPropertyDefinition() : Object("IfcPropertyDefinition") {}
-
-    };
-
-    // C++ wrapper for IfcCompositeCurveSegment
-    struct IfcCompositeCurveSegment : IfcGeometricRepresentationItem, ObjectHelper<IfcCompositeCurveSegment,3> { IfcCompositeCurveSegment() : Object("IfcCompositeCurveSegment") {}
-		IfcTransitionCode::Out Transition;
-		IfcBoolean::Out SameSense;
-		Lazy< IfcCurve > ParentCurve;
-    };
-
-    // C++ wrapper for IfcCompositeProfileDef
-    struct IfcCompositeProfileDef : IfcProfileDef, ObjectHelper<IfcCompositeProfileDef,2> { IfcCompositeProfileDef() : Object("IfcCompositeProfileDef") {}
-		ListOf< Lazy< IfcProfileDef >, 2, 0 > Profiles;
-		Maybe< IfcLabel::Out > Label;
-    };
-
-    // C++ wrapper for IfcFlowMovingDevice
-    struct IfcFlowMovingDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowMovingDevice,0> { IfcFlowMovingDevice() : Object("IfcFlowMovingDevice") {}
-
-    };
-
-    // C++ wrapper for IfcCompressor
-    struct IfcCompressor : IfcFlowMovingDevice, ObjectHelper<IfcCompressor,1> { IfcCompressor() : Object("IfcCompressor") {}
-		Maybe< IfcCompressorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowMovingDeviceType
-    struct IfcFlowMovingDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowMovingDeviceType,0> { IfcFlowMovingDeviceType() : Object("IfcFlowMovingDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcCompressorType
-    struct IfcCompressorType : IfcFlowMovingDeviceType, ObjectHelper<IfcCompressorType,1> { IfcCompressorType() : Object("IfcCompressorType") {}
-		IfcCompressorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCondenser
-    struct IfcCondenser : IfcEnergyConversionDevice, ObjectHelper<IfcCondenser,1> { IfcCondenser() : Object("IfcCondenser") {}
-		Maybe< IfcCondenserTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCondenserType
-    struct IfcCondenserType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCondenserType,1> { IfcCondenserType() : Object("IfcCondenserType") {}
-		IfcCondenserTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcResource
-    struct IfcResource : IfcObject, ObjectHelper<IfcResource,2> { IfcResource() : Object("IfcResource") {}
-		Maybe< IfcIdentifier::Out > Identification;
-		Maybe< IfcText::Out > LongDescription;
-    };
-
-    // C++ wrapper for IfcConstructionResource
-    struct IfcConstructionResource : IfcResource, ObjectHelper<IfcConstructionResource,3> { IfcConstructionResource() : Object("IfcConstructionResource") {}
-		Maybe< Lazy< NotImplemented > > Usage;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > BaseCosts;
-		Maybe< Lazy< NotImplemented > > BaseQuantity;
-    };
-
-    // C++ wrapper for IfcConstructionEquipmentResource
-    struct IfcConstructionEquipmentResource : IfcConstructionResource, ObjectHelper<IfcConstructionEquipmentResource,1> { IfcConstructionEquipmentResource() : Object("IfcConstructionEquipmentResource") {}
-		Maybe< IfcConstructionEquipmentResourceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTypeResource
-    struct IfcTypeResource : IfcTypeObject, ObjectHelper<IfcTypeResource,3> { IfcTypeResource() : Object("IfcTypeResource") {}
-		Maybe< IfcIdentifier::Out > Identification;
-		Maybe< IfcText::Out > LongDescription;
-		Maybe< IfcLabel::Out > ResourceType;
-    };
-
-    // C++ wrapper for IfcConstructionResourceType
-    struct IfcConstructionResourceType : IfcTypeResource, ObjectHelper<IfcConstructionResourceType,2> { IfcConstructionResourceType() : Object("IfcConstructionResourceType") {}
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > BaseCosts;
-		Maybe< Lazy< NotImplemented > > BaseQuantity;
-    };
-
-    // C++ wrapper for IfcConstructionEquipmentResourceType
-    struct IfcConstructionEquipmentResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionEquipmentResourceType,1> { IfcConstructionEquipmentResourceType() : Object("IfcConstructionEquipmentResourceType") {}
-		IfcConstructionEquipmentResourceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcConstructionMaterialResource
-    struct IfcConstructionMaterialResource : IfcConstructionResource, ObjectHelper<IfcConstructionMaterialResource,1> { IfcConstructionMaterialResource() : Object("IfcConstructionMaterialResource") {}
-		Maybe< IfcConstructionMaterialResourceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcConstructionMaterialResourceType
-    struct IfcConstructionMaterialResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionMaterialResourceType,1> { IfcConstructionMaterialResourceType() : Object("IfcConstructionMaterialResourceType") {}
-		IfcConstructionMaterialResourceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcConstructionProductResource
-    struct IfcConstructionProductResource : IfcConstructionResource, ObjectHelper<IfcConstructionProductResource,1> { IfcConstructionProductResource() : Object("IfcConstructionProductResource") {}
-		Maybe< IfcConstructionProductResourceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcConstructionProductResourceType
-    struct IfcConstructionProductResourceType : IfcConstructionResourceType, ObjectHelper<IfcConstructionProductResourceType,1> { IfcConstructionProductResourceType() : Object("IfcConstructionProductResourceType") {}
-		IfcConstructionProductResourceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcContext
-    struct IfcContext : IfcObjectDefinition, ObjectHelper<IfcContext,5> { IfcContext() : Object("IfcContext") {}
-		Maybe< IfcLabel::Out > ObjectType;
-		Maybe< IfcLabel::Out > LongName;
-		Maybe< IfcLabel::Out > Phase;
-		Maybe< ListOf< Lazy< IfcRepresentationContext >, 1, 0 > > RepresentationContexts;
-		Maybe< Lazy< IfcUnitAssignment > > UnitsInContext;
-    };
-
-    // C++ wrapper for IfcNamedUnit
-    struct IfcNamedUnit :  ObjectHelper<IfcNamedUnit,2> { IfcNamedUnit() : Object("IfcNamedUnit") {}
-		Lazy< NotImplemented > Dimensions;
-		IfcUnitEnum::Out UnitType;
-    };
-
-    // C++ wrapper for IfcContextDependentUnit
-    struct IfcContextDependentUnit : IfcNamedUnit, ObjectHelper<IfcContextDependentUnit,1> { IfcContextDependentUnit() : Object("IfcContextDependentUnit") {}
-		IfcLabel::Out Name;
-    };
-
-    // C++ wrapper for IfcController
-    struct IfcController : IfcDistributionControlElement, ObjectHelper<IfcController,1> { IfcController() : Object("IfcController") {}
-		Maybe< IfcControllerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcControllerType
-    struct IfcControllerType : IfcDistributionControlElementType, ObjectHelper<IfcControllerType,1> { IfcControllerType() : Object("IfcControllerType") {}
-		IfcControllerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcConversionBasedUnit
-    struct IfcConversionBasedUnit : IfcNamedUnit, ObjectHelper<IfcConversionBasedUnit,2> { IfcConversionBasedUnit() : Object("IfcConversionBasedUnit") {}
-		IfcLabel::Out Name;
-		Lazy< IfcMeasureWithUnit > ConversionFactor;
-    };
-
-    // C++ wrapper for IfcConversionBasedUnitWithOffset
-    struct IfcConversionBasedUnitWithOffset : IfcConversionBasedUnit, ObjectHelper<IfcConversionBasedUnitWithOffset,1> { IfcConversionBasedUnitWithOffset() : Object("IfcConversionBasedUnitWithOffset") {}
-		IfcReal::Out ConversionOffset;
-    };
-
-    // C++ wrapper for IfcCooledBeam
-    struct IfcCooledBeam : IfcEnergyConversionDevice, ObjectHelper<IfcCooledBeam,1> { IfcCooledBeam() : Object("IfcCooledBeam") {}
-		Maybe< IfcCooledBeamTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCooledBeamType
-    struct IfcCooledBeamType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCooledBeamType,1> { IfcCooledBeamType() : Object("IfcCooledBeamType") {}
-		IfcCooledBeamTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCoolingTower
-    struct IfcCoolingTower : IfcEnergyConversionDevice, ObjectHelper<IfcCoolingTower,1> { IfcCoolingTower() : Object("IfcCoolingTower") {}
-		Maybe< IfcCoolingTowerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCoolingTowerType
-    struct IfcCoolingTowerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcCoolingTowerType,1> { IfcCoolingTowerType() : Object("IfcCoolingTowerType") {}
-		IfcCoolingTowerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCostItem
-    struct IfcCostItem : IfcControl, ObjectHelper<IfcCostItem,3> { IfcCostItem() : Object("IfcCostItem") {}
-		Maybe< IfcCostItemTypeEnum::Out > PredefinedType;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > CostValues;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > CostQuantities;
-    };
-
-    // C++ wrapper for IfcCostSchedule
-    struct IfcCostSchedule : IfcControl, ObjectHelper<IfcCostSchedule,4> { IfcCostSchedule() : Object("IfcCostSchedule") {}
-		Maybe< IfcCostScheduleTypeEnum::Out > PredefinedType;
-		Maybe< IfcLabel::Out > Status;
-		Maybe< IfcDateTime::Out > SubmittedOn;
-		Maybe< IfcDateTime::Out > UpdateDate;
-    };
-
-    // C++ wrapper for IfcCovering
-    struct IfcCovering : IfcBuildingElement, ObjectHelper<IfcCovering,1> { IfcCovering() : Object("IfcCovering") {}
-		Maybe< IfcCoveringTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCoveringType
-    struct IfcCoveringType : IfcBuildingElementType, ObjectHelper<IfcCoveringType,1> { IfcCoveringType() : Object("IfcCoveringType") {}
-		IfcCoveringTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCrewResource
-    struct IfcCrewResource : IfcConstructionResource, ObjectHelper<IfcCrewResource,1> { IfcCrewResource() : Object("IfcCrewResource") {}
-		Maybe< IfcCrewResourceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCrewResourceType
-    struct IfcCrewResourceType : IfcConstructionResourceType, ObjectHelper<IfcCrewResourceType,1> { IfcCrewResourceType() : Object("IfcCrewResourceType") {}
-		IfcCrewResourceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCsgSolid
-    struct IfcCsgSolid : IfcSolidModel, ObjectHelper<IfcCsgSolid,1> { IfcCsgSolid() : Object("IfcCsgSolid") {}
-		IfcCsgSelect::Out TreeRootExpression;
-    };
-
-    // C++ wrapper for IfcCurtainWall
-    struct IfcCurtainWall : IfcBuildingElement, ObjectHelper<IfcCurtainWall,1> { IfcCurtainWall() : Object("IfcCurtainWall") {}
-		Maybe< IfcCurtainWallTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcCurtainWallType
-    struct IfcCurtainWallType : IfcBuildingElementType, ObjectHelper<IfcCurtainWallType,1> { IfcCurtainWallType() : Object("IfcCurtainWallType") {}
-		IfcCurtainWallTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcCurveBoundedPlane
-    struct IfcCurveBoundedPlane : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedPlane,3> { IfcCurveBoundedPlane() : Object("IfcCurveBoundedPlane") {}
-		Lazy< IfcPlane > BasisSurface;
-		Lazy< IfcCurve > OuterBoundary;
-		ListOf< Lazy< IfcCurve >, 0, 0 > InnerBoundaries;
-    };
-
-    // C++ wrapper for IfcCurveBoundedSurface
-    struct IfcCurveBoundedSurface : IfcBoundedSurface, ObjectHelper<IfcCurveBoundedSurface,3> { IfcCurveBoundedSurface() : Object("IfcCurveBoundedSurface") {}
-		Lazy< IfcSurface > BasisSurface;
-		ListOf< Lazy< IfcBoundaryCurve >, 1, 0 > Boundaries;
-		IfcBoolean::Out ImplicitOuter;
-    };
-
-    // C++ wrapper for IfcPresentationStyle
-    struct IfcPresentationStyle :  ObjectHelper<IfcPresentationStyle,1> { IfcPresentationStyle() : Object("IfcPresentationStyle") {}
-		Maybe< IfcLabel::Out > Name;
-    };
-
-    // C++ wrapper for IfcElementarySurface
-    struct IfcElementarySurface : IfcSurface, ObjectHelper<IfcElementarySurface,1> { IfcElementarySurface() : Object("IfcElementarySurface") {}
-		Lazy< IfcAxis2Placement3D > Position;
-    };
-
-    // C++ wrapper for IfcCylindricalSurface
-    struct IfcCylindricalSurface : IfcElementarySurface, ObjectHelper<IfcCylindricalSurface,1> { IfcCylindricalSurface() : Object("IfcCylindricalSurface") {}
-		IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcDamper
-    struct IfcDamper : IfcFlowController, ObjectHelper<IfcDamper,1> { IfcDamper() : Object("IfcDamper") {}
-		Maybe< IfcDamperTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDamperType
-    struct IfcDamperType : IfcFlowControllerType, ObjectHelper<IfcDamperType,1> { IfcDamperType() : Object("IfcDamperType") {}
-		IfcDamperTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDerivedProfileDef
-    struct IfcDerivedProfileDef : IfcProfileDef, ObjectHelper<IfcDerivedProfileDef,3> { IfcDerivedProfileDef() : Object("IfcDerivedProfileDef") {}
-		Lazy< IfcProfileDef > ParentProfile;
-		Lazy< IfcCartesianTransformationOperator2D > Operator;
-		Maybe< IfcLabel::Out > Label;
-    };
-
-    // C++ wrapper for IfcDirection
-    struct IfcDirection : IfcGeometricRepresentationItem, ObjectHelper<IfcDirection,1> { IfcDirection() : Object("IfcDirection") {}
-		ListOf< IfcReal, 2, 3 >::Out DirectionRatios;
-    };
-
-    // C++ wrapper for IfcDiscreteAccessory
-    struct IfcDiscreteAccessory : IfcElementComponent, ObjectHelper<IfcDiscreteAccessory,1> { IfcDiscreteAccessory() : Object("IfcDiscreteAccessory") {}
-		Maybe< IfcDiscreteAccessoryTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDiscreteAccessoryType
-    struct IfcDiscreteAccessoryType : IfcElementComponentType, ObjectHelper<IfcDiscreteAccessoryType,1> { IfcDiscreteAccessoryType() : Object("IfcDiscreteAccessoryType") {}
-		IfcDiscreteAccessoryTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionChamberElement
-    struct IfcDistributionChamberElement : IfcDistributionFlowElement, ObjectHelper<IfcDistributionChamberElement,1> { IfcDistributionChamberElement() : Object("IfcDistributionChamberElement") {}
-		Maybe< IfcDistributionChamberElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionChamberElementType
-    struct IfcDistributionChamberElementType : IfcDistributionFlowElementType, ObjectHelper<IfcDistributionChamberElementType,1> { IfcDistributionChamberElementType() : Object("IfcDistributionChamberElementType") {}
-		IfcDistributionChamberElementTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionSystem
-    struct IfcDistributionSystem : IfcSystem, ObjectHelper<IfcDistributionSystem,2> { IfcDistributionSystem() : Object("IfcDistributionSystem") {}
-		Maybe< IfcLabel::Out > LongName;
-		Maybe< IfcDistributionSystemEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDistributionCircuit
-    struct IfcDistributionCircuit : IfcDistributionSystem, ObjectHelper<IfcDistributionCircuit,0> { IfcDistributionCircuit() : Object("IfcDistributionCircuit") {}
-
-    };
-
-    // C++ wrapper for IfcPort
-    struct IfcPort : IfcProduct, ObjectHelper<IfcPort,0> { IfcPort() : Object("IfcPort") {}
-
-    };
-
-    // C++ wrapper for IfcDistributionPort
-    struct IfcDistributionPort : IfcPort, ObjectHelper<IfcDistributionPort,3> { IfcDistributionPort() : Object("IfcDistributionPort") {}
-		Maybe< IfcFlowDirectionEnum::Out > FlowDirection;
-		Maybe< IfcDistributionPortTypeEnum::Out > PredefinedType;
-		Maybe< IfcDistributionSystemEnum::Out > SystemType;
-    };
-
-    // C++ wrapper for IfcDoor
-    struct IfcDoor : IfcBuildingElement, ObjectHelper<IfcDoor,5> { IfcDoor() : Object("IfcDoor") {}
-		Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
-		Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
-		Maybe< IfcDoorTypeEnum::Out > PredefinedType;
-		Maybe< IfcDoorTypeOperationEnum::Out > OperationType;
-		Maybe< IfcLabel::Out > UserDefinedOperationType;
-    };
-
-    // C++ wrapper for IfcPropertySetDefinition
-    struct IfcPropertySetDefinition : IfcPropertyDefinition, ObjectHelper<IfcPropertySetDefinition,0> { IfcPropertySetDefinition() : Object("IfcPropertySetDefinition") {}
-
-    };
-
-    // C++ wrapper for IfcDoorStandardCase
-    struct IfcDoorStandardCase : IfcDoor, ObjectHelper<IfcDoorStandardCase,0> { IfcDoorStandardCase() : Object("IfcDoorStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcDoorStyle
-    struct IfcDoorStyle : IfcTypeProduct, ObjectHelper<IfcDoorStyle,4> { IfcDoorStyle() : Object("IfcDoorStyle") {}
-		IfcDoorStyleOperationEnum::Out OperationType;
-		IfcDoorStyleConstructionEnum::Out ConstructionType;
-		IfcBoolean::Out ParameterTakesPrecedence;
-		IfcBoolean::Out Sizeable;
-    };
-
-    // C++ wrapper for IfcDoorType
-    struct IfcDoorType : IfcBuildingElementType, ObjectHelper<IfcDoorType,4> { IfcDoorType() : Object("IfcDoorType") {}
-		IfcDoorTypeEnum::Out PredefinedType;
-		IfcDoorTypeOperationEnum::Out OperationType;
-		Maybe< IfcBoolean::Out > ParameterTakesPrecedence;
-		Maybe< IfcLabel::Out > UserDefinedOperationType;
-    };
-
-    // C++ wrapper for IfcDuctFitting
-    struct IfcDuctFitting : IfcFlowFitting, ObjectHelper<IfcDuctFitting,1> { IfcDuctFitting() : Object("IfcDuctFitting") {}
-		Maybe< IfcDuctFittingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDuctFittingType
-    struct IfcDuctFittingType : IfcFlowFittingType, ObjectHelper<IfcDuctFittingType,1> { IfcDuctFittingType() : Object("IfcDuctFittingType") {}
-		IfcDuctFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcDuctSegment
-    struct IfcDuctSegment : IfcFlowSegment, ObjectHelper<IfcDuctSegment,1> { IfcDuctSegment() : Object("IfcDuctSegment") {}
-		Maybe< IfcDuctSegmentTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcDuctSegmentType
-    struct IfcDuctSegmentType : IfcFlowSegmentType, ObjectHelper<IfcDuctSegmentType,1> { IfcDuctSegmentType() : Object("IfcDuctSegmentType") {}
-		IfcDuctSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowTreatmentDevice
-    struct IfcFlowTreatmentDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowTreatmentDevice,0> { IfcFlowTreatmentDevice() : Object("IfcFlowTreatmentDevice") {}
-
-    };
-
-    // C++ wrapper for IfcDuctSilencer
-    struct IfcDuctSilencer : IfcFlowTreatmentDevice, ObjectHelper<IfcDuctSilencer,1> { IfcDuctSilencer() : Object("IfcDuctSilencer") {}
-		Maybe< IfcDuctSilencerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowTreatmentDeviceType
-    struct IfcFlowTreatmentDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowTreatmentDeviceType,0> { IfcFlowTreatmentDeviceType() : Object("IfcFlowTreatmentDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcDuctSilencerType
-    struct IfcDuctSilencerType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcDuctSilencerType,1> { IfcDuctSilencerType() : Object("IfcDuctSilencerType") {}
-		IfcDuctSilencerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEdge
-    struct IfcEdge : IfcTopologicalRepresentationItem, ObjectHelper<IfcEdge,2> { IfcEdge() : Object("IfcEdge") {}
-		Lazy< IfcVertex > EdgeStart;
-		Lazy< IfcVertex > EdgeEnd;
-    };
-
-    // C++ wrapper for IfcEdgeCurve
-    struct IfcEdgeCurve : IfcEdge, ObjectHelper<IfcEdgeCurve,2> { IfcEdgeCurve() : Object("IfcEdgeCurve") {}
-		Lazy< IfcCurve > EdgeGeometry;
-		IfcBoolean::Out SameSense;
-    };
-
-    // C++ wrapper for IfcLoop
-    struct IfcLoop : IfcTopologicalRepresentationItem, ObjectHelper<IfcLoop,0> { IfcLoop() : Object("IfcLoop") {}
-
-    };
-
-    // C++ wrapper for IfcEdgeLoop
-    struct IfcEdgeLoop : IfcLoop, ObjectHelper<IfcEdgeLoop,1> { IfcEdgeLoop() : Object("IfcEdgeLoop") {}
-		ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
-    };
-
-    // C++ wrapper for IfcElectricAppliance
-    struct IfcElectricAppliance : IfcFlowTerminal, ObjectHelper<IfcElectricAppliance,1> { IfcElectricAppliance() : Object("IfcElectricAppliance") {}
-		Maybe< IfcElectricApplianceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricApplianceType
-    struct IfcElectricApplianceType : IfcFlowTerminalType, ObjectHelper<IfcElectricApplianceType,1> { IfcElectricApplianceType() : Object("IfcElectricApplianceType") {}
-		IfcElectricApplianceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricDistributionBoard
-    struct IfcElectricDistributionBoard : IfcFlowController, ObjectHelper<IfcElectricDistributionBoard,1> { IfcElectricDistributionBoard() : Object("IfcElectricDistributionBoard") {}
-		Maybe< IfcElectricDistributionBoardTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricDistributionBoardType
-    struct IfcElectricDistributionBoardType : IfcFlowControllerType, ObjectHelper<IfcElectricDistributionBoardType,1> { IfcElectricDistributionBoardType() : Object("IfcElectricDistributionBoardType") {}
-		IfcElectricDistributionBoardTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowStorageDevice
-    struct IfcFlowStorageDevice : IfcDistributionFlowElement, ObjectHelper<IfcFlowStorageDevice,0> { IfcFlowStorageDevice() : Object("IfcFlowStorageDevice") {}
-
-    };
-
-    // C++ wrapper for IfcElectricFlowStorageDevice
-    struct IfcElectricFlowStorageDevice : IfcFlowStorageDevice, ObjectHelper<IfcElectricFlowStorageDevice,1> { IfcElectricFlowStorageDevice() : Object("IfcElectricFlowStorageDevice") {}
-		Maybe< IfcElectricFlowStorageDeviceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowStorageDeviceType
-    struct IfcFlowStorageDeviceType : IfcDistributionFlowElementType, ObjectHelper<IfcFlowStorageDeviceType,0> { IfcFlowStorageDeviceType() : Object("IfcFlowStorageDeviceType") {}
-
-    };
-
-    // C++ wrapper for IfcElectricFlowStorageDeviceType
-    struct IfcElectricFlowStorageDeviceType : IfcFlowStorageDeviceType, ObjectHelper<IfcElectricFlowStorageDeviceType,1> { IfcElectricFlowStorageDeviceType() : Object("IfcElectricFlowStorageDeviceType") {}
-		IfcElectricFlowStorageDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricGenerator
-    struct IfcElectricGenerator : IfcEnergyConversionDevice, ObjectHelper<IfcElectricGenerator,1> { IfcElectricGenerator() : Object("IfcElectricGenerator") {}
-		Maybe< IfcElectricGeneratorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricGeneratorType
-    struct IfcElectricGeneratorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricGeneratorType,1> { IfcElectricGeneratorType() : Object("IfcElectricGeneratorType") {}
-		IfcElectricGeneratorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricMotor
-    struct IfcElectricMotor : IfcEnergyConversionDevice, ObjectHelper<IfcElectricMotor,1> { IfcElectricMotor() : Object("IfcElectricMotor") {}
-		Maybe< IfcElectricMotorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricMotorType
-    struct IfcElectricMotorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcElectricMotorType,1> { IfcElectricMotorType() : Object("IfcElectricMotorType") {}
-		IfcElectricMotorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricTimeControl
-    struct IfcElectricTimeControl : IfcFlowController, ObjectHelper<IfcElectricTimeControl,1> { IfcElectricTimeControl() : Object("IfcElectricTimeControl") {}
-		Maybe< IfcElectricTimeControlTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElectricTimeControlType
-    struct IfcElectricTimeControlType : IfcFlowControllerType, ObjectHelper<IfcElectricTimeControlType,1> { IfcElectricTimeControlType() : Object("IfcElectricTimeControlType") {}
-		IfcElectricTimeControlTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcElementAssembly
-    struct IfcElementAssembly : IfcElement, ObjectHelper<IfcElementAssembly,2> { IfcElementAssembly() : Object("IfcElementAssembly") {}
-		Maybe< IfcAssemblyPlaceEnum::Out > AssemblyPlace;
-		Maybe< IfcElementAssemblyTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcElementAssemblyType
-    struct IfcElementAssemblyType : IfcElementType, ObjectHelper<IfcElementAssemblyType,1> { IfcElementAssemblyType() : Object("IfcElementAssemblyType") {}
-		IfcElementAssemblyTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcQuantitySet
-    struct IfcQuantitySet : IfcPropertySetDefinition, ObjectHelper<IfcQuantitySet,0> { IfcQuantitySet() : Object("IfcQuantitySet") {}
-
-    };
-
-    // C++ wrapper for IfcElementQuantity
-    struct IfcElementQuantity : IfcQuantitySet, ObjectHelper<IfcElementQuantity,2> { IfcElementQuantity() : Object("IfcElementQuantity") {}
-		Maybe< IfcLabel::Out > MethodOfMeasurement;
-		ListOf< Lazy< NotImplemented >, 1, 0 > Quantities;
-    };
-
-    // C++ wrapper for IfcEllipse
-    struct IfcEllipse : IfcConic, ObjectHelper<IfcEllipse,2> { IfcEllipse() : Object("IfcEllipse") {}
-		IfcPositiveLengthMeasure::Out SemiAxis1;
-		IfcPositiveLengthMeasure::Out SemiAxis2;
-    };
-
-    // C++ wrapper for IfcEllipseProfileDef
-    struct IfcEllipseProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcEllipseProfileDef,2> { IfcEllipseProfileDef() : Object("IfcEllipseProfileDef") {}
-		IfcPositiveLengthMeasure::Out SemiAxis1;
-		IfcPositiveLengthMeasure::Out SemiAxis2;
-    };
-
-    // C++ wrapper for IfcEngine
-    struct IfcEngine : IfcEnergyConversionDevice, ObjectHelper<IfcEngine,1> { IfcEngine() : Object("IfcEngine") {}
-		Maybe< IfcEngineTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcEngineType
-    struct IfcEngineType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEngineType,1> { IfcEngineType() : Object("IfcEngineType") {}
-		IfcEngineTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEvaporativeCooler
-    struct IfcEvaporativeCooler : IfcEnergyConversionDevice, ObjectHelper<IfcEvaporativeCooler,1> { IfcEvaporativeCooler() : Object("IfcEvaporativeCooler") {}
-		Maybe< IfcEvaporativeCoolerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcEvaporativeCoolerType
-    struct IfcEvaporativeCoolerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporativeCoolerType,1> { IfcEvaporativeCoolerType() : Object("IfcEvaporativeCoolerType") {}
-		IfcEvaporativeCoolerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcEvaporator
-    struct IfcEvaporator : IfcEnergyConversionDevice, ObjectHelper<IfcEvaporator,1> { IfcEvaporator() : Object("IfcEvaporator") {}
-		Maybe< IfcEvaporatorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcEvaporatorType
-    struct IfcEvaporatorType : IfcEnergyConversionDeviceType, ObjectHelper<IfcEvaporatorType,1> { IfcEvaporatorType() : Object("IfcEvaporatorType") {}
-		IfcEvaporatorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProcess
-    struct IfcProcess : IfcObject, ObjectHelper<IfcProcess,2> { IfcProcess() : Object("IfcProcess") {}
-		Maybe< IfcIdentifier::Out > Identification;
-		Maybe< IfcText::Out > LongDescription;
-    };
-
-    // C++ wrapper for IfcEvent
-    struct IfcEvent : IfcProcess, ObjectHelper<IfcEvent,4> { IfcEvent() : Object("IfcEvent") {}
-		Maybe< IfcEventTypeEnum::Out > PredefinedType;
-		Maybe< IfcEventTriggerTypeEnum::Out > EventTriggerType;
-		Maybe< IfcLabel::Out > UserDefinedEventTriggerType;
-		Maybe< Lazy< NotImplemented > > EventOccurenceTime;
-    };
-
-    // C++ wrapper for IfcTypeProcess
-    struct IfcTypeProcess : IfcTypeObject, ObjectHelper<IfcTypeProcess,3> { IfcTypeProcess() : Object("IfcTypeProcess") {}
-		Maybe< IfcIdentifier::Out > Identification;
-		Maybe< IfcText::Out > LongDescription;
-		Maybe< IfcLabel::Out > ProcessType;
-    };
-
-    // C++ wrapper for IfcEventType
-    struct IfcEventType : IfcTypeProcess, ObjectHelper<IfcEventType,3> { IfcEventType() : Object("IfcEventType") {}
-		IfcEventTypeEnum::Out PredefinedType;
-		IfcEventTriggerTypeEnum::Out EventTriggerType;
-		Maybe< IfcLabel::Out > UserDefinedEventTriggerType;
-    };
-
-    // C++ wrapper for IfcExternalSpatialStructureElement
-    struct IfcExternalSpatialStructureElement : IfcSpatialElement, ObjectHelper<IfcExternalSpatialStructureElement,0> { IfcExternalSpatialStructureElement() : Object("IfcExternalSpatialStructureElement") {}
-
-    };
-
-    // C++ wrapper for IfcExternalSpatialElement
-    struct IfcExternalSpatialElement : IfcExternalSpatialStructureElement, ObjectHelper<IfcExternalSpatialElement,1> { IfcExternalSpatialElement() : Object("IfcExternalSpatialElement") {}
-		Maybe< IfcExternalSpatialElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSweptAreaSolid
-    struct IfcSweptAreaSolid : IfcSolidModel, ObjectHelper<IfcSweptAreaSolid,2> { IfcSweptAreaSolid() : Object("IfcSweptAreaSolid") {}
-		Lazy< IfcProfileDef > SweptArea;
-		Maybe< Lazy< IfcAxis2Placement3D > > Position;
-    };
-
-    // C++ wrapper for IfcExtrudedAreaSolid
-    struct IfcExtrudedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcExtrudedAreaSolid,2> { IfcExtrudedAreaSolid() : Object("IfcExtrudedAreaSolid") {}
-		Lazy< IfcDirection > ExtrudedDirection;
-		IfcPositiveLengthMeasure::Out Depth;
-    };
-
-    // C++ wrapper for IfcExtrudedAreaSolidTapered
-    struct IfcExtrudedAreaSolidTapered : IfcExtrudedAreaSolid, ObjectHelper<IfcExtrudedAreaSolidTapered,1> { IfcExtrudedAreaSolidTapered() : Object("IfcExtrudedAreaSolidTapered") {}
-		Lazy< IfcProfileDef > EndSweptArea;
-    };
-
-    // C++ wrapper for IfcFaceBasedSurfaceModel
-    struct IfcFaceBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcFaceBasedSurfaceModel,1> { IfcFaceBasedSurfaceModel() : Object("IfcFaceBasedSurfaceModel") {}
-		ListOf< Lazy< IfcConnectedFaceSet >, 1, 0 > FbsmFaces;
-    };
-
-    // C++ wrapper for IfcFaceBound
-    struct IfcFaceBound : IfcTopologicalRepresentationItem, ObjectHelper<IfcFaceBound,2> { IfcFaceBound() : Object("IfcFaceBound") {}
-		Lazy< IfcLoop > Bound;
-		IfcBoolean::Out Orientation;
-    };
-
-    // C++ wrapper for IfcFaceOuterBound
-    struct IfcFaceOuterBound : IfcFaceBound, ObjectHelper<IfcFaceOuterBound,0> { IfcFaceOuterBound() : Object("IfcFaceOuterBound") {}
-
-    };
-
-    // C++ wrapper for IfcFacetedBrep
-    struct IfcFacetedBrep : IfcManifoldSolidBrep, ObjectHelper<IfcFacetedBrep,0> { IfcFacetedBrep() : Object("IfcFacetedBrep") {}
-
-    };
-
-    // C++ wrapper for IfcFacetedBrepWithVoids
-    struct IfcFacetedBrepWithVoids : IfcFacetedBrep, ObjectHelper<IfcFacetedBrepWithVoids,1> { IfcFacetedBrepWithVoids() : Object("IfcFacetedBrepWithVoids") {}
-		ListOf< Lazy< IfcClosedShell >, 1, 0 > Voids;
-    };
-
-    // C++ wrapper for IfcFan
-    struct IfcFan : IfcFlowMovingDevice, ObjectHelper<IfcFan,1> { IfcFan() : Object("IfcFan") {}
-		Maybe< IfcFanTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFanType
-    struct IfcFanType : IfcFlowMovingDeviceType, ObjectHelper<IfcFanType,1> { IfcFanType() : Object("IfcFanType") {}
-		IfcFanTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFastener
-    struct IfcFastener : IfcElementComponent, ObjectHelper<IfcFastener,1> { IfcFastener() : Object("IfcFastener") {}
-		Maybe< IfcFastenerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFastenerType
-    struct IfcFastenerType : IfcElementComponentType, ObjectHelper<IfcFastenerType,1> { IfcFastenerType() : Object("IfcFastenerType") {}
-		IfcFastenerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFeatureElement
-    struct IfcFeatureElement : IfcElement, ObjectHelper<IfcFeatureElement,0> { IfcFeatureElement() : Object("IfcFeatureElement") {}
-
-    };
-
-    // C++ wrapper for IfcFeatureElementAddition
-    struct IfcFeatureElementAddition : IfcFeatureElement, ObjectHelper<IfcFeatureElementAddition,0> { IfcFeatureElementAddition() : Object("IfcFeatureElementAddition") {}
-
-    };
-
-    // C++ wrapper for IfcFeatureElementSubtraction
-    struct IfcFeatureElementSubtraction : IfcFeatureElement, ObjectHelper<IfcFeatureElementSubtraction,0> { IfcFeatureElementSubtraction() : Object("IfcFeatureElementSubtraction") {}
-
-    };
-
-    // C++ wrapper for IfcFillAreaStyleHatching
-    struct IfcFillAreaStyleHatching : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleHatching,5> { IfcFillAreaStyleHatching() : Object("IfcFillAreaStyleHatching") {}
-		Lazy< NotImplemented > HatchLineAppearance;
-		IfcHatchLineDistanceSelect::Out StartOfNextHatchLine;
-		Maybe< Lazy< IfcCartesianPoint > > PointOfReferenceHatchLine;
-		Maybe< Lazy< IfcCartesianPoint > > PatternStart;
-		IfcPlaneAngleMeasure::Out HatchLineAngle;
-    };
-
-    // C++ wrapper for IfcFillAreaStyleTiles
-    struct IfcFillAreaStyleTiles : IfcGeometricRepresentationItem, ObjectHelper<IfcFillAreaStyleTiles,3> { IfcFillAreaStyleTiles() : Object("IfcFillAreaStyleTiles") {}
-		ListOf< Lazy< IfcVector >, 2, 2 > TilingPattern;
-		ListOf< Lazy< IfcStyledItem >, 1, 0 > Tiles;
-		IfcPositiveRatioMeasure::Out TilingScale;
-    };
-
-    // C++ wrapper for IfcFilter
-    struct IfcFilter : IfcFlowTreatmentDevice, ObjectHelper<IfcFilter,1> { IfcFilter() : Object("IfcFilter") {}
-		Maybe< IfcFilterTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFilterType
-    struct IfcFilterType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcFilterType,1> { IfcFilterType() : Object("IfcFilterType") {}
-		IfcFilterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFireSuppressionTerminal
-    struct IfcFireSuppressionTerminal : IfcFlowTerminal, ObjectHelper<IfcFireSuppressionTerminal,1> { IfcFireSuppressionTerminal() : Object("IfcFireSuppressionTerminal") {}
-		Maybe< IfcFireSuppressionTerminalTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFireSuppressionTerminalType
-    struct IfcFireSuppressionTerminalType : IfcFlowTerminalType, ObjectHelper<IfcFireSuppressionTerminalType,1> { IfcFireSuppressionTerminalType() : Object("IfcFireSuppressionTerminalType") {}
-		IfcFireSuppressionTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFixedReferenceSweptAreaSolid
-    struct IfcFixedReferenceSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcFixedReferenceSweptAreaSolid,4> { IfcFixedReferenceSweptAreaSolid() : Object("IfcFixedReferenceSweptAreaSolid") {}
-		Lazy< IfcCurve > Directrix;
-		Maybe< IfcParameterValue::Out > StartParam;
-		Maybe< IfcParameterValue::Out > EndParam;
-		Lazy< IfcDirection > FixedReference;
-    };
-
-    // C++ wrapper for IfcFlowInstrument
-    struct IfcFlowInstrument : IfcDistributionControlElement, ObjectHelper<IfcFlowInstrument,1> { IfcFlowInstrument() : Object("IfcFlowInstrument") {}
-		Maybe< IfcFlowInstrumentTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowInstrumentType
-    struct IfcFlowInstrumentType : IfcDistributionControlElementType, ObjectHelper<IfcFlowInstrumentType,1> { IfcFlowInstrumentType() : Object("IfcFlowInstrumentType") {}
-		IfcFlowInstrumentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowMeter
-    struct IfcFlowMeter : IfcFlowController, ObjectHelper<IfcFlowMeter,1> { IfcFlowMeter() : Object("IfcFlowMeter") {}
-		Maybe< IfcFlowMeterTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFlowMeterType
-    struct IfcFlowMeterType : IfcFlowControllerType, ObjectHelper<IfcFlowMeterType,1> { IfcFlowMeterType() : Object("IfcFlowMeterType") {}
-		IfcFlowMeterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFooting
-    struct IfcFooting : IfcBuildingElement, ObjectHelper<IfcFooting,1> { IfcFooting() : Object("IfcFooting") {}
-		Maybe< IfcFootingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFootingType
-    struct IfcFootingType : IfcBuildingElementType, ObjectHelper<IfcFootingType,1> { IfcFootingType() : Object("IfcFootingType") {}
-		IfcFootingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcFurnishingElement
-    struct IfcFurnishingElement : IfcElement, ObjectHelper<IfcFurnishingElement,0> { IfcFurnishingElement() : Object("IfcFurnishingElement") {}
-
-    };
-
-    // C++ wrapper for IfcFurnishingElementType
-    struct IfcFurnishingElementType : IfcElementType, ObjectHelper<IfcFurnishingElementType,0> { IfcFurnishingElementType() : Object("IfcFurnishingElementType") {}
-
-    };
-
-    // C++ wrapper for IfcFurniture
-    struct IfcFurniture : IfcFurnishingElement, ObjectHelper<IfcFurniture,1> { IfcFurniture() : Object("IfcFurniture") {}
-		Maybe< IfcFurnitureTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcFurnitureType
-    struct IfcFurnitureType : IfcFurnishingElementType, ObjectHelper<IfcFurnitureType,2> { IfcFurnitureType() : Object("IfcFurnitureType") {}
-		IfcAssemblyPlaceEnum::Out AssemblyPlace;
-		Maybe< IfcFurnitureTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcGeographicElement
-    struct IfcGeographicElement : IfcElement, ObjectHelper<IfcGeographicElement,1> { IfcGeographicElement() : Object("IfcGeographicElement") {}
-		Maybe< IfcGeographicElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcGeographicElementType
-    struct IfcGeographicElementType : IfcElementType, ObjectHelper<IfcGeographicElementType,1> { IfcGeographicElementType() : Object("IfcGeographicElementType") {}
-		IfcGeographicElementTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcGeometricSet
-    struct IfcGeometricSet : IfcGeometricRepresentationItem, ObjectHelper<IfcGeometricSet,1> { IfcGeometricSet() : Object("IfcGeometricSet") {}
-		ListOf< IfcGeometricSetSelect, 1, 0 >::Out Elements;
-    };
-
-    // C++ wrapper for IfcGeometricCurveSet
-    struct IfcGeometricCurveSet : IfcGeometricSet, ObjectHelper<IfcGeometricCurveSet,0> { IfcGeometricCurveSet() : Object("IfcGeometricCurveSet") {}
-
-    };
-
-    // C++ wrapper for IfcRepresentationContext
-    struct IfcRepresentationContext :  ObjectHelper<IfcRepresentationContext,2> { IfcRepresentationContext() : Object("IfcRepresentationContext") {}
-		Maybe< IfcLabel::Out > ContextIdentifier;
-		Maybe< IfcLabel::Out > ContextType;
-    };
-
-    // C++ wrapper for IfcGeometricRepresentationContext
-    struct IfcGeometricRepresentationContext : IfcRepresentationContext, ObjectHelper<IfcGeometricRepresentationContext,4> { IfcGeometricRepresentationContext() : Object("IfcGeometricRepresentationContext") {}
-		IfcDimensionCount::Out CoordinateSpaceDimension;
-		Maybe< IfcReal::Out > Precision;
-		IfcAxis2Placement::Out WorldCoordinateSystem;
-		Maybe< Lazy< IfcDirection > > TrueNorth;
-    };
-
-    // C++ wrapper for IfcGeometricRepresentationSubContext
-    struct IfcGeometricRepresentationSubContext : IfcGeometricRepresentationContext, ObjectHelper<IfcGeometricRepresentationSubContext,4> { IfcGeometricRepresentationSubContext() : Object("IfcGeometricRepresentationSubContext") {}
-		Lazy< IfcGeometricRepresentationContext > ParentContext;
-		Maybe< IfcPositiveRatioMeasure::Out > TargetScale;
-		IfcGeometricProjectionEnum::Out TargetView;
-		Maybe< IfcLabel::Out > UserDefinedTargetView;
-    };
-
-    // C++ wrapper for IfcGrid
-    struct IfcGrid : IfcProduct, ObjectHelper<IfcGrid,4> { IfcGrid() : Object("IfcGrid") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > UAxes;
-		ListOf< Lazy< NotImplemented >, 1, 0 > VAxes;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WAxes;
-		Maybe< IfcGridTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcObjectPlacement
-    struct IfcObjectPlacement :  ObjectHelper<IfcObjectPlacement,0> { IfcObjectPlacement() : Object("IfcObjectPlacement") {}
-
-    };
-
-    // C++ wrapper for IfcGridPlacement
-    struct IfcGridPlacement : IfcObjectPlacement, ObjectHelper<IfcGridPlacement,2> { IfcGridPlacement() : Object("IfcGridPlacement") {}
-		Lazy< NotImplemented > PlacementLocation;
-		Maybe< IfcGridPlacementDirectionSelect::Out > PlacementRefDirection;
-    };
-
-    // C++ wrapper for IfcHeatExchanger
-    struct IfcHeatExchanger : IfcEnergyConversionDevice, ObjectHelper<IfcHeatExchanger,1> { IfcHeatExchanger() : Object("IfcHeatExchanger") {}
-		Maybe< IfcHeatExchangerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcHeatExchangerType
-    struct IfcHeatExchangerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHeatExchangerType,1> { IfcHeatExchangerType() : Object("IfcHeatExchangerType") {}
-		IfcHeatExchangerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcHumidifier
-    struct IfcHumidifier : IfcEnergyConversionDevice, ObjectHelper<IfcHumidifier,1> { IfcHumidifier() : Object("IfcHumidifier") {}
-		Maybe< IfcHumidifierTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcHumidifierType
-    struct IfcHumidifierType : IfcEnergyConversionDeviceType, ObjectHelper<IfcHumidifierType,1> { IfcHumidifierType() : Object("IfcHumidifierType") {}
-		IfcHumidifierTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcIShapeProfileDef
-    struct IfcIShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcIShapeProfileDef,7> { IfcIShapeProfileDef() : Object("IfcIShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out OverallWidth;
-		IfcPositiveLengthMeasure::Out OverallDepth;
-		IfcPositiveLengthMeasure::Out WebThickness;
-		IfcPositiveLengthMeasure::Out FlangeThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FlangeEdgeRadius;
-		Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
-    };
-
-    // C++ wrapper for IfcIndexedPolyCurve
-    struct IfcIndexedPolyCurve : IfcBoundedCurve, ObjectHelper<IfcIndexedPolyCurve,3> { IfcIndexedPolyCurve() : Object("IfcIndexedPolyCurve") {}
-		Lazy< IfcCartesianPointList > Points;
-		Maybe< ListOf< IfcSegmentIndexSelect, 1, 0 >::Out > Segments;
-		Maybe< IfcBoolean::Out > SelfIntersect;
-    };
-
-    // C++ wrapper for IfcTessellatedItem
-    struct IfcTessellatedItem : IfcGeometricRepresentationItem, ObjectHelper<IfcTessellatedItem,0> { IfcTessellatedItem() : Object("IfcTessellatedItem") {}
-
-    };
-
-    // C++ wrapper for IfcIndexedPolygonalFace
-    struct IfcIndexedPolygonalFace : IfcTessellatedItem, ObjectHelper<IfcIndexedPolygonalFace,1> { IfcIndexedPolygonalFace() : Object("IfcIndexedPolygonalFace") {}
-		ListOf< IfcPositiveInteger, 3, 0 >::Out CoordIndex;
-    };
-
-    // C++ wrapper for IfcIndexedPolygonalFaceWithVoids
-    struct IfcIndexedPolygonalFaceWithVoids : IfcIndexedPolygonalFace, ObjectHelper<IfcIndexedPolygonalFaceWithVoids,0> { IfcIndexedPolygonalFaceWithVoids() : Object("IfcIndexedPolygonalFaceWithVoids") {}
-
-    };
-
-    // C++ wrapper for IfcInterceptor
-    struct IfcInterceptor : IfcFlowTreatmentDevice, ObjectHelper<IfcInterceptor,1> { IfcInterceptor() : Object("IfcInterceptor") {}
-		Maybe< IfcInterceptorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcInterceptorType
-    struct IfcInterceptorType : IfcFlowTreatmentDeviceType, ObjectHelper<IfcInterceptorType,1> { IfcInterceptorType() : Object("IfcInterceptorType") {}
-		IfcInterceptorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSurfaceCurve
-    struct IfcSurfaceCurve : IfcCurve, ObjectHelper<IfcSurfaceCurve,3> { IfcSurfaceCurve() : Object("IfcSurfaceCurve") {}
-		Lazy< IfcCurve > Curve3D;
-		ListOf< Lazy< IfcPcurve >, 1, 2 > AssociatedGeometry;
-		IfcPreferredSurfaceCurveRepresentation::Out MasterRepresentation;
-    };
-
-    // C++ wrapper for IfcIntersectionCurve
-    struct IfcIntersectionCurve : IfcSurfaceCurve, ObjectHelper<IfcIntersectionCurve,0> { IfcIntersectionCurve() : Object("IfcIntersectionCurve") {}
-
-    };
-
-    // C++ wrapper for IfcInventory
-    struct IfcInventory : IfcGroup, ObjectHelper<IfcInventory,6> { IfcInventory() : Object("IfcInventory") {}
-		Maybe< IfcInventoryTypeEnum::Out > PredefinedType;
-		Maybe< IfcActorSelect::Out > Jurisdiction;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > ResponsiblePersons;
-		Maybe< IfcDate::Out > LastUpdateDate;
-		Maybe< Lazy< NotImplemented > > CurrentValue;
-		Maybe< Lazy< NotImplemented > > OriginalValue;
-    };
-
-    // C++ wrapper for IfcJunctionBox
-    struct IfcJunctionBox : IfcFlowFitting, ObjectHelper<IfcJunctionBox,1> { IfcJunctionBox() : Object("IfcJunctionBox") {}
-		Maybe< IfcJunctionBoxTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcJunctionBoxType
-    struct IfcJunctionBoxType : IfcFlowFittingType, ObjectHelper<IfcJunctionBoxType,1> { IfcJunctionBoxType() : Object("IfcJunctionBoxType") {}
-		IfcJunctionBoxTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLShapeProfileDef
-    struct IfcLShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcLShapeProfileDef,6> { IfcLShapeProfileDef() : Object("IfcLShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out Depth;
-		Maybe< IfcPositiveLengthMeasure::Out > Width;
-		IfcPositiveLengthMeasure::Out Thickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
-		Maybe< IfcPlaneAngleMeasure::Out > LegSlope;
-    };
-
-    // C++ wrapper for IfcLaborResource
-    struct IfcLaborResource : IfcConstructionResource, ObjectHelper<IfcLaborResource,1> { IfcLaborResource() : Object("IfcLaborResource") {}
-		Maybe< IfcLaborResourceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcLaborResourceType
-    struct IfcLaborResourceType : IfcConstructionResourceType, ObjectHelper<IfcLaborResourceType,1> { IfcLaborResourceType() : Object("IfcLaborResourceType") {}
-		IfcLaborResourceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLamp
-    struct IfcLamp : IfcFlowTerminal, ObjectHelper<IfcLamp,1> { IfcLamp() : Object("IfcLamp") {}
-		Maybe< IfcLampTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcLampType
-    struct IfcLampType : IfcFlowTerminalType, ObjectHelper<IfcLampType,1> { IfcLampType() : Object("IfcLampType") {}
-		IfcLampTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLightFixture
-    struct IfcLightFixture : IfcFlowTerminal, ObjectHelper<IfcLightFixture,1> { IfcLightFixture() : Object("IfcLightFixture") {}
-		Maybe< IfcLightFixtureTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcLightFixtureType
-    struct IfcLightFixtureType : IfcFlowTerminalType, ObjectHelper<IfcLightFixtureType,1> { IfcLightFixtureType() : Object("IfcLightFixtureType") {}
-		IfcLightFixtureTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcLightSource
-    struct IfcLightSource : IfcGeometricRepresentationItem, ObjectHelper<IfcLightSource,4> { IfcLightSource() : Object("IfcLightSource") {}
-		Maybe< IfcLabel::Out > Name;
-		Lazy< IfcColourRgb > LightColour;
-		Maybe< IfcNormalisedRatioMeasure::Out > AmbientIntensity;
-		Maybe< IfcNormalisedRatioMeasure::Out > Intensity;
-    };
-
-    // C++ wrapper for IfcLightSourceAmbient
-    struct IfcLightSourceAmbient : IfcLightSource, ObjectHelper<IfcLightSourceAmbient,0> { IfcLightSourceAmbient() : Object("IfcLightSourceAmbient") {}
-
-    };
-
-    // C++ wrapper for IfcLightSourceDirectional
-    struct IfcLightSourceDirectional : IfcLightSource, ObjectHelper<IfcLightSourceDirectional,1> { IfcLightSourceDirectional() : Object("IfcLightSourceDirectional") {}
-		Lazy< IfcDirection > Orientation;
-    };
-
-    // C++ wrapper for IfcLightSourceGoniometric
-    struct IfcLightSourceGoniometric : IfcLightSource, ObjectHelper<IfcLightSourceGoniometric,6> { IfcLightSourceGoniometric() : Object("IfcLightSourceGoniometric") {}
-		Lazy< IfcAxis2Placement3D > Position;
-		Maybe< Lazy< IfcColourRgb > > ColourAppearance;
-		IfcThermodynamicTemperatureMeasure::Out ColourTemperature;
-		IfcLuminousFluxMeasure::Out LuminousFlux;
-		IfcLightEmissionSourceEnum::Out LightEmissionSource;
-		IfcLightDistributionDataSourceSelect::Out LightDistributionDataSource;
-    };
-
-    // C++ wrapper for IfcLightSourcePositional
-    struct IfcLightSourcePositional : IfcLightSource, ObjectHelper<IfcLightSourcePositional,5> { IfcLightSourcePositional() : Object("IfcLightSourcePositional") {}
-		Lazy< IfcCartesianPoint > Position;
-		IfcPositiveLengthMeasure::Out Radius;
-		IfcReal::Out ConstantAttenuation;
-		IfcReal::Out DistanceAttenuation;
-		IfcReal::Out QuadricAttenuation;
-    };
-
-    // C++ wrapper for IfcLightSourceSpot
-    struct IfcLightSourceSpot : IfcLightSourcePositional, ObjectHelper<IfcLightSourceSpot,4> { IfcLightSourceSpot() : Object("IfcLightSourceSpot") {}
-		Lazy< IfcDirection > Orientation;
-		Maybe< IfcReal::Out > ConcentrationExponent;
-		IfcPositivePlaneAngleMeasure::Out SpreadAngle;
-		IfcPositivePlaneAngleMeasure::Out BeamWidthAngle;
-    };
-
-    // C++ wrapper for IfcLine
-    struct IfcLine : IfcCurve, ObjectHelper<IfcLine,2> { IfcLine() : Object("IfcLine") {}
-		Lazy< IfcCartesianPoint > Pnt;
-		Lazy< IfcVector > Dir;
-    };
-
-    // C++ wrapper for IfcLocalPlacement
-    struct IfcLocalPlacement : IfcObjectPlacement, ObjectHelper<IfcLocalPlacement,2> { IfcLocalPlacement() : Object("IfcLocalPlacement") {}
-		Maybe< Lazy< IfcObjectPlacement > > PlacementRelTo;
-		IfcAxis2Placement::Out RelativePlacement;
-    };
-
-    // C++ wrapper for IfcMappedItem
-    struct IfcMappedItem : IfcRepresentationItem, ObjectHelper<IfcMappedItem,2> { IfcMappedItem() : Object("IfcMappedItem") {}
-		Lazy< IfcRepresentationMap > MappingSource;
-		Lazy< IfcCartesianTransformationOperator > MappingTarget;
-    };
-
-    // C++ wrapper for IfcProductRepresentation
-    struct IfcProductRepresentation :  ObjectHelper<IfcProductRepresentation,3> { IfcProductRepresentation() : Object("IfcProductRepresentation") {}
-		Maybe< IfcLabel::Out > Name;
-		Maybe< IfcText::Out > Description;
-		ListOf< Lazy< IfcRepresentation >, 1, 0 > Representations;
-    };
-
-    // C++ wrapper for IfcMaterialDefinitionRepresentation
-    struct IfcMaterialDefinitionRepresentation : IfcProductRepresentation, ObjectHelper<IfcMaterialDefinitionRepresentation,1> { IfcMaterialDefinitionRepresentation() : Object("IfcMaterialDefinitionRepresentation") {}
-		Lazy< NotImplemented > RepresentedMaterial;
-    };
-
-    // C++ wrapper for IfcMeasureWithUnit
-    struct IfcMeasureWithUnit :  ObjectHelper<IfcMeasureWithUnit,2> { IfcMeasureWithUnit() : Object("IfcMeasureWithUnit") {}
-		IfcValue::Out ValueComponent;
-		IfcUnit::Out UnitComponent;
-    };
-
-    // C++ wrapper for IfcMechanicalFastener
-    struct IfcMechanicalFastener : IfcElementComponent, ObjectHelper<IfcMechanicalFastener,3> { IfcMechanicalFastener() : Object("IfcMechanicalFastener") {}
-		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-		Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
-		Maybe< IfcMechanicalFastenerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcMechanicalFastenerType
-    struct IfcMechanicalFastenerType : IfcElementComponentType, ObjectHelper<IfcMechanicalFastenerType,3> { IfcMechanicalFastenerType() : Object("IfcMechanicalFastenerType") {}
-		IfcMechanicalFastenerTypeEnum::Out PredefinedType;
-		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-		Maybe< IfcPositiveLengthMeasure::Out > NominalLength;
-    };
-
-    // C++ wrapper for IfcMedicalDevice
-    struct IfcMedicalDevice : IfcFlowTerminal, ObjectHelper<IfcMedicalDevice,1> { IfcMedicalDevice() : Object("IfcMedicalDevice") {}
-		Maybe< IfcMedicalDeviceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcMedicalDeviceType
-    struct IfcMedicalDeviceType : IfcFlowTerminalType, ObjectHelper<IfcMedicalDeviceType,1> { IfcMedicalDeviceType() : Object("IfcMedicalDeviceType") {}
-		IfcMedicalDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcMember
-    struct IfcMember : IfcBuildingElement, ObjectHelper<IfcMember,1> { IfcMember() : Object("IfcMember") {}
-		Maybe< IfcMemberTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcMemberStandardCase
-    struct IfcMemberStandardCase : IfcMember, ObjectHelper<IfcMemberStandardCase,0> { IfcMemberStandardCase() : Object("IfcMemberStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcMemberType
-    struct IfcMemberType : IfcBuildingElementType, ObjectHelper<IfcMemberType,1> { IfcMemberType() : Object("IfcMemberType") {}
-		IfcMemberTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcMirroredProfileDef
-    struct IfcMirroredProfileDef : IfcDerivedProfileDef, ObjectHelper<IfcMirroredProfileDef,0> { IfcMirroredProfileDef() : Object("IfcMirroredProfileDef") {}
-
-    };
-
-    // C++ wrapper for IfcMotorConnection
-    struct IfcMotorConnection : IfcEnergyConversionDevice, ObjectHelper<IfcMotorConnection,1> { IfcMotorConnection() : Object("IfcMotorConnection") {}
-		Maybe< IfcMotorConnectionTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcMotorConnectionType
-    struct IfcMotorConnectionType : IfcEnergyConversionDeviceType, ObjectHelper<IfcMotorConnectionType,1> { IfcMotorConnectionType() : Object("IfcMotorConnectionType") {}
-		IfcMotorConnectionTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcOccupant
-    struct IfcOccupant : IfcActor, ObjectHelper<IfcOccupant,1> { IfcOccupant() : Object("IfcOccupant") {}
-		Maybe< IfcOccupantTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcOffsetCurve2D
-    struct IfcOffsetCurve2D : IfcCurve, ObjectHelper<IfcOffsetCurve2D,3> { IfcOffsetCurve2D() : Object("IfcOffsetCurve2D") {}
-		Lazy< IfcCurve > BasisCurve;
-		IfcLengthMeasure::Out Distance;
-		IfcLogical::Out SelfIntersect;
-    };
-
-    // C++ wrapper for IfcOffsetCurve3D
-    struct IfcOffsetCurve3D : IfcCurve, ObjectHelper<IfcOffsetCurve3D,4> { IfcOffsetCurve3D() : Object("IfcOffsetCurve3D") {}
-		Lazy< IfcCurve > BasisCurve;
-		IfcLengthMeasure::Out Distance;
-		IfcLogical::Out SelfIntersect;
-		Lazy< IfcDirection > RefDirection;
-    };
-
-    // C++ wrapper for IfcOpenShell
-    struct IfcOpenShell : IfcConnectedFaceSet, ObjectHelper<IfcOpenShell,0> { IfcOpenShell() : Object("IfcOpenShell") {}
-
-    };
-
-    // C++ wrapper for IfcOpeningElement
-    struct IfcOpeningElement : IfcFeatureElementSubtraction, ObjectHelper<IfcOpeningElement,1> { IfcOpeningElement() : Object("IfcOpeningElement") {}
-		Maybe< IfcOpeningElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcOpeningStandardCase
-    struct IfcOpeningStandardCase : IfcOpeningElement, ObjectHelper<IfcOpeningStandardCase,0> { IfcOpeningStandardCase() : Object("IfcOpeningStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcOrientedEdge
-    struct IfcOrientedEdge : IfcEdge, ObjectHelper<IfcOrientedEdge,2> { IfcOrientedEdge() : Object("IfcOrientedEdge") {}
-		Lazy< IfcEdge > EdgeElement;
-		IfcBoolean::Out Orientation;
-    };
-
-    // C++ wrapper for IfcOuterBoundaryCurve
-    struct IfcOuterBoundaryCurve : IfcBoundaryCurve, ObjectHelper<IfcOuterBoundaryCurve,0> { IfcOuterBoundaryCurve() : Object("IfcOuterBoundaryCurve") {}
-
-    };
-
-    // C++ wrapper for IfcOutlet
-    struct IfcOutlet : IfcFlowTerminal, ObjectHelper<IfcOutlet,1> { IfcOutlet() : Object("IfcOutlet") {}
-		Maybe< IfcOutletTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcOutletType
-    struct IfcOutletType : IfcFlowTerminalType, ObjectHelper<IfcOutletType,1> { IfcOutletType() : Object("IfcOutletType") {}
-		IfcOutletTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPath
-    struct IfcPath : IfcTopologicalRepresentationItem, ObjectHelper<IfcPath,1> { IfcPath() : Object("IfcPath") {}
-		ListOf< Lazy< IfcOrientedEdge >, 1, 0 > EdgeList;
-    };
-
-    // C++ wrapper for IfcPcurve
-    struct IfcPcurve : IfcCurve, ObjectHelper<IfcPcurve,2> { IfcPcurve() : Object("IfcPcurve") {}
-		Lazy< IfcSurface > BasisSurface;
-		Lazy< IfcCurve > ReferenceCurve;
-    };
-
-    // C++ wrapper for IfcPerformanceHistory
-    struct IfcPerformanceHistory : IfcControl, ObjectHelper<IfcPerformanceHistory,2> { IfcPerformanceHistory() : Object("IfcPerformanceHistory") {}
-		IfcLabel::Out LifeCyclePhase;
-		Maybe< IfcPerformanceHistoryTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcPermit
-    struct IfcPermit : IfcControl, ObjectHelper<IfcPermit,3> { IfcPermit() : Object("IfcPermit") {}
-		Maybe< IfcPermitTypeEnum::Out > PredefinedType;
-		Maybe< IfcLabel::Out > Status;
-		Maybe< IfcText::Out > LongDescription;
-    };
-
-    // C++ wrapper for IfcPile
-    struct IfcPile : IfcBuildingElement, ObjectHelper<IfcPile,2> { IfcPile() : Object("IfcPile") {}
-		Maybe< IfcPileTypeEnum::Out > PredefinedType;
-		Maybe< IfcPileConstructionEnum::Out > ConstructionType;
-    };
-
-    // C++ wrapper for IfcPileType
-    struct IfcPileType : IfcBuildingElementType, ObjectHelper<IfcPileType,1> { IfcPileType() : Object("IfcPileType") {}
-		IfcPileTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPipeFitting
-    struct IfcPipeFitting : IfcFlowFitting, ObjectHelper<IfcPipeFitting,1> { IfcPipeFitting() : Object("IfcPipeFitting") {}
-		Maybe< IfcPipeFittingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcPipeFittingType
-    struct IfcPipeFittingType : IfcFlowFittingType, ObjectHelper<IfcPipeFittingType,1> { IfcPipeFittingType() : Object("IfcPipeFittingType") {}
-		IfcPipeFittingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPipeSegment
-    struct IfcPipeSegment : IfcFlowSegment, ObjectHelper<IfcPipeSegment,1> { IfcPipeSegment() : Object("IfcPipeSegment") {}
-		Maybe< IfcPipeSegmentTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcPipeSegmentType
-    struct IfcPipeSegmentType : IfcFlowSegmentType, ObjectHelper<IfcPipeSegmentType,1> { IfcPipeSegmentType() : Object("IfcPipeSegmentType") {}
-		IfcPipeSegmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPlanarExtent
-    struct IfcPlanarExtent : IfcGeometricRepresentationItem, ObjectHelper<IfcPlanarExtent,2> { IfcPlanarExtent() : Object("IfcPlanarExtent") {}
-		IfcLengthMeasure::Out SizeInX;
-		IfcLengthMeasure::Out SizeInY;
-    };
-
-    // C++ wrapper for IfcPlanarBox
-    struct IfcPlanarBox : IfcPlanarExtent, ObjectHelper<IfcPlanarBox,1> { IfcPlanarBox() : Object("IfcPlanarBox") {}
-		IfcAxis2Placement::Out Placement;
-    };
-
-    // C++ wrapper for IfcPlane
-    struct IfcPlane : IfcElementarySurface, ObjectHelper<IfcPlane,0> { IfcPlane() : Object("IfcPlane") {}
-
-    };
-
-    // C++ wrapper for IfcPlate
-    struct IfcPlate : IfcBuildingElement, ObjectHelper<IfcPlate,1> { IfcPlate() : Object("IfcPlate") {}
-		Maybe< IfcPlateTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcPlateStandardCase
-    struct IfcPlateStandardCase : IfcPlate, ObjectHelper<IfcPlateStandardCase,0> { IfcPlateStandardCase() : Object("IfcPlateStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcPlateType
-    struct IfcPlateType : IfcBuildingElementType, ObjectHelper<IfcPlateType,1> { IfcPlateType() : Object("IfcPlateType") {}
-		IfcPlateTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcPointOnCurve
-    struct IfcPointOnCurve : IfcPoint, ObjectHelper<IfcPointOnCurve,2> { IfcPointOnCurve() : Object("IfcPointOnCurve") {}
-		Lazy< IfcCurve > BasisCurve;
-		IfcParameterValue::Out PointParameter;
-    };
-
-    // C++ wrapper for IfcPointOnSurface
-    struct IfcPointOnSurface : IfcPoint, ObjectHelper<IfcPointOnSurface,3> { IfcPointOnSurface() : Object("IfcPointOnSurface") {}
-		Lazy< IfcSurface > BasisSurface;
-		IfcParameterValue::Out PointParameterU;
-		IfcParameterValue::Out PointParameterV;
-    };
-
-    // C++ wrapper for IfcPolyLoop
-    struct IfcPolyLoop : IfcLoop, ObjectHelper<IfcPolyLoop,1> { IfcPolyLoop() : Object("IfcPolyLoop") {}
-		ListOf< Lazy< IfcCartesianPoint >, 3, 0 > Polygon;
-    };
-
-    // C++ wrapper for IfcPolygonalBoundedHalfSpace
-    struct IfcPolygonalBoundedHalfSpace : IfcHalfSpaceSolid, ObjectHelper<IfcPolygonalBoundedHalfSpace,2> { IfcPolygonalBoundedHalfSpace() : Object("IfcPolygonalBoundedHalfSpace") {}
-		Lazy< IfcAxis2Placement3D > Position;
-		Lazy< IfcBoundedCurve > PolygonalBoundary;
-    };
-
-    // C++ wrapper for IfcTessellatedFaceSet
-    struct IfcTessellatedFaceSet : IfcTessellatedItem, ObjectHelper<IfcTessellatedFaceSet,1> { IfcTessellatedFaceSet() : Object("IfcTessellatedFaceSet") {}
-		Lazy< IfcCartesianPointList3D > Coordinates;
-    };
-
-    // C++ wrapper for IfcPolygonalFaceSet
-    struct IfcPolygonalFaceSet : IfcTessellatedFaceSet, ObjectHelper<IfcPolygonalFaceSet,3> { IfcPolygonalFaceSet() : Object("IfcPolygonalFaceSet") {}
-		Maybe< IfcBoolean::Out > Closed;
-		ListOf< Lazy< IfcIndexedPolygonalFace >, 1, 0 > Faces;
-		Maybe< ListOf< IfcPositiveInteger, 1, 0 >::Out > PnIndex;
-    };
-
-    // C++ wrapper for IfcPolyline
-    struct IfcPolyline : IfcBoundedCurve, ObjectHelper<IfcPolyline,1> { IfcPolyline() : Object("IfcPolyline") {}
-		ListOf< Lazy< IfcCartesianPoint >, 2, 0 > Points;
-    };
-
-    // C++ wrapper for IfcPresentationStyleAssignment
-    struct IfcPresentationStyleAssignment :  ObjectHelper<IfcPresentationStyleAssignment,1> { IfcPresentationStyleAssignment() : Object("IfcPresentationStyleAssignment") {}
-		ListOf< IfcPresentationStyleSelect, 1, 0 >::Out Styles;
-    };
-
-    // C++ wrapper for IfcProcedure
-    struct IfcProcedure : IfcProcess, ObjectHelper<IfcProcedure,1> { IfcProcedure() : Object("IfcProcedure") {}
-		Maybe< IfcProcedureTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcProcedureType
-    struct IfcProcedureType : IfcTypeProcess, ObjectHelper<IfcProcedureType,1> { IfcProcedureType() : Object("IfcProcedureType") {}
-		IfcProcedureTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProductDefinitionShape
-    struct IfcProductDefinitionShape : IfcProductRepresentation, ObjectHelper<IfcProductDefinitionShape,0> { IfcProductDefinitionShape() : Object("IfcProductDefinitionShape") {}
-
-    };
-
-    // C++ wrapper for IfcProject
-    struct IfcProject : IfcContext, ObjectHelper<IfcProject,0> { IfcProject() : Object("IfcProject") {}
-
-    };
-
-    // C++ wrapper for IfcProjectLibrary
-    struct IfcProjectLibrary : IfcContext, ObjectHelper<IfcProjectLibrary,0> { IfcProjectLibrary() : Object("IfcProjectLibrary") {}
-
-    };
-
-    // C++ wrapper for IfcProjectOrder
-    struct IfcProjectOrder : IfcControl, ObjectHelper<IfcProjectOrder,3> { IfcProjectOrder() : Object("IfcProjectOrder") {}
-		Maybe< IfcProjectOrderTypeEnum::Out > PredefinedType;
-		Maybe< IfcLabel::Out > Status;
-		Maybe< IfcText::Out > LongDescription;
-    };
-
-    // C++ wrapper for IfcProjectionElement
-    struct IfcProjectionElement : IfcFeatureElementAddition, ObjectHelper<IfcProjectionElement,1> { IfcProjectionElement() : Object("IfcProjectionElement") {}
-		Maybe< IfcProjectionElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSimpleProperty
-    struct IfcSimpleProperty : IfcProperty, ObjectHelper<IfcSimpleProperty,0> { IfcSimpleProperty() : Object("IfcSimpleProperty") {}
-
-    };
-
-    // C++ wrapper for IfcPropertyBoundedValue
-    struct IfcPropertyBoundedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyBoundedValue,4> { IfcPropertyBoundedValue() : Object("IfcPropertyBoundedValue") {}
-		Maybe< IfcValue::Out > UpperBoundValue;
-		Maybe< IfcValue::Out > LowerBoundValue;
-		Maybe< IfcUnit::Out > Unit;
-		Maybe< IfcValue::Out > SetPointValue;
-    };
-
-    // C++ wrapper for IfcPropertyEnumeratedValue
-    struct IfcPropertyEnumeratedValue : IfcSimpleProperty, ObjectHelper<IfcPropertyEnumeratedValue,2> { IfcPropertyEnumeratedValue() : Object("IfcPropertyEnumeratedValue") {}
-		Maybe< ListOf< IfcValue, 1, 0 >::Out > EnumerationValues;
-		Maybe< Lazy< NotImplemented > > EnumerationReference;
-    };
-
-    // C++ wrapper for IfcPropertyListValue
-    struct IfcPropertyListValue : IfcSimpleProperty, ObjectHelper<IfcPropertyListValue,2> { IfcPropertyListValue() : Object("IfcPropertyListValue") {}
-		Maybe< ListOf< IfcValue, 1, 0 >::Out > ListValues;
-		Maybe< IfcUnit::Out > Unit;
-    };
-
-    // C++ wrapper for IfcPropertyReferenceValue
-    struct IfcPropertyReferenceValue : IfcSimpleProperty, ObjectHelper<IfcPropertyReferenceValue,2> { IfcPropertyReferenceValue() : Object("IfcPropertyReferenceValue") {}
-		Maybe< IfcText::Out > UsageName;
-		Maybe< IfcObjectReferenceSelect::Out > PropertyReference;
-    };
-
-    // C++ wrapper for IfcPropertySet
-    struct IfcPropertySet : IfcPropertySetDefinition, ObjectHelper<IfcPropertySet,1> { IfcPropertySet() : Object("IfcPropertySet") {}
-		ListOf< Lazy< IfcProperty >, 1, 0 > HasProperties;
-    };
-
-    // C++ wrapper for IfcPropertySingleValue
-    struct IfcPropertySingleValue : IfcSimpleProperty, ObjectHelper<IfcPropertySingleValue,2> { IfcPropertySingleValue() : Object("IfcPropertySingleValue") {}
-		Maybe< IfcValue::Out > NominalValue;
-		Maybe< IfcUnit::Out > Unit;
-    };
-
-    // C++ wrapper for IfcPropertyTableValue
-    struct IfcPropertyTableValue : IfcSimpleProperty, ObjectHelper<IfcPropertyTableValue,6> { IfcPropertyTableValue() : Object("IfcPropertyTableValue") {}
-		Maybe< ListOf< IfcValue, 1, 0 >::Out > DefiningValues;
-		Maybe< ListOf< IfcValue, 1, 0 >::Out > DefinedValues;
-		Maybe< IfcText::Out > Expression;
-		Maybe< IfcUnit::Out > DefiningUnit;
-		Maybe< IfcUnit::Out > DefinedUnit;
-		Maybe< IfcCurveInterpolationEnum::Out > CurveInterpolation;
-    };
-
-    // C++ wrapper for IfcProtectiveDevice
-    struct IfcProtectiveDevice : IfcFlowController, ObjectHelper<IfcProtectiveDevice,1> { IfcProtectiveDevice() : Object("IfcProtectiveDevice") {}
-		Maybe< IfcProtectiveDeviceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcProtectiveDeviceTrippingUnit
-    struct IfcProtectiveDeviceTrippingUnit : IfcDistributionControlElement, ObjectHelper<IfcProtectiveDeviceTrippingUnit,1> { IfcProtectiveDeviceTrippingUnit() : Object("IfcProtectiveDeviceTrippingUnit") {}
-		Maybe< IfcProtectiveDeviceTrippingUnitTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcProtectiveDeviceTrippingUnitType
-    struct IfcProtectiveDeviceTrippingUnitType : IfcDistributionControlElementType, ObjectHelper<IfcProtectiveDeviceTrippingUnitType,1> { IfcProtectiveDeviceTrippingUnitType() : Object("IfcProtectiveDeviceTrippingUnitType") {}
-		IfcProtectiveDeviceTrippingUnitTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProtectiveDeviceType
-    struct IfcProtectiveDeviceType : IfcFlowControllerType, ObjectHelper<IfcProtectiveDeviceType,1> { IfcProtectiveDeviceType() : Object("IfcProtectiveDeviceType") {}
-		IfcProtectiveDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcProxy
-    struct IfcProxy : IfcProduct, ObjectHelper<IfcProxy,2> { IfcProxy() : Object("IfcProxy") {}
-		IfcObjectTypeEnum::Out ProxyType;
-		Maybe< IfcLabel::Out > Tag;
-    };
-
-    // C++ wrapper for IfcPump
-    struct IfcPump : IfcFlowMovingDevice, ObjectHelper<IfcPump,1> { IfcPump() : Object("IfcPump") {}
-		Maybe< IfcPumpTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcPumpType
-    struct IfcPumpType : IfcFlowMovingDeviceType, ObjectHelper<IfcPumpType,1> { IfcPumpType() : Object("IfcPumpType") {}
-		IfcPumpTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRailing
-    struct IfcRailing : IfcBuildingElement, ObjectHelper<IfcRailing,1> { IfcRailing() : Object("IfcRailing") {}
-		Maybe< IfcRailingTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcRailingType
-    struct IfcRailingType : IfcBuildingElementType, ObjectHelper<IfcRailingType,1> { IfcRailingType() : Object("IfcRailingType") {}
-		IfcRailingTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRamp
-    struct IfcRamp : IfcBuildingElement, ObjectHelper<IfcRamp,1> { IfcRamp() : Object("IfcRamp") {}
-		Maybe< IfcRampTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcRampFlight
-    struct IfcRampFlight : IfcBuildingElement, ObjectHelper<IfcRampFlight,1> { IfcRampFlight() : Object("IfcRampFlight") {}
-		Maybe< IfcRampFlightTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcRampFlightType
-    struct IfcRampFlightType : IfcBuildingElementType, ObjectHelper<IfcRampFlightType,1> { IfcRampFlightType() : Object("IfcRampFlightType") {}
-		IfcRampFlightTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRampType
-    struct IfcRampType : IfcBuildingElementType, ObjectHelper<IfcRampType,1> { IfcRampType() : Object("IfcRampType") {}
-		IfcRampTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRationalBSplineCurveWithKnots
-    struct IfcRationalBSplineCurveWithKnots : IfcBSplineCurveWithKnots, ObjectHelper<IfcRationalBSplineCurveWithKnots,1> { IfcRationalBSplineCurveWithKnots() : Object("IfcRationalBSplineCurveWithKnots") {}
-		ListOf< IfcReal, 2, 0 >::Out WeightsData;
-    };
-
-    // C++ wrapper for IfcRationalBSplineSurfaceWithKnots
-    struct IfcRationalBSplineSurfaceWithKnots : IfcBSplineSurfaceWithKnots, ObjectHelper<IfcRationalBSplineSurfaceWithKnots,0> { IfcRationalBSplineSurfaceWithKnots() : Object("IfcRationalBSplineSurfaceWithKnots") {}
-
-    };
-
-    // C++ wrapper for IfcRectangleProfileDef
-    struct IfcRectangleProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcRectangleProfileDef,2> { IfcRectangleProfileDef() : Object("IfcRectangleProfileDef") {}
-		IfcPositiveLengthMeasure::Out XDim;
-		IfcPositiveLengthMeasure::Out YDim;
-    };
-
-    // C++ wrapper for IfcRectangleHollowProfileDef
-    struct IfcRectangleHollowProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRectangleHollowProfileDef,3> { IfcRectangleHollowProfileDef() : Object("IfcRectangleHollowProfileDef") {}
-		IfcPositiveLengthMeasure::Out WallThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > InnerFilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > OuterFilletRadius;
-    };
-
-    // C++ wrapper for IfcRectangularPyramid
-    struct IfcRectangularPyramid : IfcCsgPrimitive3D, ObjectHelper<IfcRectangularPyramid,3> { IfcRectangularPyramid() : Object("IfcRectangularPyramid") {}
-		IfcPositiveLengthMeasure::Out XLength;
-		IfcPositiveLengthMeasure::Out YLength;
-		IfcPositiveLengthMeasure::Out Height;
-    };
-
-    // C++ wrapper for IfcRectangularTrimmedSurface
-    struct IfcRectangularTrimmedSurface : IfcBoundedSurface, ObjectHelper<IfcRectangularTrimmedSurface,7> { IfcRectangularTrimmedSurface() : Object("IfcRectangularTrimmedSurface") {}
-		Lazy< IfcSurface > BasisSurface;
-		IfcParameterValue::Out U1;
-		IfcParameterValue::Out V1;
-		IfcParameterValue::Out U2;
-		IfcParameterValue::Out V2;
-		IfcBoolean::Out Usense;
-		IfcBoolean::Out Vsense;
-    };
-
-    // C++ wrapper for IfcReinforcingElement
-    struct IfcReinforcingElement : IfcElementComponent, ObjectHelper<IfcReinforcingElement,1> { IfcReinforcingElement() : Object("IfcReinforcingElement") {}
-		Maybe< IfcLabel::Out > SteelGrade;
-    };
-
-    // C++ wrapper for IfcReinforcingBar
-    struct IfcReinforcingBar : IfcReinforcingElement, ObjectHelper<IfcReinforcingBar,5> { IfcReinforcingBar() : Object("IfcReinforcingBar") {}
-		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
-		Maybe< IfcPositiveLengthMeasure::Out > BarLength;
-		Maybe< IfcReinforcingBarTypeEnum::Out > PredefinedType;
-		Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
-    };
-
-    // C++ wrapper for IfcReinforcingElementType
-    struct IfcReinforcingElementType : IfcElementComponentType, ObjectHelper<IfcReinforcingElementType,0> { IfcReinforcingElementType() : Object("IfcReinforcingElementType") {}
-
-    };
-
-    // C++ wrapper for IfcReinforcingBarType
-    struct IfcReinforcingBarType : IfcReinforcingElementType, ObjectHelper<IfcReinforcingBarType,7> { IfcReinforcingBarType() : Object("IfcReinforcingBarType") {}
-		IfcReinforcingBarTypeEnum::Out PredefinedType;
-		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
-		Maybe< IfcPositiveLengthMeasure::Out > BarLength;
-		Maybe< IfcReinforcingBarSurfaceEnum::Out > BarSurface;
-		Maybe< IfcLabel::Out > BendingShapeCode;
-		Maybe< ListOf< IfcBendingParameterSelect, 1, 0 >::Out > BendingParameters;
-    };
-
-    // C++ wrapper for IfcReinforcingMesh
-    struct IfcReinforcingMesh : IfcReinforcingElement, ObjectHelper<IfcReinforcingMesh,9> { IfcReinforcingMesh() : Object("IfcReinforcingMesh") {}
-		Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
-		Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
-		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarNominalDiameter;
-		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarNominalDiameter;
-		Maybe< IfcAreaMeasure::Out > LongitudinalBarCrossSectionArea;
-		Maybe< IfcAreaMeasure::Out > TransverseBarCrossSectionArea;
-		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarSpacing;
-		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarSpacing;
-		Maybe< IfcReinforcingMeshTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcReinforcingMeshType
-    struct IfcReinforcingMeshType : IfcReinforcingElementType, ObjectHelper<IfcReinforcingMeshType,11> { IfcReinforcingMeshType() : Object("IfcReinforcingMeshType") {}
-		IfcReinforcingMeshTypeEnum::Out PredefinedType;
-		Maybe< IfcPositiveLengthMeasure::Out > MeshLength;
-		Maybe< IfcPositiveLengthMeasure::Out > MeshWidth;
-		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarNominalDiameter;
-		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarNominalDiameter;
-		Maybe< IfcAreaMeasure::Out > LongitudinalBarCrossSectionArea;
-		Maybe< IfcAreaMeasure::Out > TransverseBarCrossSectionArea;
-		Maybe< IfcPositiveLengthMeasure::Out > LongitudinalBarSpacing;
-		Maybe< IfcPositiveLengthMeasure::Out > TransverseBarSpacing;
-		Maybe< IfcLabel::Out > BendingShapeCode;
-		Maybe< ListOf< IfcBendingParameterSelect, 1, 0 >::Out > BendingParameters;
-    };
-
-    // C++ wrapper for IfcRelationship
-    struct IfcRelationship : IfcRoot, ObjectHelper<IfcRelationship,0> { IfcRelationship() : Object("IfcRelationship") {}
-
-    };
-
-    // C++ wrapper for IfcRelDecomposes
-    struct IfcRelDecomposes : IfcRelationship, ObjectHelper<IfcRelDecomposes,0> { IfcRelDecomposes() : Object("IfcRelDecomposes") {}
-
-    };
-
-    // C++ wrapper for IfcRelAggregates
-    struct IfcRelAggregates : IfcRelDecomposes, ObjectHelper<IfcRelAggregates,2> { IfcRelAggregates() : Object("IfcRelAggregates") {}
-		Lazy< IfcObjectDefinition > RelatingObject;
-		ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
-    };
-
-    // C++ wrapper for IfcRelConnects
-    struct IfcRelConnects : IfcRelationship, ObjectHelper<IfcRelConnects,0> { IfcRelConnects() : Object("IfcRelConnects") {}
-
-    };
-
-    // C++ wrapper for IfcRelContainedInSpatialStructure
-    struct IfcRelContainedInSpatialStructure : IfcRelConnects, ObjectHelper<IfcRelContainedInSpatialStructure,2> { IfcRelContainedInSpatialStructure() : Object("IfcRelContainedInSpatialStructure") {}
-		ListOf< Lazy< IfcProduct >, 1, 0 > RelatedElements;
-		Lazy< IfcSpatialElement > RelatingStructure;
-    };
-
-    // C++ wrapper for IfcRelDefines
-    struct IfcRelDefines : IfcRelationship, ObjectHelper<IfcRelDefines,0> { IfcRelDefines() : Object("IfcRelDefines") {}
-
-    };
-
-    // C++ wrapper for IfcRelDefinesByProperties
-    struct IfcRelDefinesByProperties : IfcRelDefines, ObjectHelper<IfcRelDefinesByProperties,2> { IfcRelDefinesByProperties() : Object("IfcRelDefinesByProperties") {}
-		ListOf< Lazy< IfcObjectDefinition >, 1, 0 > RelatedObjects;
-		IfcPropertySetDefinitionSelect::Out RelatingPropertyDefinition;
-    };
-
-    // C++ wrapper for IfcRelFillsElement
-    struct IfcRelFillsElement : IfcRelConnects, ObjectHelper<IfcRelFillsElement,2> { IfcRelFillsElement() : Object("IfcRelFillsElement") {}
-		Lazy< IfcOpeningElement > RelatingOpeningElement;
-		Lazy< IfcElement > RelatedBuildingElement;
-    };
-
-    // C++ wrapper for IfcRelVoidsElement
-    struct IfcRelVoidsElement : IfcRelDecomposes, ObjectHelper<IfcRelVoidsElement,2> { IfcRelVoidsElement() : Object("IfcRelVoidsElement") {}
-		Lazy< IfcElement > RelatingBuildingElement;
-		Lazy< IfcFeatureElementSubtraction > RelatedOpeningElement;
-    };
-
-    // C++ wrapper for IfcReparametrisedCompositeCurveSegment
-    struct IfcReparametrisedCompositeCurveSegment : IfcCompositeCurveSegment, ObjectHelper<IfcReparametrisedCompositeCurveSegment,1> { IfcReparametrisedCompositeCurveSegment() : Object("IfcReparametrisedCompositeCurveSegment") {}
-		IfcParameterValue::Out ParamLength;
-    };
-
-    // C++ wrapper for IfcRepresentation
-    struct IfcRepresentation :  ObjectHelper<IfcRepresentation,4> { IfcRepresentation() : Object("IfcRepresentation") {}
-		Lazy< IfcRepresentationContext > ContextOfItems;
-		Maybe< IfcLabel::Out > RepresentationIdentifier;
-		Maybe< IfcLabel::Out > RepresentationType;
-		ListOf< Lazy< IfcRepresentationItem >, 1, 0 > Items;
-    };
-
-    // C++ wrapper for IfcRepresentationMap
-    struct IfcRepresentationMap :  ObjectHelper<IfcRepresentationMap,2> { IfcRepresentationMap() : Object("IfcRepresentationMap") {}
-		IfcAxis2Placement::Out MappingOrigin;
-		Lazy< IfcRepresentation > MappedRepresentation;
-    };
-
-    // C++ wrapper for IfcRevolvedAreaSolid
-    struct IfcRevolvedAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcRevolvedAreaSolid,2> { IfcRevolvedAreaSolid() : Object("IfcRevolvedAreaSolid") {}
-		Lazy< IfcAxis1Placement > Axis;
-		IfcPlaneAngleMeasure::Out Angle;
-    };
-
-    // C++ wrapper for IfcRevolvedAreaSolidTapered
-    struct IfcRevolvedAreaSolidTapered : IfcRevolvedAreaSolid, ObjectHelper<IfcRevolvedAreaSolidTapered,1> { IfcRevolvedAreaSolidTapered() : Object("IfcRevolvedAreaSolidTapered") {}
-		Lazy< IfcProfileDef > EndSweptArea;
-    };
-
-    // C++ wrapper for IfcRightCircularCone
-    struct IfcRightCircularCone : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCone,2> { IfcRightCircularCone() : Object("IfcRightCircularCone") {}
-		IfcPositiveLengthMeasure::Out Height;
-		IfcPositiveLengthMeasure::Out BottomRadius;
-    };
-
-    // C++ wrapper for IfcRightCircularCylinder
-    struct IfcRightCircularCylinder : IfcCsgPrimitive3D, ObjectHelper<IfcRightCircularCylinder,2> { IfcRightCircularCylinder() : Object("IfcRightCircularCylinder") {}
-		IfcPositiveLengthMeasure::Out Height;
-		IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcRoof
-    struct IfcRoof : IfcBuildingElement, ObjectHelper<IfcRoof,1> { IfcRoof() : Object("IfcRoof") {}
-		Maybe< IfcRoofTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcRoofType
-    struct IfcRoofType : IfcBuildingElementType, ObjectHelper<IfcRoofType,1> { IfcRoofType() : Object("IfcRoofType") {}
-		IfcRoofTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcRoundedRectangleProfileDef
-    struct IfcRoundedRectangleProfileDef : IfcRectangleProfileDef, ObjectHelper<IfcRoundedRectangleProfileDef,1> { IfcRoundedRectangleProfileDef() : Object("IfcRoundedRectangleProfileDef") {}
-		IfcPositiveLengthMeasure::Out RoundingRadius;
-    };
-
-    // C++ wrapper for IfcSIUnit
-    struct IfcSIUnit : IfcNamedUnit, ObjectHelper<IfcSIUnit,2> { IfcSIUnit() : Object("IfcSIUnit") {}
-		Maybe< IfcSIPrefix::Out > Prefix;
-		IfcSIUnitName::Out Name;
-    };
-
-    // C++ wrapper for IfcSanitaryTerminal
-    struct IfcSanitaryTerminal : IfcFlowTerminal, ObjectHelper<IfcSanitaryTerminal,1> { IfcSanitaryTerminal() : Object("IfcSanitaryTerminal") {}
-		Maybe< IfcSanitaryTerminalTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSanitaryTerminalType
-    struct IfcSanitaryTerminalType : IfcFlowTerminalType, ObjectHelper<IfcSanitaryTerminalType,1> { IfcSanitaryTerminalType() : Object("IfcSanitaryTerminalType") {}
-		IfcSanitaryTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSeamCurve
-    struct IfcSeamCurve : IfcSurfaceCurve, ObjectHelper<IfcSeamCurve,0> { IfcSeamCurve() : Object("IfcSeamCurve") {}
-
-    };
-
-    // C++ wrapper for IfcSectionedSpine
-    struct IfcSectionedSpine : IfcGeometricRepresentationItem, ObjectHelper<IfcSectionedSpine,3> { IfcSectionedSpine() : Object("IfcSectionedSpine") {}
-		Lazy< IfcCompositeCurve > SpineCurve;
-		ListOf< Lazy< IfcProfileDef >, 2, 0 > CrossSections;
-		ListOf< Lazy< IfcAxis2Placement3D >, 2, 0 > CrossSectionPositions;
-    };
-
-    // C++ wrapper for IfcSensor
-    struct IfcSensor : IfcDistributionControlElement, ObjectHelper<IfcSensor,1> { IfcSensor() : Object("IfcSensor") {}
-		Maybe< IfcSensorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSensorType
-    struct IfcSensorType : IfcDistributionControlElementType, ObjectHelper<IfcSensorType,1> { IfcSensorType() : Object("IfcSensorType") {}
-		IfcSensorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcShadingDevice
-    struct IfcShadingDevice : IfcBuildingElement, ObjectHelper<IfcShadingDevice,1> { IfcShadingDevice() : Object("IfcShadingDevice") {}
-		Maybe< IfcShadingDeviceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcShadingDeviceType
-    struct IfcShadingDeviceType : IfcBuildingElementType, ObjectHelper<IfcShadingDeviceType,1> { IfcShadingDeviceType() : Object("IfcShadingDeviceType") {}
-		IfcShadingDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcShapeModel
-    struct IfcShapeModel : IfcRepresentation, ObjectHelper<IfcShapeModel,0> { IfcShapeModel() : Object("IfcShapeModel") {}
-
-    };
-
-    // C++ wrapper for IfcShapeRepresentation
-    struct IfcShapeRepresentation : IfcShapeModel, ObjectHelper<IfcShapeRepresentation,0> { IfcShapeRepresentation() : Object("IfcShapeRepresentation") {}
-
-    };
-
-    // C++ wrapper for IfcShellBasedSurfaceModel
-    struct IfcShellBasedSurfaceModel : IfcGeometricRepresentationItem, ObjectHelper<IfcShellBasedSurfaceModel,1> { IfcShellBasedSurfaceModel() : Object("IfcShellBasedSurfaceModel") {}
-		ListOf< IfcShell, 1, 0 >::Out SbsmBoundary;
-    };
-
-    // C++ wrapper for IfcSite
-    struct IfcSite : IfcSpatialStructureElement, ObjectHelper<IfcSite,5> { IfcSite() : Object("IfcSite") {}
-		Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLatitude;
-		Maybe< IfcCompoundPlaneAngleMeasure::Out > RefLongitude;
-		Maybe< IfcLengthMeasure::Out > RefElevation;
-		Maybe< IfcLabel::Out > LandTitleNumber;
-		Maybe< Lazy< NotImplemented > > SiteAddress;
-    };
-
-    // C++ wrapper for IfcSlab
-    struct IfcSlab : IfcBuildingElement, ObjectHelper<IfcSlab,1> { IfcSlab() : Object("IfcSlab") {}
-		Maybe< IfcSlabTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSlabElementedCase
-    struct IfcSlabElementedCase : IfcSlab, ObjectHelper<IfcSlabElementedCase,0> { IfcSlabElementedCase() : Object("IfcSlabElementedCase") {}
-
-    };
-
-    // C++ wrapper for IfcSlabStandardCase
-    struct IfcSlabStandardCase : IfcSlab, ObjectHelper<IfcSlabStandardCase,0> { IfcSlabStandardCase() : Object("IfcSlabStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcSlabType
-    struct IfcSlabType : IfcBuildingElementType, ObjectHelper<IfcSlabType,1> { IfcSlabType() : Object("IfcSlabType") {}
-		IfcSlabTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSolarDevice
-    struct IfcSolarDevice : IfcEnergyConversionDevice, ObjectHelper<IfcSolarDevice,1> { IfcSolarDevice() : Object("IfcSolarDevice") {}
-		Maybe< IfcSolarDeviceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSolarDeviceType
-    struct IfcSolarDeviceType : IfcEnergyConversionDeviceType, ObjectHelper<IfcSolarDeviceType,1> { IfcSolarDeviceType() : Object("IfcSolarDeviceType") {}
-		IfcSolarDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSpace
-    struct IfcSpace : IfcSpatialStructureElement, ObjectHelper<IfcSpace,2> { IfcSpace() : Object("IfcSpace") {}
-		Maybe< IfcSpaceTypeEnum::Out > PredefinedType;
-		Maybe< IfcLengthMeasure::Out > ElevationWithFlooring;
-    };
-
-    // C++ wrapper for IfcSpaceHeater
-    struct IfcSpaceHeater : IfcFlowTerminal, ObjectHelper<IfcSpaceHeater,1> { IfcSpaceHeater() : Object("IfcSpaceHeater") {}
-		Maybe< IfcSpaceHeaterTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSpaceHeaterType
-    struct IfcSpaceHeaterType : IfcFlowTerminalType, ObjectHelper<IfcSpaceHeaterType,1> { IfcSpaceHeaterType() : Object("IfcSpaceHeaterType") {}
-		IfcSpaceHeaterTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSpatialElementType
-    struct IfcSpatialElementType : IfcTypeProduct, ObjectHelper<IfcSpatialElementType,1> { IfcSpatialElementType() : Object("IfcSpatialElementType") {}
-		Maybe< IfcLabel::Out > ElementType;
-    };
-
-    // C++ wrapper for IfcSpatialStructureElementType
-    struct IfcSpatialStructureElementType : IfcSpatialElementType, ObjectHelper<IfcSpatialStructureElementType,0> { IfcSpatialStructureElementType() : Object("IfcSpatialStructureElementType") {}
-
-    };
-
-    // C++ wrapper for IfcSpaceType
-    struct IfcSpaceType : IfcSpatialStructureElementType, ObjectHelper<IfcSpaceType,2> { IfcSpaceType() : Object("IfcSpaceType") {}
-		IfcSpaceTypeEnum::Out PredefinedType;
-		Maybe< IfcLabel::Out > LongName;
-    };
-
-    // C++ wrapper for IfcSpatialZone
-    struct IfcSpatialZone : IfcSpatialElement, ObjectHelper<IfcSpatialZone,1> { IfcSpatialZone() : Object("IfcSpatialZone") {}
-		Maybe< IfcSpatialZoneTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSpatialZoneType
-    struct IfcSpatialZoneType : IfcSpatialElementType, ObjectHelper<IfcSpatialZoneType,2> { IfcSpatialZoneType() : Object("IfcSpatialZoneType") {}
-		IfcSpatialZoneTypeEnum::Out PredefinedType;
-		Maybe< IfcLabel::Out > LongName;
-    };
-
-    // C++ wrapper for IfcSphere
-    struct IfcSphere : IfcCsgPrimitive3D, ObjectHelper<IfcSphere,1> { IfcSphere() : Object("IfcSphere") {}
-		IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcSphericalSurface
-    struct IfcSphericalSurface : IfcElementarySurface, ObjectHelper<IfcSphericalSurface,1> { IfcSphericalSurface() : Object("IfcSphericalSurface") {}
-		IfcPositiveLengthMeasure::Out Radius;
-    };
-
-    // C++ wrapper for IfcStackTerminal
-    struct IfcStackTerminal : IfcFlowTerminal, ObjectHelper<IfcStackTerminal,1> { IfcStackTerminal() : Object("IfcStackTerminal") {}
-		Maybe< IfcStackTerminalTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcStackTerminalType
-    struct IfcStackTerminalType : IfcFlowTerminalType, ObjectHelper<IfcStackTerminalType,1> { IfcStackTerminalType() : Object("IfcStackTerminalType") {}
-		IfcStackTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStair
-    struct IfcStair : IfcBuildingElement, ObjectHelper<IfcStair,1> { IfcStair() : Object("IfcStair") {}
-		Maybe< IfcStairTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcStairFlight
-    struct IfcStairFlight : IfcBuildingElement, ObjectHelper<IfcStairFlight,5> { IfcStairFlight() : Object("IfcStairFlight") {}
-		Maybe< IfcInteger::Out > NumberOfRisers;
-		Maybe< IfcInteger::Out > NumberOfTreads;
-		Maybe< IfcPositiveLengthMeasure::Out > RiserHeight;
-		Maybe< IfcPositiveLengthMeasure::Out > TreadLength;
-		Maybe< IfcStairFlightTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcStairFlightType
-    struct IfcStairFlightType : IfcBuildingElementType, ObjectHelper<IfcStairFlightType,1> { IfcStairFlightType() : Object("IfcStairFlightType") {}
-		IfcStairFlightTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStairType
-    struct IfcStairType : IfcBuildingElementType, ObjectHelper<IfcStairType,1> { IfcStairType() : Object("IfcStairType") {}
-		IfcStairTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStructuralActivity
-    struct IfcStructuralActivity : IfcProduct, ObjectHelper<IfcStructuralActivity,2> { IfcStructuralActivity() : Object("IfcStructuralActivity") {}
-		Lazy< NotImplemented > AppliedLoad;
-		IfcGlobalOrLocalEnum::Out GlobalOrLocal;
-    };
-
-    // C++ wrapper for IfcStructuralAction
-    struct IfcStructuralAction : IfcStructuralActivity, ObjectHelper<IfcStructuralAction,1> { IfcStructuralAction() : Object("IfcStructuralAction") {}
-		Maybe< IfcBoolean::Out > DestabilizingLoad;
-    };
-
-    // C++ wrapper for IfcStructuralAnalysisModel
-    struct IfcStructuralAnalysisModel : IfcSystem, ObjectHelper<IfcStructuralAnalysisModel,5> { IfcStructuralAnalysisModel() : Object("IfcStructuralAnalysisModel") {}
-		IfcAnalysisModelTypeEnum::Out PredefinedType;
-		Maybe< Lazy< IfcAxis2Placement3D > > OrientationOf2DPlane;
-		Maybe< ListOf< Lazy< IfcStructuralLoadGroup >, 1, 0 > > LoadedBy;
-		Maybe< ListOf< Lazy< IfcStructuralResultGroup >, 1, 0 > > HasResults;
-		Maybe< Lazy< IfcObjectPlacement > > SharedPlacement;
-    };
-
-    // C++ wrapper for IfcStructuralItem
-    struct IfcStructuralItem : IfcProduct, ObjectHelper<IfcStructuralItem,0> { IfcStructuralItem() : Object("IfcStructuralItem") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralConnection
-    struct IfcStructuralConnection : IfcStructuralItem, ObjectHelper<IfcStructuralConnection,1> { IfcStructuralConnection() : Object("IfcStructuralConnection") {}
-		Maybe< Lazy< NotImplemented > > AppliedCondition;
-    };
-
-    // C++ wrapper for IfcStructuralCurveAction
-    struct IfcStructuralCurveAction : IfcStructuralAction, ObjectHelper<IfcStructuralCurveAction,2> { IfcStructuralCurveAction() : Object("IfcStructuralCurveAction") {}
-		Maybe< IfcProjectedOrTrueLengthEnum::Out > ProjectedOrTrue;
-		IfcStructuralCurveActivityTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStructuralCurveConnection
-    struct IfcStructuralCurveConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralCurveConnection,1> { IfcStructuralCurveConnection() : Object("IfcStructuralCurveConnection") {}
-		Lazy< IfcDirection > Axis;
-    };
-
-    // C++ wrapper for IfcStructuralMember
-    struct IfcStructuralMember : IfcStructuralItem, ObjectHelper<IfcStructuralMember,0> { IfcStructuralMember() : Object("IfcStructuralMember") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralCurveMember
-    struct IfcStructuralCurveMember : IfcStructuralMember, ObjectHelper<IfcStructuralCurveMember,2> { IfcStructuralCurveMember() : Object("IfcStructuralCurveMember") {}
-		IfcStructuralCurveMemberTypeEnum::Out PredefinedType;
-		Lazy< IfcDirection > Axis;
-    };
-
-    // C++ wrapper for IfcStructuralCurveMemberVarying
-    struct IfcStructuralCurveMemberVarying : IfcStructuralCurveMember, ObjectHelper<IfcStructuralCurveMemberVarying,0> { IfcStructuralCurveMemberVarying() : Object("IfcStructuralCurveMemberVarying") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralReaction
-    struct IfcStructuralReaction : IfcStructuralActivity, ObjectHelper<IfcStructuralReaction,0> { IfcStructuralReaction() : Object("IfcStructuralReaction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralCurveReaction
-    struct IfcStructuralCurveReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralCurveReaction,1> { IfcStructuralCurveReaction() : Object("IfcStructuralCurveReaction") {}
-		IfcStructuralCurveActivityTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStructuralLinearAction
-    struct IfcStructuralLinearAction : IfcStructuralCurveAction, ObjectHelper<IfcStructuralLinearAction,0> { IfcStructuralLinearAction() : Object("IfcStructuralLinearAction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralLoadGroup
-    struct IfcStructuralLoadGroup : IfcGroup, ObjectHelper<IfcStructuralLoadGroup,5> { IfcStructuralLoadGroup() : Object("IfcStructuralLoadGroup") {}
-		IfcLoadGroupTypeEnum::Out PredefinedType;
-		IfcActionTypeEnum::Out ActionType;
-		IfcActionSourceTypeEnum::Out ActionSource;
-		Maybe< IfcRatioMeasure::Out > Coefficient;
-		Maybe< IfcLabel::Out > Purpose;
-    };
-
-    // C++ wrapper for IfcStructuralLoadCase
-    struct IfcStructuralLoadCase : IfcStructuralLoadGroup, ObjectHelper<IfcStructuralLoadCase,1> { IfcStructuralLoadCase() : Object("IfcStructuralLoadCase") {}
-		Maybe< ListOf< IfcRatioMeasure, 3, 3 >::Out > SelfWeightCoefficients;
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceAction
-    struct IfcStructuralSurfaceAction : IfcStructuralAction, ObjectHelper<IfcStructuralSurfaceAction,2> { IfcStructuralSurfaceAction() : Object("IfcStructuralSurfaceAction") {}
-		Maybe< IfcProjectedOrTrueLengthEnum::Out > ProjectedOrTrue;
-		IfcStructuralSurfaceActivityTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStructuralPlanarAction
-    struct IfcStructuralPlanarAction : IfcStructuralSurfaceAction, ObjectHelper<IfcStructuralPlanarAction,0> { IfcStructuralPlanarAction() : Object("IfcStructuralPlanarAction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralPointAction
-    struct IfcStructuralPointAction : IfcStructuralAction, ObjectHelper<IfcStructuralPointAction,0> { IfcStructuralPointAction() : Object("IfcStructuralPointAction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralPointConnection
-    struct IfcStructuralPointConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralPointConnection,1> { IfcStructuralPointConnection() : Object("IfcStructuralPointConnection") {}
-		Maybe< Lazy< IfcAxis2Placement3D > > ConditionCoordinateSystem;
-    };
-
-    // C++ wrapper for IfcStructuralPointReaction
-    struct IfcStructuralPointReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralPointReaction,0> { IfcStructuralPointReaction() : Object("IfcStructuralPointReaction") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralResultGroup
-    struct IfcStructuralResultGroup : IfcGroup, ObjectHelper<IfcStructuralResultGroup,3> { IfcStructuralResultGroup() : Object("IfcStructuralResultGroup") {}
-		IfcAnalysisTheoryTypeEnum::Out TheoryType;
-		Maybe< Lazy< IfcStructuralLoadGroup > > ResultForLoadGroup;
-		IfcBoolean::Out IsLinear;
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceConnection
-    struct IfcStructuralSurfaceConnection : IfcStructuralConnection, ObjectHelper<IfcStructuralSurfaceConnection,0> { IfcStructuralSurfaceConnection() : Object("IfcStructuralSurfaceConnection") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceMember
-    struct IfcStructuralSurfaceMember : IfcStructuralMember, ObjectHelper<IfcStructuralSurfaceMember,2> { IfcStructuralSurfaceMember() : Object("IfcStructuralSurfaceMember") {}
-		IfcStructuralSurfaceMemberTypeEnum::Out PredefinedType;
-		Maybe< IfcPositiveLengthMeasure::Out > Thickness;
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceMemberVarying
-    struct IfcStructuralSurfaceMemberVarying : IfcStructuralSurfaceMember, ObjectHelper<IfcStructuralSurfaceMemberVarying,0> { IfcStructuralSurfaceMemberVarying() : Object("IfcStructuralSurfaceMemberVarying") {}
-
-    };
-
-    // C++ wrapper for IfcStructuralSurfaceReaction
-    struct IfcStructuralSurfaceReaction : IfcStructuralReaction, ObjectHelper<IfcStructuralSurfaceReaction,1> { IfcStructuralSurfaceReaction() : Object("IfcStructuralSurfaceReaction") {}
-		IfcStructuralSurfaceActivityTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcStyleModel
-    struct IfcStyleModel : IfcRepresentation, ObjectHelper<IfcStyleModel,0> { IfcStyleModel() : Object("IfcStyleModel") {}
-
-    };
-
-    // C++ wrapper for IfcStyledItem
-    struct IfcStyledItem : IfcRepresentationItem, ObjectHelper<IfcStyledItem,3> { IfcStyledItem() : Object("IfcStyledItem") {}
-		Maybe< Lazy< IfcRepresentationItem > > Item;
-		ListOf< IfcStyleAssignmentSelect, 1, 0 >::Out Styles;
-		Maybe< IfcLabel::Out > Name;
-    };
-
-    // C++ wrapper for IfcStyledRepresentation
-    struct IfcStyledRepresentation : IfcStyleModel, ObjectHelper<IfcStyledRepresentation,0> { IfcStyledRepresentation() : Object("IfcStyledRepresentation") {}
-
-    };
-
-    // C++ wrapper for IfcSubContractResource
-    struct IfcSubContractResource : IfcConstructionResource, ObjectHelper<IfcSubContractResource,1> { IfcSubContractResource() : Object("IfcSubContractResource") {}
-		Maybe< IfcSubContractResourceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSubContractResourceType
-    struct IfcSubContractResourceType : IfcConstructionResourceType, ObjectHelper<IfcSubContractResourceType,1> { IfcSubContractResourceType() : Object("IfcSubContractResourceType") {}
-		IfcSubContractResourceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSubedge
-    struct IfcSubedge : IfcEdge, ObjectHelper<IfcSubedge,1> { IfcSubedge() : Object("IfcSubedge") {}
-		Lazy< IfcEdge > ParentEdge;
-    };
-
-    // C++ wrapper for IfcSurfaceCurveSweptAreaSolid
-    struct IfcSurfaceCurveSweptAreaSolid : IfcSweptAreaSolid, ObjectHelper<IfcSurfaceCurveSweptAreaSolid,4> { IfcSurfaceCurveSweptAreaSolid() : Object("IfcSurfaceCurveSweptAreaSolid") {}
-		Lazy< IfcCurve > Directrix;
-		Maybe< IfcParameterValue::Out > StartParam;
-		Maybe< IfcParameterValue::Out > EndParam;
-		Lazy< IfcSurface > ReferenceSurface;
-    };
-
-    // C++ wrapper for IfcSurfaceFeature
-    struct IfcSurfaceFeature : IfcFeatureElement, ObjectHelper<IfcSurfaceFeature,1> { IfcSurfaceFeature() : Object("IfcSurfaceFeature") {}
-		Maybe< IfcSurfaceFeatureTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSweptSurface
-    struct IfcSweptSurface : IfcSurface, ObjectHelper<IfcSweptSurface,2> { IfcSweptSurface() : Object("IfcSweptSurface") {}
-		Lazy< IfcProfileDef > SweptCurve;
-		Maybe< Lazy< IfcAxis2Placement3D > > Position;
-    };
-
-    // C++ wrapper for IfcSurfaceOfLinearExtrusion
-    struct IfcSurfaceOfLinearExtrusion : IfcSweptSurface, ObjectHelper<IfcSurfaceOfLinearExtrusion,2> { IfcSurfaceOfLinearExtrusion() : Object("IfcSurfaceOfLinearExtrusion") {}
-		Lazy< IfcDirection > ExtrudedDirection;
-		IfcLengthMeasure::Out Depth;
-    };
-
-    // C++ wrapper for IfcSurfaceOfRevolution
-    struct IfcSurfaceOfRevolution : IfcSweptSurface, ObjectHelper<IfcSurfaceOfRevolution,1> { IfcSurfaceOfRevolution() : Object("IfcSurfaceOfRevolution") {}
-		Lazy< IfcAxis1Placement > AxisPosition;
-    };
-
-    // C++ wrapper for IfcSurfaceStyle
-    struct IfcSurfaceStyle : IfcPresentationStyle, ObjectHelper<IfcSurfaceStyle,2> { IfcSurfaceStyle() : Object("IfcSurfaceStyle") {}
-		IfcSurfaceSide::Out Side;
-		ListOf< IfcSurfaceStyleElementSelect, 1, 5 >::Out Styles;
-    };
-
-    // C++ wrapper for IfcSurfaceStyleShading
-    struct IfcSurfaceStyleShading : IfcPresentationItem, ObjectHelper<IfcSurfaceStyleShading,2> { IfcSurfaceStyleShading() : Object("IfcSurfaceStyleShading") {}
-		Lazy< IfcColourRgb > SurfaceColour;
-		Maybe< IfcNormalisedRatioMeasure::Out > Transparency;
-    };
-
-    // C++ wrapper for IfcSurfaceStyleRendering
-    struct IfcSurfaceStyleRendering : IfcSurfaceStyleShading, ObjectHelper<IfcSurfaceStyleRendering,7> { IfcSurfaceStyleRendering() : Object("IfcSurfaceStyleRendering") {}
-		Maybe< IfcColourOrFactor::Out > DiffuseColour;
-		Maybe< IfcColourOrFactor::Out > TransmissionColour;
-		Maybe< IfcColourOrFactor::Out > DiffuseTransmissionColour;
-		Maybe< IfcColourOrFactor::Out > ReflectionColour;
-		Maybe< IfcColourOrFactor::Out > SpecularColour;
-		Maybe< IfcSpecularHighlightSelect::Out > SpecularHighlight;
-		IfcReflectanceMethodEnum::Out ReflectanceMethod;
-    };
-
-    // C++ wrapper for IfcSurfaceStyleWithTextures
-    struct IfcSurfaceStyleWithTextures : IfcPresentationItem, ObjectHelper<IfcSurfaceStyleWithTextures,1> { IfcSurfaceStyleWithTextures() : Object("IfcSurfaceStyleWithTextures") {}
-		ListOf< Lazy< NotImplemented >, 1, 0 > Textures;
-    };
-
-    // C++ wrapper for IfcSweptDiskSolid
-    struct IfcSweptDiskSolid : IfcSolidModel, ObjectHelper<IfcSweptDiskSolid,5> { IfcSweptDiskSolid() : Object("IfcSweptDiskSolid") {}
-		Lazy< IfcCurve > Directrix;
-		IfcPositiveLengthMeasure::Out Radius;
-		Maybe< IfcPositiveLengthMeasure::Out > InnerRadius;
-		Maybe< IfcParameterValue::Out > StartParam;
-		Maybe< IfcParameterValue::Out > EndParam;
-    };
-
-    // C++ wrapper for IfcSweptDiskSolidPolygonal
-    struct IfcSweptDiskSolidPolygonal : IfcSweptDiskSolid, ObjectHelper<IfcSweptDiskSolidPolygonal,1> { IfcSweptDiskSolidPolygonal() : Object("IfcSweptDiskSolidPolygonal") {}
-		Maybe< IfcPositiveLengthMeasure::Out > FilletRadius;
-    };
-
-    // C++ wrapper for IfcSwitchingDevice
-    struct IfcSwitchingDevice : IfcFlowController, ObjectHelper<IfcSwitchingDevice,1> { IfcSwitchingDevice() : Object("IfcSwitchingDevice") {}
-		Maybe< IfcSwitchingDeviceTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSwitchingDeviceType
-    struct IfcSwitchingDeviceType : IfcFlowControllerType, ObjectHelper<IfcSwitchingDeviceType,1> { IfcSwitchingDeviceType() : Object("IfcSwitchingDeviceType") {}
-		IfcSwitchingDeviceTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcSystemFurnitureElement
-    struct IfcSystemFurnitureElement : IfcFurnishingElement, ObjectHelper<IfcSystemFurnitureElement,1> { IfcSystemFurnitureElement() : Object("IfcSystemFurnitureElement") {}
-		Maybe< IfcSystemFurnitureElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcSystemFurnitureElementType
-    struct IfcSystemFurnitureElementType : IfcFurnishingElementType, ObjectHelper<IfcSystemFurnitureElementType,1> { IfcSystemFurnitureElementType() : Object("IfcSystemFurnitureElementType") {}
-		Maybe< IfcSystemFurnitureElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTShapeProfileDef
-    struct IfcTShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTShapeProfileDef,9> { IfcTShapeProfileDef() : Object("IfcTShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out Depth;
-		IfcPositiveLengthMeasure::Out FlangeWidth;
-		IfcPositiveLengthMeasure::Out WebThickness;
-		IfcPositiveLengthMeasure::Out FlangeThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FlangeEdgeRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > WebEdgeRadius;
-		Maybe< IfcPlaneAngleMeasure::Out > WebSlope;
-		Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
-    };
-
-    // C++ wrapper for IfcTank
-    struct IfcTank : IfcFlowStorageDevice, ObjectHelper<IfcTank,1> { IfcTank() : Object("IfcTank") {}
-		Maybe< IfcTankTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTankType
-    struct IfcTankType : IfcFlowStorageDeviceType, ObjectHelper<IfcTankType,1> { IfcTankType() : Object("IfcTankType") {}
-		IfcTankTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTask
-    struct IfcTask : IfcProcess, ObjectHelper<IfcTask,6> { IfcTask() : Object("IfcTask") {}
-		Maybe< IfcLabel::Out > Status;
-		Maybe< IfcLabel::Out > WorkMethod;
-		IfcBoolean::Out IsMilestone;
-		Maybe< IfcInteger::Out > Priority;
-		Maybe< Lazy< NotImplemented > > TaskTime;
-		Maybe< IfcTaskTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTaskType
-    struct IfcTaskType : IfcTypeProcess, ObjectHelper<IfcTaskType,2> { IfcTaskType() : Object("IfcTaskType") {}
-		IfcTaskTypeEnum::Out PredefinedType;
-		Maybe< IfcLabel::Out > WorkMethod;
-    };
-
-    // C++ wrapper for IfcTendon
-    struct IfcTendon : IfcReinforcingElement, ObjectHelper<IfcTendon,8> { IfcTendon() : Object("IfcTendon") {}
-		Maybe< IfcTendonTypeEnum::Out > PredefinedType;
-		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
-		Maybe< IfcForceMeasure::Out > TensionForce;
-		Maybe< IfcPressureMeasure::Out > PreStress;
-		Maybe< IfcNormalisedRatioMeasure::Out > FrictionCoefficient;
-		Maybe< IfcPositiveLengthMeasure::Out > AnchorageSlip;
-		Maybe< IfcPositiveLengthMeasure::Out > MinCurvatureRadius;
-    };
-
-    // C++ wrapper for IfcTendonAnchor
-    struct IfcTendonAnchor : IfcReinforcingElement, ObjectHelper<IfcTendonAnchor,1> { IfcTendonAnchor() : Object("IfcTendonAnchor") {}
-		Maybe< IfcTendonAnchorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTendonAnchorType
-    struct IfcTendonAnchorType : IfcReinforcingElementType, ObjectHelper<IfcTendonAnchorType,1> { IfcTendonAnchorType() : Object("IfcTendonAnchorType") {}
-		IfcTendonAnchorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTendonType
-    struct IfcTendonType : IfcReinforcingElementType, ObjectHelper<IfcTendonType,4> { IfcTendonType() : Object("IfcTendonType") {}
-		IfcTendonTypeEnum::Out PredefinedType;
-		Maybe< IfcPositiveLengthMeasure::Out > NominalDiameter;
-		Maybe< IfcAreaMeasure::Out > CrossSectionArea;
-		Maybe< IfcPositiveLengthMeasure::Out > SheathDiameter;
-    };
-
-    // C++ wrapper for IfcTextLiteral
-    struct IfcTextLiteral : IfcGeometricRepresentationItem, ObjectHelper<IfcTextLiteral,3> { IfcTextLiteral() : Object("IfcTextLiteral") {}
-		IfcPresentableText::Out Literal;
-		IfcAxis2Placement::Out Placement;
-		IfcTextPath::Out Path;
-    };
-
-    // C++ wrapper for IfcTextLiteralWithExtent
-    struct IfcTextLiteralWithExtent : IfcTextLiteral, ObjectHelper<IfcTextLiteralWithExtent,2> { IfcTextLiteralWithExtent() : Object("IfcTextLiteralWithExtent") {}
-		Lazy< IfcPlanarExtent > Extent;
-		IfcBoxAlignment::Out BoxAlignment;
-    };
-
-    // C++ wrapper for IfcTopologyRepresentation
-    struct IfcTopologyRepresentation : IfcShapeModel, ObjectHelper<IfcTopologyRepresentation,0> { IfcTopologyRepresentation() : Object("IfcTopologyRepresentation") {}
-
-    };
-
-    // C++ wrapper for IfcToroidalSurface
-    struct IfcToroidalSurface : IfcElementarySurface, ObjectHelper<IfcToroidalSurface,2> { IfcToroidalSurface() : Object("IfcToroidalSurface") {}
-		IfcPositiveLengthMeasure::Out MajorRadius;
-		IfcPositiveLengthMeasure::Out MinorRadius;
-    };
-
-    // C++ wrapper for IfcTransformer
-    struct IfcTransformer : IfcEnergyConversionDevice, ObjectHelper<IfcTransformer,1> { IfcTransformer() : Object("IfcTransformer") {}
-		Maybe< IfcTransformerTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTransformerType
-    struct IfcTransformerType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTransformerType,1> { IfcTransformerType() : Object("IfcTransformerType") {}
-		IfcTransformerTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTransportElement
-    struct IfcTransportElement : IfcElement, ObjectHelper<IfcTransportElement,1> { IfcTransportElement() : Object("IfcTransportElement") {}
-		Maybe< IfcTransportElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTransportElementType
-    struct IfcTransportElementType : IfcElementType, ObjectHelper<IfcTransportElementType,1> { IfcTransportElementType() : Object("IfcTransportElementType") {}
-		IfcTransportElementTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcTrapeziumProfileDef
-    struct IfcTrapeziumProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcTrapeziumProfileDef,4> { IfcTrapeziumProfileDef() : Object("IfcTrapeziumProfileDef") {}
-		IfcPositiveLengthMeasure::Out BottomXDim;
-		IfcPositiveLengthMeasure::Out TopXDim;
-		IfcPositiveLengthMeasure::Out YDim;
-		IfcLengthMeasure::Out TopXOffset;
-    };
-
-    // C++ wrapper for IfcTriangulatedFaceSet
-    struct IfcTriangulatedFaceSet : IfcTessellatedFaceSet, ObjectHelper<IfcTriangulatedFaceSet,2> { IfcTriangulatedFaceSet() : Object("IfcTriangulatedFaceSet") {}
-		Maybe< IfcBoolean::Out > Closed;
-		Maybe< ListOf< IfcPositiveInteger, 1, 0 >::Out > PnIndex;
-    };
-
-    // C++ wrapper for IfcTrimmedCurve
-    struct IfcTrimmedCurve : IfcBoundedCurve, ObjectHelper<IfcTrimmedCurve,5> { IfcTrimmedCurve() : Object("IfcTrimmedCurve") {}
-		Lazy< IfcCurve > BasisCurve;
-		ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim1;
-		ListOf< IfcTrimmingSelect, 1, 2 >::Out Trim2;
-		IfcBoolean::Out SenseAgreement;
-		IfcTrimmingPreference::Out MasterRepresentation;
-    };
-
-    // C++ wrapper for IfcTubeBundle
-    struct IfcTubeBundle : IfcEnergyConversionDevice, ObjectHelper<IfcTubeBundle,1> { IfcTubeBundle() : Object("IfcTubeBundle") {}
-		Maybe< IfcTubeBundleTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcTubeBundleType
-    struct IfcTubeBundleType : IfcEnergyConversionDeviceType, ObjectHelper<IfcTubeBundleType,1> { IfcTubeBundleType() : Object("IfcTubeBundleType") {}
-		IfcTubeBundleTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcUShapeProfileDef
-    struct IfcUShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcUShapeProfileDef,7> { IfcUShapeProfileDef() : Object("IfcUShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out Depth;
-		IfcPositiveLengthMeasure::Out FlangeWidth;
-		IfcPositiveLengthMeasure::Out WebThickness;
-		IfcPositiveLengthMeasure::Out FlangeThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
-		Maybe< IfcPlaneAngleMeasure::Out > FlangeSlope;
-    };
-
-    // C++ wrapper for IfcUnitAssignment
-    struct IfcUnitAssignment :  ObjectHelper<IfcUnitAssignment,1> { IfcUnitAssignment() : Object("IfcUnitAssignment") {}
-		ListOf< IfcUnit, 1, 0 >::Out Units;
-    };
-
-    // C++ wrapper for IfcUnitaryControlElement
-    struct IfcUnitaryControlElement : IfcDistributionControlElement, ObjectHelper<IfcUnitaryControlElement,1> { IfcUnitaryControlElement() : Object("IfcUnitaryControlElement") {}
-		Maybe< IfcUnitaryControlElementTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcUnitaryControlElementType
-    struct IfcUnitaryControlElementType : IfcDistributionControlElementType, ObjectHelper<IfcUnitaryControlElementType,1> { IfcUnitaryControlElementType() : Object("IfcUnitaryControlElementType") {}
-		IfcUnitaryControlElementTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcUnitaryEquipment
-    struct IfcUnitaryEquipment : IfcEnergyConversionDevice, ObjectHelper<IfcUnitaryEquipment,1> { IfcUnitaryEquipment() : Object("IfcUnitaryEquipment") {}
-		Maybe< IfcUnitaryEquipmentTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcUnitaryEquipmentType
-    struct IfcUnitaryEquipmentType : IfcEnergyConversionDeviceType, ObjectHelper<IfcUnitaryEquipmentType,1> { IfcUnitaryEquipmentType() : Object("IfcUnitaryEquipmentType") {}
-		IfcUnitaryEquipmentTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcValve
-    struct IfcValve : IfcFlowController, ObjectHelper<IfcValve,1> { IfcValve() : Object("IfcValve") {}
-		Maybe< IfcValveTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcValveType
-    struct IfcValveType : IfcFlowControllerType, ObjectHelper<IfcValveType,1> { IfcValveType() : Object("IfcValveType") {}
-		IfcValveTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcVector
-    struct IfcVector : IfcGeometricRepresentationItem, ObjectHelper<IfcVector,2> { IfcVector() : Object("IfcVector") {}
-		Lazy< IfcDirection > Orientation;
-		IfcLengthMeasure::Out Magnitude;
-    };
-
-    // C++ wrapper for IfcVertex
-    struct IfcVertex : IfcTopologicalRepresentationItem, ObjectHelper<IfcVertex,0> { IfcVertex() : Object("IfcVertex") {}
-
-    };
-
-    // C++ wrapper for IfcVertexLoop
-    struct IfcVertexLoop : IfcLoop, ObjectHelper<IfcVertexLoop,1> { IfcVertexLoop() : Object("IfcVertexLoop") {}
-		Lazy< IfcVertex > LoopVertex;
-    };
-
-    // C++ wrapper for IfcVertexPoint
-    struct IfcVertexPoint : IfcVertex, ObjectHelper<IfcVertexPoint,1> { IfcVertexPoint() : Object("IfcVertexPoint") {}
-		Lazy< IfcPoint > VertexGeometry;
-    };
-
-    // C++ wrapper for IfcVibrationIsolator
-    struct IfcVibrationIsolator : IfcElementComponent, ObjectHelper<IfcVibrationIsolator,1> { IfcVibrationIsolator() : Object("IfcVibrationIsolator") {}
-		Maybe< IfcVibrationIsolatorTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcVibrationIsolatorType
-    struct IfcVibrationIsolatorType : IfcElementComponentType, ObjectHelper<IfcVibrationIsolatorType,1> { IfcVibrationIsolatorType() : Object("IfcVibrationIsolatorType") {}
-		IfcVibrationIsolatorTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcVirtualElement
-    struct IfcVirtualElement : IfcElement, ObjectHelper<IfcVirtualElement,0> { IfcVirtualElement() : Object("IfcVirtualElement") {}
-
-    };
-
-    // C++ wrapper for IfcVoidingFeature
-    struct IfcVoidingFeature : IfcFeatureElementSubtraction, ObjectHelper<IfcVoidingFeature,1> { IfcVoidingFeature() : Object("IfcVoidingFeature") {}
-		Maybe< IfcVoidingFeatureTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcWall
-    struct IfcWall : IfcBuildingElement, ObjectHelper<IfcWall,1> { IfcWall() : Object("IfcWall") {}
-		Maybe< IfcWallTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcWallElementedCase
-    struct IfcWallElementedCase : IfcWall, ObjectHelper<IfcWallElementedCase,0> { IfcWallElementedCase() : Object("IfcWallElementedCase") {}
-
-    };
-
-    // C++ wrapper for IfcWallStandardCase
-    struct IfcWallStandardCase : IfcWall, ObjectHelper<IfcWallStandardCase,0> { IfcWallStandardCase() : Object("IfcWallStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcWallType
-    struct IfcWallType : IfcBuildingElementType, ObjectHelper<IfcWallType,1> { IfcWallType() : Object("IfcWallType") {}
-		IfcWallTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcWasteTerminal
-    struct IfcWasteTerminal : IfcFlowTerminal, ObjectHelper<IfcWasteTerminal,1> { IfcWasteTerminal() : Object("IfcWasteTerminal") {}
-		Maybe< IfcWasteTerminalTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcWasteTerminalType
-    struct IfcWasteTerminalType : IfcFlowTerminalType, ObjectHelper<IfcWasteTerminalType,1> { IfcWasteTerminalType() : Object("IfcWasteTerminalType") {}
-		IfcWasteTerminalTypeEnum::Out PredefinedType;
-    };
-
-    // C++ wrapper for IfcWindow
-    struct IfcWindow : IfcBuildingElement, ObjectHelper<IfcWindow,5> { IfcWindow() : Object("IfcWindow") {}
-		Maybe< IfcPositiveLengthMeasure::Out > OverallHeight;
-		Maybe< IfcPositiveLengthMeasure::Out > OverallWidth;
-		Maybe< IfcWindowTypeEnum::Out > PredefinedType;
-		Maybe< IfcWindowTypePartitioningEnum::Out > PartitioningType;
-		Maybe< IfcLabel::Out > UserDefinedPartitioningType;
-    };
-
-    // C++ wrapper for IfcWindowStandardCase
-    struct IfcWindowStandardCase : IfcWindow, ObjectHelper<IfcWindowStandardCase,0> { IfcWindowStandardCase() : Object("IfcWindowStandardCase") {}
-
-    };
-
-    // C++ wrapper for IfcWindowStyle
-    struct IfcWindowStyle : IfcTypeProduct, ObjectHelper<IfcWindowStyle,4> { IfcWindowStyle() : Object("IfcWindowStyle") {}
-		IfcWindowStyleConstructionEnum::Out ConstructionType;
-		IfcWindowStyleOperationEnum::Out OperationType;
-		IfcBoolean::Out ParameterTakesPrecedence;
-		IfcBoolean::Out Sizeable;
-    };
-
-    // C++ wrapper for IfcWindowType
-    struct IfcWindowType : IfcBuildingElementType, ObjectHelper<IfcWindowType,4> { IfcWindowType() : Object("IfcWindowType") {}
-		IfcWindowTypeEnum::Out PredefinedType;
-		IfcWindowTypePartitioningEnum::Out PartitioningType;
-		Maybe< IfcBoolean::Out > ParameterTakesPrecedence;
-		Maybe< IfcLabel::Out > UserDefinedPartitioningType;
-    };
-
-    // C++ wrapper for IfcWorkCalendar
-    struct IfcWorkCalendar : IfcControl, ObjectHelper<IfcWorkCalendar,3> { IfcWorkCalendar() : Object("IfcWorkCalendar") {}
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > WorkingTimes;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > ExceptionTimes;
-		Maybe< IfcWorkCalendarTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcWorkControl
-    struct IfcWorkControl : IfcControl, ObjectHelper<IfcWorkControl,7> { IfcWorkControl() : Object("IfcWorkControl") {}
-		IfcDateTime::Out CreationDate;
-		Maybe< ListOf< Lazy< NotImplemented >, 1, 0 > > Creators;
-		Maybe< IfcLabel::Out > Purpose;
-		Maybe< IfcDuration::Out > Duration;
-		Maybe< IfcDuration::Out > TotalFloat;
-		IfcDateTime::Out StartTime;
-		Maybe< IfcDateTime::Out > FinishTime;
-    };
-
-    // C++ wrapper for IfcWorkPlan
-    struct IfcWorkPlan : IfcWorkControl, ObjectHelper<IfcWorkPlan,1> { IfcWorkPlan() : Object("IfcWorkPlan") {}
-		Maybe< IfcWorkPlanTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcWorkSchedule
-    struct IfcWorkSchedule : IfcWorkControl, ObjectHelper<IfcWorkSchedule,1> { IfcWorkSchedule() : Object("IfcWorkSchedule") {}
-		Maybe< IfcWorkScheduleTypeEnum::Out > PredefinedType;
-    };
-
-    // C++ wrapper for IfcZShapeProfileDef
-    struct IfcZShapeProfileDef : IfcParameterizedProfileDef, ObjectHelper<IfcZShapeProfileDef,6> { IfcZShapeProfileDef() : Object("IfcZShapeProfileDef") {}
-		IfcPositiveLengthMeasure::Out Depth;
-		IfcPositiveLengthMeasure::Out FlangeWidth;
-		IfcPositiveLengthMeasure::Out WebThickness;
-		IfcPositiveLengthMeasure::Out FlangeThickness;
-		Maybe< IfcNonNegativeLengthMeasure::Out > FilletRadius;
-		Maybe< IfcNonNegativeLengthMeasure::Out > EdgeRadius;
-    };
-
-    // C++ wrapper for IfcZone
-    struct IfcZone : IfcSystem, ObjectHelper<IfcZone,1> { IfcZone() : Object("IfcZone") {}
-		Maybe< IfcLabel::Out > LongName;
-    };
-
-	void GetSchema(EXPRESS::ConversionSchema& out);
-
-} //! IFC
-namespace STEP {
-
-    // ******************************************************************************
-    // Converter stubs
-    // ******************************************************************************
-
-#define DECL_CONV_STUB(type) template <> size_t GenericFill<IFC::type>(const STEP::DB& db, const EXPRESS::LIST& params, IFC::type* in)
-
-    DECL_CONV_STUB( IfcRoot );
-    DECL_CONV_STUB( IfcObjectDefinition );
-    DECL_CONV_STUB( IfcObject );
-    DECL_CONV_STUB( IfcControl );
-    DECL_CONV_STUB( IfcActionRequest );
-    DECL_CONV_STUB( IfcActor );
-    DECL_CONV_STUB( IfcProduct );
-    DECL_CONV_STUB( IfcElement );
-    DECL_CONV_STUB( IfcDistributionElement );
-    DECL_CONV_STUB( IfcDistributionControlElement );
-    DECL_CONV_STUB( IfcActuator );
-    DECL_CONV_STUB( IfcTypeObject );
-    DECL_CONV_STUB( IfcTypeProduct );
-    DECL_CONV_STUB( IfcElementType );
-    DECL_CONV_STUB( IfcDistributionElementType );
-    DECL_CONV_STUB( IfcDistributionControlElementType );
-    DECL_CONV_STUB( IfcActuatorType );
-    DECL_CONV_STUB( IfcRepresentationItem );
-    DECL_CONV_STUB( IfcGeometricRepresentationItem );
-    DECL_CONV_STUB( IfcSolidModel );
-    DECL_CONV_STUB( IfcManifoldSolidBrep );
-    DECL_CONV_STUB( IfcAdvancedBrep );
-    DECL_CONV_STUB( IfcAdvancedBrepWithVoids );
-    DECL_CONV_STUB( IfcTopologicalRepresentationItem );
-    DECL_CONV_STUB( IfcFace );
-    DECL_CONV_STUB( IfcFaceSurface );
-    DECL_CONV_STUB( IfcAdvancedFace );
-    DECL_CONV_STUB( IfcDistributionFlowElement );
-    DECL_CONV_STUB( IfcFlowTerminal );
-    DECL_CONV_STUB( IfcAirTerminal );
-    DECL_CONV_STUB( IfcFlowController );
-    DECL_CONV_STUB( IfcAirTerminalBox );
-    DECL_CONV_STUB( IfcDistributionFlowElementType );
-    DECL_CONV_STUB( IfcFlowControllerType );
-    DECL_CONV_STUB( IfcAirTerminalBoxType );
-    DECL_CONV_STUB( IfcFlowTerminalType );
-    DECL_CONV_STUB( IfcAirTerminalType );
-    DECL_CONV_STUB( IfcEnergyConversionDevice );
-    DECL_CONV_STUB( IfcAirToAirHeatRecovery );
-    DECL_CONV_STUB( IfcEnergyConversionDeviceType );
-    DECL_CONV_STUB( IfcAirToAirHeatRecoveryType );
-    DECL_CONV_STUB( IfcAlarm );
-    DECL_CONV_STUB( IfcAlarmType );
-    DECL_CONV_STUB( IfcAnnotation );
-    DECL_CONV_STUB( IfcAnnotationFillArea );
-    DECL_CONV_STUB( IfcProfileDef );
-    DECL_CONV_STUB( IfcArbitraryClosedProfileDef );
-    DECL_CONV_STUB( IfcArbitraryOpenProfileDef );
-    DECL_CONV_STUB( IfcArbitraryProfileDefWithVoids );
-    DECL_CONV_STUB( IfcGroup );
-    DECL_CONV_STUB( IfcAsset );
-    DECL_CONV_STUB( IfcParameterizedProfileDef );
-    DECL_CONV_STUB( IfcAsymmetricIShapeProfileDef );
-    DECL_CONV_STUB( IfcAudioVisualAppliance );
-    DECL_CONV_STUB( IfcAudioVisualApplianceType );
-    DECL_CONV_STUB( IfcPlacement );
-    DECL_CONV_STUB( IfcAxis1Placement );
-    DECL_CONV_STUB( IfcAxis2Placement2D );
-    DECL_CONV_STUB( IfcAxis2Placement3D );
-    DECL_CONV_STUB( IfcCurve );
-    DECL_CONV_STUB( IfcBoundedCurve );
-    DECL_CONV_STUB( IfcBSplineCurve );
-    DECL_CONV_STUB( IfcBSplineCurveWithKnots );
-    DECL_CONV_STUB( IfcSurface );
-    DECL_CONV_STUB( IfcBoundedSurface );
-    DECL_CONV_STUB( IfcBSplineSurface );
-    DECL_CONV_STUB( IfcBSplineSurfaceWithKnots );
-    DECL_CONV_STUB( IfcBuildingElement );
-    DECL_CONV_STUB( IfcBeam );
-    DECL_CONV_STUB( IfcBeamStandardCase );
-    DECL_CONV_STUB( IfcBuildingElementType );
-    DECL_CONV_STUB( IfcBeamType );
-    DECL_CONV_STUB( IfcPresentationItem );
-    DECL_CONV_STUB( IfcCsgPrimitive3D );
-    DECL_CONV_STUB( IfcBlock );
-    DECL_CONV_STUB( IfcBoiler );
-    DECL_CONV_STUB( IfcBoilerType );
-    DECL_CONV_STUB( IfcBooleanResult );
-    DECL_CONV_STUB( IfcBooleanClippingResult );
-    DECL_CONV_STUB( IfcCompositeCurve );
-    DECL_CONV_STUB( IfcCompositeCurveOnSurface );
-    DECL_CONV_STUB( IfcBoundaryCurve );
-    DECL_CONV_STUB( IfcBoundingBox );
-    DECL_CONV_STUB( IfcHalfSpaceSolid );
-    DECL_CONV_STUB( IfcBoxedHalfSpace );
-    DECL_CONV_STUB( IfcSpatialElement );
-    DECL_CONV_STUB( IfcSpatialStructureElement );
-    DECL_CONV_STUB( IfcBuilding );
-    DECL_CONV_STUB( IfcElementComponent );
-    DECL_CONV_STUB( IfcBuildingElementPart );
-    DECL_CONV_STUB( IfcElementComponentType );
-    DECL_CONV_STUB( IfcBuildingElementPartType );
-    DECL_CONV_STUB( IfcBuildingElementProxy );
-    DECL_CONV_STUB( IfcBuildingElementProxyType );
-    DECL_CONV_STUB( IfcBuildingStorey );
-    DECL_CONV_STUB( IfcSystem );
-    DECL_CONV_STUB( IfcBuildingSystem );
-    DECL_CONV_STUB( IfcBurner );
-    DECL_CONV_STUB( IfcBurnerType );
-    DECL_CONV_STUB( IfcCShapeProfileDef );
-    DECL_CONV_STUB( IfcFlowFitting );
-    DECL_CONV_STUB( IfcCableCarrierFitting );
-    DECL_CONV_STUB( IfcFlowFittingType );
-    DECL_CONV_STUB( IfcCableCarrierFittingType );
-    DECL_CONV_STUB( IfcFlowSegment );
-    DECL_CONV_STUB( IfcCableCarrierSegment );
-    DECL_CONV_STUB( IfcFlowSegmentType );
-    DECL_CONV_STUB( IfcCableCarrierSegmentType );
-    DECL_CONV_STUB( IfcCableFitting );
-    DECL_CONV_STUB( IfcCableFittingType );
-    DECL_CONV_STUB( IfcCableSegment );
-    DECL_CONV_STUB( IfcCableSegmentType );
-    DECL_CONV_STUB( IfcPoint );
-    DECL_CONV_STUB( IfcCartesianPoint );
-    DECL_CONV_STUB( IfcCartesianPointList );
-    DECL_CONV_STUB( IfcCartesianPointList2D );
-    DECL_CONV_STUB( IfcCartesianPointList3D );
-    DECL_CONV_STUB( IfcCartesianTransformationOperator );
-    DECL_CONV_STUB( IfcCartesianTransformationOperator2D );
-    DECL_CONV_STUB( IfcCartesianTransformationOperator2DnonUniform );
-    DECL_CONV_STUB( IfcCartesianTransformationOperator3D );
-    DECL_CONV_STUB( IfcCartesianTransformationOperator3DnonUniform );
-    DECL_CONV_STUB( IfcCenterLineProfileDef );
-    DECL_CONV_STUB( IfcChiller );
-    DECL_CONV_STUB( IfcChillerType );
-    DECL_CONV_STUB( IfcChimney );
-    DECL_CONV_STUB( IfcChimneyType );
-    DECL_CONV_STUB( IfcConic );
-    DECL_CONV_STUB( IfcCircle );
-    DECL_CONV_STUB( IfcCircleProfileDef );
-    DECL_CONV_STUB( IfcCircleHollowProfileDef );
-    DECL_CONV_STUB( IfcCivilElement );
-    DECL_CONV_STUB( IfcCivilElementType );
-    DECL_CONV_STUB( IfcConnectedFaceSet );
-    DECL_CONV_STUB( IfcClosedShell );
-    DECL_CONV_STUB( IfcCoil );
-    DECL_CONV_STUB( IfcCoilType );
-    DECL_CONV_STUB( IfcColourSpecification );
-    DECL_CONV_STUB( IfcColourRgb );
-    DECL_CONV_STUB( IfcColumn );
-    DECL_CONV_STUB( IfcColumnStandardCase );
-    DECL_CONV_STUB( IfcColumnType );
-    DECL_CONV_STUB( IfcCommunicationsAppliance );
-    DECL_CONV_STUB( IfcCommunicationsApplianceType );
-    DECL_CONV_STUB( IfcPropertyAbstraction );
-    DECL_CONV_STUB( IfcProperty );
-    DECL_CONV_STUB( IfcComplexProperty );
-    DECL_CONV_STUB( IfcPropertyDefinition );
-    DECL_CONV_STUB( IfcCompositeCurveSegment );
-    DECL_CONV_STUB( IfcCompositeProfileDef );
-    DECL_CONV_STUB( IfcFlowMovingDevice );
-    DECL_CONV_STUB( IfcCompressor );
-    DECL_CONV_STUB( IfcFlowMovingDeviceType );
-    DECL_CONV_STUB( IfcCompressorType );
-    DECL_CONV_STUB( IfcCondenser );
-    DECL_CONV_STUB( IfcCondenserType );
-    DECL_CONV_STUB( IfcResource );
-    DECL_CONV_STUB( IfcConstructionResource );
-    DECL_CONV_STUB( IfcConstructionEquipmentResource );
-    DECL_CONV_STUB( IfcTypeResource );
-    DECL_CONV_STUB( IfcConstructionResourceType );
-    DECL_CONV_STUB( IfcConstructionEquipmentResourceType );
-    DECL_CONV_STUB( IfcConstructionMaterialResource );
-    DECL_CONV_STUB( IfcConstructionMaterialResourceType );
-    DECL_CONV_STUB( IfcConstructionProductResource );
-    DECL_CONV_STUB( IfcConstructionProductResourceType );
-    DECL_CONV_STUB( IfcContext );
-    DECL_CONV_STUB( IfcNamedUnit );
-    DECL_CONV_STUB( IfcContextDependentUnit );
-    DECL_CONV_STUB( IfcController );
-    DECL_CONV_STUB( IfcControllerType );
-    DECL_CONV_STUB( IfcConversionBasedUnit );
-    DECL_CONV_STUB( IfcConversionBasedUnitWithOffset );
-    DECL_CONV_STUB( IfcCooledBeam );
-    DECL_CONV_STUB( IfcCooledBeamType );
-    DECL_CONV_STUB( IfcCoolingTower );
-    DECL_CONV_STUB( IfcCoolingTowerType );
-    DECL_CONV_STUB( IfcCostItem );
-    DECL_CONV_STUB( IfcCostSchedule );
-    DECL_CONV_STUB( IfcCovering );
-    DECL_CONV_STUB( IfcCoveringType );
-    DECL_CONV_STUB( IfcCrewResource );
-    DECL_CONV_STUB( IfcCrewResourceType );
-    DECL_CONV_STUB( IfcCsgSolid );
-    DECL_CONV_STUB( IfcCurtainWall );
-    DECL_CONV_STUB( IfcCurtainWallType );
-    DECL_CONV_STUB( IfcCurveBoundedPlane );
-    DECL_CONV_STUB( IfcCurveBoundedSurface );
-    DECL_CONV_STUB( IfcPresentationStyle );
-    DECL_CONV_STUB( IfcElementarySurface );
-    DECL_CONV_STUB( IfcCylindricalSurface );
-    DECL_CONV_STUB( IfcDamper );
-    DECL_CONV_STUB( IfcDamperType );
-    DECL_CONV_STUB( IfcDerivedProfileDef );
-    DECL_CONV_STUB( IfcDirection );
-    DECL_CONV_STUB( IfcDiscreteAccessory );
-    DECL_CONV_STUB( IfcDiscreteAccessoryType );
-    DECL_CONV_STUB( IfcDistributionChamberElement );
-    DECL_CONV_STUB( IfcDistributionChamberElementType );
-    DECL_CONV_STUB( IfcDistributionSystem );
-    DECL_CONV_STUB( IfcDistributionCircuit );
-    DECL_CONV_STUB( IfcPort );
-    DECL_CONV_STUB( IfcDistributionPort );
-    DECL_CONV_STUB( IfcDoor );
-    DECL_CONV_STUB( IfcPropertySetDefinition );
-    DECL_CONV_STUB( IfcDoorStandardCase );
-    DECL_CONV_STUB( IfcDoorStyle );
-    DECL_CONV_STUB( IfcDoorType );
-    DECL_CONV_STUB( IfcDuctFitting );
-    DECL_CONV_STUB( IfcDuctFittingType );
-    DECL_CONV_STUB( IfcDuctSegment );
-    DECL_CONV_STUB( IfcDuctSegmentType );
-    DECL_CONV_STUB( IfcFlowTreatmentDevice );
-    DECL_CONV_STUB( IfcDuctSilencer );
-    DECL_CONV_STUB( IfcFlowTreatmentDeviceType );
-    DECL_CONV_STUB( IfcDuctSilencerType );
-    DECL_CONV_STUB( IfcEdge );
-    DECL_CONV_STUB( IfcEdgeCurve );
-    DECL_CONV_STUB( IfcLoop );
-    DECL_CONV_STUB( IfcEdgeLoop );
-    DECL_CONV_STUB( IfcElectricAppliance );
-    DECL_CONV_STUB( IfcElectricApplianceType );
-    DECL_CONV_STUB( IfcElectricDistributionBoard );
-    DECL_CONV_STUB( IfcElectricDistributionBoardType );
-    DECL_CONV_STUB( IfcFlowStorageDevice );
-    DECL_CONV_STUB( IfcElectricFlowStorageDevice );
-    DECL_CONV_STUB( IfcFlowStorageDeviceType );
-    DECL_CONV_STUB( IfcElectricFlowStorageDeviceType );
-    DECL_CONV_STUB( IfcElectricGenerator );
-    DECL_CONV_STUB( IfcElectricGeneratorType );
-    DECL_CONV_STUB( IfcElectricMotor );
-    DECL_CONV_STUB( IfcElectricMotorType );
-    DECL_CONV_STUB( IfcElectricTimeControl );
-    DECL_CONV_STUB( IfcElectricTimeControlType );
-    DECL_CONV_STUB( IfcElementAssembly );
-    DECL_CONV_STUB( IfcElementAssemblyType );
-    DECL_CONV_STUB( IfcQuantitySet );
-    DECL_CONV_STUB( IfcElementQuantity );
-    DECL_CONV_STUB( IfcEllipse );
-    DECL_CONV_STUB( IfcEllipseProfileDef );
-    DECL_CONV_STUB( IfcEngine );
-    DECL_CONV_STUB( IfcEngineType );
-    DECL_CONV_STUB( IfcEvaporativeCooler );
-    DECL_CONV_STUB( IfcEvaporativeCoolerType );
-    DECL_CONV_STUB( IfcEvaporator );
-    DECL_CONV_STUB( IfcEvaporatorType );
-    DECL_CONV_STUB( IfcProcess );
-    DECL_CONV_STUB( IfcEvent );
-    DECL_CONV_STUB( IfcTypeProcess );
-    DECL_CONV_STUB( IfcEventType );
-    DECL_CONV_STUB( IfcExternalSpatialStructureElement );
-    DECL_CONV_STUB( IfcExternalSpatialElement );
-    DECL_CONV_STUB( IfcSweptAreaSolid );
-    DECL_CONV_STUB( IfcExtrudedAreaSolid );
-    DECL_CONV_STUB( IfcExtrudedAreaSolidTapered );
-    DECL_CONV_STUB( IfcFaceBasedSurfaceModel );
-    DECL_CONV_STUB( IfcFaceBound );
-    DECL_CONV_STUB( IfcFaceOuterBound );
-    DECL_CONV_STUB( IfcFacetedBrep );
-    DECL_CONV_STUB( IfcFacetedBrepWithVoids );
-    DECL_CONV_STUB( IfcFan );
-    DECL_CONV_STUB( IfcFanType );
-    DECL_CONV_STUB( IfcFastener );
-    DECL_CONV_STUB( IfcFastenerType );
-    DECL_CONV_STUB( IfcFeatureElement );
-    DECL_CONV_STUB( IfcFeatureElementAddition );
-    DECL_CONV_STUB( IfcFeatureElementSubtraction );
-    DECL_CONV_STUB( IfcFillAreaStyleHatching );
-    DECL_CONV_STUB( IfcFillAreaStyleTiles );
-    DECL_CONV_STUB( IfcFilter );
-    DECL_CONV_STUB( IfcFilterType );
-    DECL_CONV_STUB( IfcFireSuppressionTerminal );
-    DECL_CONV_STUB( IfcFireSuppressionTerminalType );
-    DECL_CONV_STUB( IfcFixedReferenceSweptAreaSolid );
-    DECL_CONV_STUB( IfcFlowInstrument );
-    DECL_CONV_STUB( IfcFlowInstrumentType );
-    DECL_CONV_STUB( IfcFlowMeter );
-    DECL_CONV_STUB( IfcFlowMeterType );
-    DECL_CONV_STUB( IfcFooting );
-    DECL_CONV_STUB( IfcFootingType );
-    DECL_CONV_STUB( IfcFurnishingElement );
-    DECL_CONV_STUB( IfcFurnishingElementType );
-    DECL_CONV_STUB( IfcFurniture );
-    DECL_CONV_STUB( IfcFurnitureType );
-    DECL_CONV_STUB( IfcGeographicElement );
-    DECL_CONV_STUB( IfcGeographicElementType );
-    DECL_CONV_STUB( IfcGeometricSet );
-    DECL_CONV_STUB( IfcGeometricCurveSet );
-    DECL_CONV_STUB( IfcRepresentationContext );
-    DECL_CONV_STUB( IfcGeometricRepresentationContext );
-    DECL_CONV_STUB( IfcGeometricRepresentationSubContext );
-    DECL_CONV_STUB( IfcGrid );
-    DECL_CONV_STUB( IfcObjectPlacement );
-    DECL_CONV_STUB( IfcGridPlacement );
-    DECL_CONV_STUB( IfcHeatExchanger );
-    DECL_CONV_STUB( IfcHeatExchangerType );
-    DECL_CONV_STUB( IfcHumidifier );
-    DECL_CONV_STUB( IfcHumidifierType );
-    DECL_CONV_STUB( IfcIShapeProfileDef );
-    DECL_CONV_STUB( IfcIndexedPolyCurve );
-    DECL_CONV_STUB( IfcTessellatedItem );
-    DECL_CONV_STUB( IfcIndexedPolygonalFace );
-    DECL_CONV_STUB( IfcIndexedPolygonalFaceWithVoids );
-    DECL_CONV_STUB( IfcInterceptor );
-    DECL_CONV_STUB( IfcInterceptorType );
-    DECL_CONV_STUB( IfcSurfaceCurve );
-    DECL_CONV_STUB( IfcIntersectionCurve );
-    DECL_CONV_STUB( IfcInventory );
-    DECL_CONV_STUB( IfcJunctionBox );
-    DECL_CONV_STUB( IfcJunctionBoxType );
-    DECL_CONV_STUB( IfcLShapeProfileDef );
-    DECL_CONV_STUB( IfcLaborResource );
-    DECL_CONV_STUB( IfcLaborResourceType );
-    DECL_CONV_STUB( IfcLamp );
-    DECL_CONV_STUB( IfcLampType );
-    DECL_CONV_STUB( IfcLightFixture );
-    DECL_CONV_STUB( IfcLightFixtureType );
-    DECL_CONV_STUB( IfcLightSource );
-    DECL_CONV_STUB( IfcLightSourceAmbient );
-    DECL_CONV_STUB( IfcLightSourceDirectional );
-    DECL_CONV_STUB( IfcLightSourceGoniometric );
-    DECL_CONV_STUB( IfcLightSourcePositional );
-    DECL_CONV_STUB( IfcLightSourceSpot );
-    DECL_CONV_STUB( IfcLine );
-    DECL_CONV_STUB( IfcLocalPlacement );
-    DECL_CONV_STUB( IfcMappedItem );
-    DECL_CONV_STUB( IfcProductRepresentation );
-    DECL_CONV_STUB( IfcMaterialDefinitionRepresentation );
-    DECL_CONV_STUB( IfcMeasureWithUnit );
-    DECL_CONV_STUB( IfcMechanicalFastener );
-    DECL_CONV_STUB( IfcMechanicalFastenerType );
-    DECL_CONV_STUB( IfcMedicalDevice );
-    DECL_CONV_STUB( IfcMedicalDeviceType );
-    DECL_CONV_STUB( IfcMember );
-    DECL_CONV_STUB( IfcMemberStandardCase );
-    DECL_CONV_STUB( IfcMemberType );
-    DECL_CONV_STUB( IfcMirroredProfileDef );
-    DECL_CONV_STUB( IfcMotorConnection );
-    DECL_CONV_STUB( IfcMotorConnectionType );
-    DECL_CONV_STUB( IfcOccupant );
-    DECL_CONV_STUB( IfcOffsetCurve2D );
-    DECL_CONV_STUB( IfcOffsetCurve3D );
-    DECL_CONV_STUB( IfcOpenShell );
-    DECL_CONV_STUB( IfcOpeningElement );
-    DECL_CONV_STUB( IfcOpeningStandardCase );
-    DECL_CONV_STUB( IfcOrientedEdge );
-    DECL_CONV_STUB( IfcOuterBoundaryCurve );
-    DECL_CONV_STUB( IfcOutlet );
-    DECL_CONV_STUB( IfcOutletType );
-    DECL_CONV_STUB( IfcPath );
-    DECL_CONV_STUB( IfcPcurve );
-    DECL_CONV_STUB( IfcPerformanceHistory );
-    DECL_CONV_STUB( IfcPermit );
-    DECL_CONV_STUB( IfcPile );
-    DECL_CONV_STUB( IfcPileType );
-    DECL_CONV_STUB( IfcPipeFitting );
-    DECL_CONV_STUB( IfcPipeFittingType );
-    DECL_CONV_STUB( IfcPipeSegment );
-    DECL_CONV_STUB( IfcPipeSegmentType );
-    DECL_CONV_STUB( IfcPlanarExtent );
-    DECL_CONV_STUB( IfcPlanarBox );
-    DECL_CONV_STUB( IfcPlane );
-    DECL_CONV_STUB( IfcPlate );
-    DECL_CONV_STUB( IfcPlateStandardCase );
-    DECL_CONV_STUB( IfcPlateType );
-    DECL_CONV_STUB( IfcPointOnCurve );
-    DECL_CONV_STUB( IfcPointOnSurface );
-    DECL_CONV_STUB( IfcPolyLoop );
-    DECL_CONV_STUB( IfcPolygonalBoundedHalfSpace );
-    DECL_CONV_STUB( IfcTessellatedFaceSet );
-    DECL_CONV_STUB( IfcPolygonalFaceSet );
-    DECL_CONV_STUB( IfcPolyline );
-    DECL_CONV_STUB( IfcPresentationStyleAssignment );
-    DECL_CONV_STUB( IfcProcedure );
-    DECL_CONV_STUB( IfcProcedureType );
-    DECL_CONV_STUB( IfcProductDefinitionShape );
-    DECL_CONV_STUB( IfcProject );
-    DECL_CONV_STUB( IfcProjectLibrary );
-    DECL_CONV_STUB( IfcProjectOrder );
-    DECL_CONV_STUB( IfcProjectionElement );
-    DECL_CONV_STUB( IfcSimpleProperty );
-    DECL_CONV_STUB( IfcPropertyBoundedValue );
-    DECL_CONV_STUB( IfcPropertyEnumeratedValue );
-    DECL_CONV_STUB( IfcPropertyListValue );
-    DECL_CONV_STUB( IfcPropertyReferenceValue );
-    DECL_CONV_STUB( IfcPropertySet );
-    DECL_CONV_STUB( IfcPropertySingleValue );
-    DECL_CONV_STUB( IfcPropertyTableValue );
-    DECL_CONV_STUB( IfcProtectiveDevice );
-    DECL_CONV_STUB( IfcProtectiveDeviceTrippingUnit );
-    DECL_CONV_STUB( IfcProtectiveDeviceTrippingUnitType );
-    DECL_CONV_STUB( IfcProtectiveDeviceType );
-    DECL_CONV_STUB( IfcProxy );
-    DECL_CONV_STUB( IfcPump );
-    DECL_CONV_STUB( IfcPumpType );
-    DECL_CONV_STUB( IfcRailing );
-    DECL_CONV_STUB( IfcRailingType );
-    DECL_CONV_STUB( IfcRamp );
-    DECL_CONV_STUB( IfcRampFlight );
-    DECL_CONV_STUB( IfcRampFlightType );
-    DECL_CONV_STUB( IfcRampType );
-    DECL_CONV_STUB( IfcRationalBSplineCurveWithKnots );
-    DECL_CONV_STUB( IfcRationalBSplineSurfaceWithKnots );
-    DECL_CONV_STUB( IfcRectangleProfileDef );
-    DECL_CONV_STUB( IfcRectangleHollowProfileDef );
-    DECL_CONV_STUB( IfcRectangularPyramid );
-    DECL_CONV_STUB( IfcRectangularTrimmedSurface );
-    DECL_CONV_STUB( IfcReinforcingElement );
-    DECL_CONV_STUB( IfcReinforcingBar );
-    DECL_CONV_STUB( IfcReinforcingElementType );
-    DECL_CONV_STUB( IfcReinforcingBarType );
-    DECL_CONV_STUB( IfcReinforcingMesh );
-    DECL_CONV_STUB( IfcReinforcingMeshType );
-    DECL_CONV_STUB( IfcRelationship );
-    DECL_CONV_STUB( IfcRelDecomposes );
-    DECL_CONV_STUB( IfcRelAggregates );
-    DECL_CONV_STUB( IfcRelConnects );
-    DECL_CONV_STUB( IfcRelContainedInSpatialStructure );
-    DECL_CONV_STUB( IfcRelDefines );
-    DECL_CONV_STUB( IfcRelDefinesByProperties );
-    DECL_CONV_STUB( IfcRelFillsElement );
-    DECL_CONV_STUB( IfcRelVoidsElement );
-    DECL_CONV_STUB( IfcReparametrisedCompositeCurveSegment );
-    DECL_CONV_STUB( IfcRepresentation );
-    DECL_CONV_STUB( IfcRepresentationMap );
-    DECL_CONV_STUB( IfcRevolvedAreaSolid );
-    DECL_CONV_STUB( IfcRevolvedAreaSolidTapered );
-    DECL_CONV_STUB( IfcRightCircularCone );
-    DECL_CONV_STUB( IfcRightCircularCylinder );
-    DECL_CONV_STUB( IfcRoof );
-    DECL_CONV_STUB( IfcRoofType );
-    DECL_CONV_STUB( IfcRoundedRectangleProfileDef );
-    DECL_CONV_STUB( IfcSIUnit );
-    DECL_CONV_STUB( IfcSanitaryTerminal );
-    DECL_CONV_STUB( IfcSanitaryTerminalType );
-    DECL_CONV_STUB( IfcSeamCurve );
-    DECL_CONV_STUB( IfcSectionedSpine );
-    DECL_CONV_STUB( IfcSensor );
-    DECL_CONV_STUB( IfcSensorType );
-    DECL_CONV_STUB( IfcShadingDevice );
-    DECL_CONV_STUB( IfcShadingDeviceType );
-    DECL_CONV_STUB( IfcShapeModel );
-    DECL_CONV_STUB( IfcShapeRepresentation );
-    DECL_CONV_STUB( IfcShellBasedSurfaceModel );
-    DECL_CONV_STUB( IfcSite );
-    DECL_CONV_STUB( IfcSlab );
-    DECL_CONV_STUB( IfcSlabElementedCase );
-    DECL_CONV_STUB( IfcSlabStandardCase );
-    DECL_CONV_STUB( IfcSlabType );
-    DECL_CONV_STUB( IfcSolarDevice );
-    DECL_CONV_STUB( IfcSolarDeviceType );
-    DECL_CONV_STUB( IfcSpace );
-    DECL_CONV_STUB( IfcSpaceHeater );
-    DECL_CONV_STUB( IfcSpaceHeaterType );
-    DECL_CONV_STUB( IfcSpatialElementType );
-    DECL_CONV_STUB( IfcSpatialStructureElementType );
-    DECL_CONV_STUB( IfcSpaceType );
-    DECL_CONV_STUB( IfcSpatialZone );
-    DECL_CONV_STUB( IfcSpatialZoneType );
-    DECL_CONV_STUB( IfcSphere );
-    DECL_CONV_STUB( IfcSphericalSurface );
-    DECL_CONV_STUB( IfcStackTerminal );
-    DECL_CONV_STUB( IfcStackTerminalType );
-    DECL_CONV_STUB( IfcStair );
-    DECL_CONV_STUB( IfcStairFlight );
-    DECL_CONV_STUB( IfcStairFlightType );
-    DECL_CONV_STUB( IfcStairType );
-    DECL_CONV_STUB( IfcStructuralActivity );
-    DECL_CONV_STUB( IfcStructuralAction );
-    DECL_CONV_STUB( IfcStructuralAnalysisModel );
-    DECL_CONV_STUB( IfcStructuralItem );
-    DECL_CONV_STUB( IfcStructuralConnection );
-    DECL_CONV_STUB( IfcStructuralCurveAction );
-    DECL_CONV_STUB( IfcStructuralCurveConnection );
-    DECL_CONV_STUB( IfcStructuralMember );
-    DECL_CONV_STUB( IfcStructuralCurveMember );
-    DECL_CONV_STUB( IfcStructuralCurveMemberVarying );
-    DECL_CONV_STUB( IfcStructuralReaction );
-    DECL_CONV_STUB( IfcStructuralCurveReaction );
-    DECL_CONV_STUB( IfcStructuralLinearAction );
-    DECL_CONV_STUB( IfcStructuralLoadGroup );
-    DECL_CONV_STUB( IfcStructuralLoadCase );
-    DECL_CONV_STUB( IfcStructuralSurfaceAction );
-    DECL_CONV_STUB( IfcStructuralPlanarAction );
-    DECL_CONV_STUB( IfcStructuralPointAction );
-    DECL_CONV_STUB( IfcStructuralPointConnection );
-    DECL_CONV_STUB( IfcStructuralPointReaction );
-    DECL_CONV_STUB( IfcStructuralResultGroup );
-    DECL_CONV_STUB( IfcStructuralSurfaceConnection );
-    DECL_CONV_STUB( IfcStructuralSurfaceMember );
-    DECL_CONV_STUB( IfcStructuralSurfaceMemberVarying );
-    DECL_CONV_STUB( IfcStructuralSurfaceReaction );
-    DECL_CONV_STUB( IfcStyleModel );
-    DECL_CONV_STUB( IfcStyledItem );
-    DECL_CONV_STUB( IfcStyledRepresentation );
-    DECL_CONV_STUB( IfcSubContractResource );
-    DECL_CONV_STUB( IfcSubContractResourceType );
-    DECL_CONV_STUB( IfcSubedge );
-    DECL_CONV_STUB( IfcSurfaceCurveSweptAreaSolid );
-    DECL_CONV_STUB( IfcSurfaceFeature );
-    DECL_CONV_STUB( IfcSweptSurface );
-    DECL_CONV_STUB( IfcSurfaceOfLinearExtrusion );
-    DECL_CONV_STUB( IfcSurfaceOfRevolution );
-    DECL_CONV_STUB( IfcSurfaceStyle );
-    DECL_CONV_STUB( IfcSurfaceStyleShading );
-    DECL_CONV_STUB( IfcSurfaceStyleRendering );
-    DECL_CONV_STUB( IfcSurfaceStyleWithTextures );
-    DECL_CONV_STUB( IfcSweptDiskSolid );
-    DECL_CONV_STUB( IfcSweptDiskSolidPolygonal );
-    DECL_CONV_STUB( IfcSwitchingDevice );
-    DECL_CONV_STUB( IfcSwitchingDeviceType );
-    DECL_CONV_STUB( IfcSystemFurnitureElement );
-    DECL_CONV_STUB( IfcSystemFurnitureElementType );
-    DECL_CONV_STUB( IfcTShapeProfileDef );
-    DECL_CONV_STUB( IfcTank );
-    DECL_CONV_STUB( IfcTankType );
-    DECL_CONV_STUB( IfcTask );
-    DECL_CONV_STUB( IfcTaskType );
-    DECL_CONV_STUB( IfcTendon );
-    DECL_CONV_STUB( IfcTendonAnchor );
-    DECL_CONV_STUB( IfcTendonAnchorType );
-    DECL_CONV_STUB( IfcTendonType );
-    DECL_CONV_STUB( IfcTextLiteral );
-    DECL_CONV_STUB( IfcTextLiteralWithExtent );
-    DECL_CONV_STUB( IfcTopologyRepresentation );
-    DECL_CONV_STUB( IfcToroidalSurface );
-    DECL_CONV_STUB( IfcTransformer );
-    DECL_CONV_STUB( IfcTransformerType );
-    DECL_CONV_STUB( IfcTransportElement );
-    DECL_CONV_STUB( IfcTransportElementType );
-    DECL_CONV_STUB( IfcTrapeziumProfileDef );
-    DECL_CONV_STUB( IfcTriangulatedFaceSet );
-    DECL_CONV_STUB( IfcTrimmedCurve );
-    DECL_CONV_STUB( IfcTubeBundle );
-    DECL_CONV_STUB( IfcTubeBundleType );
-    DECL_CONV_STUB( IfcUShapeProfileDef );
-    DECL_CONV_STUB( IfcUnitAssignment );
-    DECL_CONV_STUB( IfcUnitaryControlElement );
-    DECL_CONV_STUB( IfcUnitaryControlElementType );
-    DECL_CONV_STUB( IfcUnitaryEquipment );
-    DECL_CONV_STUB( IfcUnitaryEquipmentType );
-    DECL_CONV_STUB( IfcValve );
-    DECL_CONV_STUB( IfcValveType );
-    DECL_CONV_STUB( IfcVector );
-    DECL_CONV_STUB( IfcVertex );
-    DECL_CONV_STUB( IfcVertexLoop );
-    DECL_CONV_STUB( IfcVertexPoint );
-    DECL_CONV_STUB( IfcVibrationIsolator );
-    DECL_CONV_STUB( IfcVibrationIsolatorType );
-    DECL_CONV_STUB( IfcVirtualElement );
-    DECL_CONV_STUB( IfcVoidingFeature );
-    DECL_CONV_STUB( IfcWall );
-    DECL_CONV_STUB( IfcWallElementedCase );
-    DECL_CONV_STUB( IfcWallStandardCase );
-    DECL_CONV_STUB( IfcWallType );
-    DECL_CONV_STUB( IfcWasteTerminal );
-    DECL_CONV_STUB( IfcWasteTerminalType );
-    DECL_CONV_STUB( IfcWindow );
-    DECL_CONV_STUB( IfcWindowStandardCase );
-    DECL_CONV_STUB( IfcWindowStyle );
-    DECL_CONV_STUB( IfcWindowType );
-    DECL_CONV_STUB( IfcWorkCalendar );
-    DECL_CONV_STUB( IfcWorkControl );
-    DECL_CONV_STUB( IfcWorkPlan );
-    DECL_CONV_STUB( IfcWorkSchedule );
-    DECL_CONV_STUB( IfcZShapeProfileDef );
-    DECL_CONV_STUB( IfcZone );
-
-
-#undef DECL_CONV_STUB
-
-} //! Schema_4
-} //! STEP
-} //! Assimp
-
-#endif // INCLUDED_IFC_READER_GEN_H
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.cpp b/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.cpp
deleted file mode 100644
index 6b378c1..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.cpp
+++ /dev/null
@@ -1,701 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFCUtil.cpp
- *  @brief Implementation of conversion routines for some common Ifc helper entities.
- */
-
-#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-
-#include "AssetLib/IFC/IFCUtil.h"
-#include "Common/PolyTools.h"
-#include "PostProcessing/ProcessHelper.h"
-
-namespace Assimp {
-namespace IFC {
-
-// ------------------------------------------------------------------------------------------------
-void TempOpening::Transform(const IfcMatrix4& mat) {
-    if(profileMesh) {
-        profileMesh->Transform(mat);
-    }
-    if(profileMesh2D) {
-        profileMesh2D->Transform(mat);
-    }
-    extrusionDir *= IfcMatrix3(mat);
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMesh* TempMesh::ToMesh()
-{
-    ai_assert(mVerts.size() == std::accumulate(mVertcnt.begin(),mVertcnt.end(),size_t(0)));
-
-    if (mVerts.empty()) {
-        return nullptr;
-    }
-
-    std::unique_ptr<aiMesh> mesh(new aiMesh());
-
-    // copy vertices
-    mesh->mNumVertices = static_cast<unsigned int>(mVerts.size());
-    mesh->mVertices = new aiVector3D[mesh->mNumVertices];
-    std::copy(mVerts.begin(),mVerts.end(),mesh->mVertices);
-
-    // and build up faces
-    mesh->mNumFaces = static_cast<unsigned int>(mVertcnt.size());
-    mesh->mFaces = new aiFace[mesh->mNumFaces];
-
-    for(unsigned int i = 0,n=0, acc = 0; i < mesh->mNumFaces; ++n) {
-        aiFace& f = mesh->mFaces[i];
-        if (!mVertcnt[n]) {
-            --mesh->mNumFaces;
-            continue;
-        }
-
-        f.mNumIndices = mVertcnt[n];
-        f.mIndices = new unsigned int[f.mNumIndices];
-        for(unsigned int a = 0; a < f.mNumIndices; ++a) {
-            f.mIndices[a] = acc++;
-        }
-
-        ++i;
-    }
-
-    return mesh.release();
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::Clear()
-{
-    mVerts.clear();
-    mVertcnt.clear();
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::Transform(const IfcMatrix4& mat)
-{
-    for(IfcVector3& v : mVerts) {
-        v *= mat;
-    }
-}
-
-// ------------------------------------------------------------------------------
-IfcVector3 TempMesh::Center() const
-{
-    return (mVerts.size() == 0) ? IfcVector3(0.0f, 0.0f, 0.0f) : (std::accumulate(mVerts.begin(),mVerts.end(),IfcVector3()) / static_cast<IfcFloat>(mVerts.size()));
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::Append(const TempMesh& other)
-{
-    mVerts.insert(mVerts.end(),other.mVerts.begin(),other.mVerts.end());
-    mVertcnt.insert(mVertcnt.end(),other.mVertcnt.begin(),other.mVertcnt.end());
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::RemoveDegenerates()
-{
-    // The strategy is simple: walk the mesh and compute normals using
-    // Newell's algorithm. The length of the normals gives the area
-    // of the polygons, which is close to zero for lines.
-
-    std::vector<IfcVector3> normals;
-    ComputePolygonNormals(normals, false);
-
-    bool drop = false;
-    size_t inor = 0;
-
-    std::vector<IfcVector3>::iterator vit = mVerts.begin();
-    for (std::vector<unsigned int>::iterator it = mVertcnt.begin(); it != mVertcnt.end(); ++inor) {
-        const unsigned int pcount = *it;
-
-        if (normals[inor].SquareLength() < 1e-10f) {
-            it = mVertcnt.erase(it);
-            vit = mVerts.erase(vit, vit + pcount);
-
-            drop = true;
-            continue;
-        }
-
-        vit += pcount;
-        ++it;
-    }
-
-    if(drop) {
-        IFCImporter::LogVerboseDebug("removing degenerate faces");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-IfcVector3 TempMesh::ComputePolygonNormal(const IfcVector3* vtcs, size_t cnt, bool normalize)
-{
-    std::vector<IfcFloat> temp((cnt+2)*3);
-    for( size_t vofs = 0, i = 0; vofs < cnt; ++vofs )
-    {
-        const IfcVector3& v = vtcs[vofs];
-        temp[i++] = v.x;
-        temp[i++] = v.y;
-        temp[i++] = v.z;
-    }
-
-    IfcVector3 nor;
-    NewellNormal<3, 3, 3>(nor, static_cast<int>(cnt), &temp[0], &temp[1], &temp[2]);
-    return normalize ? nor.Normalize() : nor;
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::ComputePolygonNormals(std::vector<IfcVector3>& normals,
-    bool normalize,
-    size_t ofs) const
-{
-    size_t max_vcount = 0;
-    std::vector<unsigned int>::const_iterator begin = mVertcnt.begin()+ofs, end = mVertcnt.end(),  iit;
-    for(iit = begin; iit != end; ++iit) {
-        max_vcount = std::max(max_vcount,static_cast<size_t>(*iit));
-    }
-
-    std::vector<IfcFloat> temp((max_vcount+2)*4);
-    normals.reserve( normals.size() + mVertcnt.size()-ofs );
-
-    // `NewellNormal()` currently has a relatively strange interface and need to
-    // re-structure things a bit to meet them.
-    size_t vidx = std::accumulate(mVertcnt.begin(),begin,0);
-    for(iit = begin; iit != end; vidx += *iit++) {
-        if (!*iit) {
-            normals.push_back(IfcVector3());
-            continue;
-        }
-        for(size_t vofs = 0, cnt = 0; vofs < *iit; ++vofs) {
-            const IfcVector3& v = mVerts[vidx+vofs];
-            temp[cnt++] = v.x;
-            temp[cnt++] = v.y;
-            temp[cnt++] = v.z;
-#ifdef ASSIMP_BUILD_DEBUG
-            temp[cnt] = std::numeric_limits<IfcFloat>::quiet_NaN();
-#endif
-            ++cnt;
-        }
-
-        normals.push_back(IfcVector3());
-        NewellNormal<4,4,4>(normals.back(),*iit,&temp[0],&temp[1],&temp[2]);
-    }
-
-    if(normalize) {
-        for(IfcVector3& n : normals) {
-            n.Normalize();
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Compute the normal of the last polygon in the given mesh
-IfcVector3 TempMesh::ComputeLastPolygonNormal(bool normalize) const {
-    return ComputePolygonNormal(&mVerts[mVerts.size() - mVertcnt.back()], mVertcnt.back(), normalize);
-}
-
-struct CompareVector {
-    bool operator () (const IfcVector3& a, const IfcVector3& b) const {
-        IfcVector3 d = a - b;
-        IfcFloat eps = ai_epsilon;
-        return d.x < -eps || (std::abs(d.x) < eps && d.y < -eps) || (std::abs(d.x) < eps && std::abs(d.y) < eps && d.z < -eps);
-    }
-};
-
-struct FindVector {
-    IfcVector3 v;
-    FindVector(const IfcVector3& p) : v(p) { }
-    bool operator()(const IfcVector3 &p) {
-        return FuzzyVectorCompare(ai_epsilon)(p, v);
-    }
-};
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::FixupFaceOrientation()
-{
-    const IfcVector3 vavg = Center();
-
-    // create a list of start indices for all faces to allow random access to faces
-    std::vector<size_t> faceStartIndices(mVertcnt.size());
-    for( size_t i = 0, a = 0; a < mVertcnt.size(); i += mVertcnt[a], ++a )
-        faceStartIndices[a] = i;
-
-    // list all faces on a vertex
-    std::map<IfcVector3, std::vector<size_t>, CompareVector> facesByVertex;
-    for( size_t a = 0; a < mVertcnt.size(); ++a )
-    {
-        for( size_t b = 0; b < mVertcnt[a]; ++b )
-            facesByVertex[mVerts[faceStartIndices[a] + b]].push_back(a);
-    }
-    // determine neighbourhood for all polys
-    std::vector<size_t> neighbour(mVerts.size(), SIZE_MAX);
-    std::vector<size_t> tempIntersect(10);
-    for( size_t a = 0; a < mVertcnt.size(); ++a )
-    {
-        for( size_t b = 0; b < mVertcnt[a]; ++b )
-        {
-            size_t ib = faceStartIndices[a] + b, nib = faceStartIndices[a] + (b + 1) % mVertcnt[a];
-            const std::vector<size_t>& facesOnB = facesByVertex[mVerts[ib]];
-            const std::vector<size_t>& facesOnNB = facesByVertex[mVerts[nib]];
-            // there should be exactly one or two faces which appear in both lists. Our face and the other side
-            std::vector<size_t>::iterator sectstart = tempIntersect.begin();
-            std::vector<size_t>::iterator sectend = std::set_intersection(
-                facesOnB.begin(), facesOnB.end(), facesOnNB.begin(), facesOnNB.end(), sectstart);
-
-            if( std::distance(sectstart, sectend) != 2 )
-                continue;
-            if( *sectstart == a )
-                ++sectstart;
-            neighbour[ib] = *sectstart;
-        }
-    }
-
-    // now we're getting started. We take the face which is the farthest away from the center. This face is most probably
-    // facing outwards. So we reverse this face to point outwards in relation to the center. Then we adapt neighbouring
-    // faces to have the same winding until all faces have been tested.
-    std::vector<bool> faceDone(mVertcnt.size(), false);
-    while( std::count(faceDone.begin(), faceDone.end(), false) != 0 )
-    {
-        // find the farthest of the remaining faces
-        size_t farthestIndex = SIZE_MAX;
-        IfcFloat farthestDistance = -1.0;
-        for( size_t a = 0; a < mVertcnt.size(); ++a )
-        {
-            if( faceDone[a] )
-                continue;
-            IfcVector3 faceCenter = std::accumulate(mVerts.begin() + faceStartIndices[a],
-                mVerts.begin() + faceStartIndices[a] + mVertcnt[a], IfcVector3(0.0)) / IfcFloat(mVertcnt[a]);
-            IfcFloat dst = (faceCenter - vavg).SquareLength();
-            if( dst > farthestDistance ) { farthestDistance = dst; farthestIndex = a; }
-        }
-
-        // calculate its normal and reverse the poly if its facing towards the mesh center
-        IfcVector3 farthestNormal = ComputePolygonNormal(mVerts.data() + faceStartIndices[farthestIndex], mVertcnt[farthestIndex]);
-        IfcVector3 farthestCenter = std::accumulate(mVerts.begin() + faceStartIndices[farthestIndex],
-            mVerts.begin() + faceStartIndices[farthestIndex] + mVertcnt[farthestIndex], IfcVector3(0.0))
-            / IfcFloat(mVertcnt[farthestIndex]);
-        // We accept a bit of negative orientation without reversing. In case of doubt, prefer the orientation given in
-        // the file.
-        if( (farthestNormal * (farthestCenter - vavg).Normalize()) < -0.4 )
-        {
-            size_t fsi = faceStartIndices[farthestIndex], fvc = mVertcnt[farthestIndex];
-            std::reverse(mVerts.begin() + fsi, mVerts.begin() + fsi + fvc);
-            std::reverse(neighbour.begin() + fsi, neighbour.begin() + fsi + fvc);
-            // because of the neighbour index belonging to the edge starting with the point at the same index, we need to
-            // cycle the neighbours through to match the edges again.
-            // Before: points A - B - C - D with edge neighbour p - q - r - s
-            // After: points D - C - B - A, reversed neighbours are s - r - q - p, but the should be
-            //                r   q   p   s
-            for( size_t a = 0; a < fvc - 1; ++a )
-                std::swap(neighbour[fsi + a], neighbour[fsi + a + 1]);
-        }
-        faceDone[farthestIndex] = true;
-        std::vector<size_t> todo;
-        todo.push_back(farthestIndex);
-
-        // go over its neighbour faces recursively and adapt their winding order to match the farthest face
-        while( !todo.empty() )
-        {
-            size_t tdf = todo.back();
-            size_t vsi = faceStartIndices[tdf], vc = mVertcnt[tdf];
-            todo.pop_back();
-
-            // check its neighbours
-            for( size_t a = 0; a < vc; ++a )
-            {
-                // ignore neighbours if we already checked them
-                size_t nbi = neighbour[vsi + a];
-                if( nbi == SIZE_MAX || faceDone[nbi] )
-                    continue;
-
-                const IfcVector3& vp = mVerts[vsi + a];
-                size_t nbvsi = faceStartIndices[nbi], nbvc = mVertcnt[nbi];
-                std::vector<IfcVector3>::iterator it = std::find_if(mVerts.begin() + nbvsi, mVerts.begin() + nbvsi + nbvc, FindVector(vp));
-                ai_assert(it != mVerts.begin() + nbvsi + nbvc);
-                size_t nb_vidx = std::distance(mVerts.begin() + nbvsi, it);
-                // two faces winded in the same direction should have a crossed edge, where one face has p0->p1 and the other
-                // has p1'->p0'. If the next point on the neighbouring face is also the next on the current face, we need
-                // to reverse the neighbour
-                nb_vidx = (nb_vidx + 1) % nbvc;
-                size_t oursideidx = (a + 1) % vc;
-                if (FuzzyVectorCompare(ai_epsilon)(mVerts[vsi + oursideidx], mVerts[nbvsi + nb_vidx])) {
-                    std::reverse(mVerts.begin() + nbvsi, mVerts.begin() + nbvsi + nbvc);
-                    std::reverse(neighbour.begin() + nbvsi, neighbour.begin() + nbvsi + nbvc);
-                    for (size_t aa = 0; aa < nbvc - 1; ++aa) {
-                        std::swap(neighbour[nbvsi + aa], neighbour[nbvsi + aa + 1]);
-                    }
-                }
-
-                // either way we're done with the neighbour. Mark it as done and continue checking from there recursively
-                faceDone[nbi] = true;
-                todo.push_back(nbi);
-            }
-        }
-
-        // no more faces reachable from this part of the surface, start over with a disjunct part and its farthest face
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::RemoveAdjacentDuplicates() {
-    bool drop = false;
-    std::vector<IfcVector3>::iterator base = mVerts.begin();
-    for(unsigned int& cnt : mVertcnt) {
-        if (cnt < 2){
-            base += cnt;
-            continue;
-        }
-
-        IfcVector3 vmin,vmax;
-        ArrayBounds(&*base, cnt ,vmin,vmax);
-
-
-        const IfcFloat epsilon = (vmax-vmin).SquareLength() / static_cast<IfcFloat>(1e9);
-        //const IfcFloat dotepsilon = 1e-9;
-
-        //// look for vertices that lie directly on the line between their predecessor and their
-        //// successor and replace them with either of them.
-
-        //for(size_t i = 0; i < cnt; ++i) {
-        //  IfcVector3& v1 = *(base+i), &v0 = *(base+(i?i-1:cnt-1)), &v2 = *(base+(i+1)%cnt);
-        //  const IfcVector3& d0 = (v1-v0), &d1 = (v2-v1);
-        //  const IfcFloat l0 = d0.SquareLength(), l1 = d1.SquareLength();
-        //  if (!l0 || !l1) {
-        //      continue;
-        //  }
-
-        //  const IfcFloat d = (d0/std::sqrt(l0))*(d1/std::sqrt(l1));
-
-        //  if ( d >= 1.f-dotepsilon ) {
-        //      v1 = v0;
-        //  }
-        //  else if ( d < -1.f+dotepsilon ) {
-        //      v2 = v1;
-        //      continue;
-        //  }
-        //}
-
-        // drop any identical, adjacent vertices. this pass will collect the dropouts
-        // of the previous pass as a side-effect.
-        FuzzyVectorCompare fz(epsilon);
-        std::vector<IfcVector3>::iterator end = base+cnt, e = std::unique( base, end, fz );
-        if (e != end) {
-            cnt -= static_cast<unsigned int>(std::distance(e, end));
-            mVerts.erase(e,end);
-            drop  = true;
-        }
-
-        // check front and back vertices for this polygon
-        if (cnt > 1 && fz(*base,*(base+cnt-1))) {
-            mVerts.erase(base+ --cnt);
-            drop  = true;
-        }
-
-        // removing adjacent duplicates shouldn't erase everything :-)
-        ai_assert(cnt>0);
-        base += cnt;
-    }
-    if(drop) {
-        IFCImporter::LogVerboseDebug("removing duplicate vertices");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void TempMesh::Swap(TempMesh& other)
-{
-    mVertcnt.swap(other.mVertcnt);
-    mVerts.swap(other.mVerts);
-}
-
-// ------------------------------------------------------------------------------------------------
-bool IsTrue(const ::Assimp::STEP::EXPRESS::BOOLEAN& in)
-{
-    return (std::string)in == "TRUE" || (std::string)in == "T";
-}
-
-// ------------------------------------------------------------------------------------------------
-IfcFloat ConvertSIPrefix(const std::string& prefix)
-{
-    if (prefix == "EXA") {
-        return 1e18f;
-    }
-    else if (prefix == "PETA") {
-        return 1e15f;
-    }
-    else if (prefix == "TERA") {
-        return 1e12f;
-    }
-    else if (prefix == "GIGA") {
-        return 1e9f;
-    }
-    else if (prefix == "MEGA") {
-        return 1e6f;
-    }
-    else if (prefix == "KILO") {
-        return 1e3f;
-    }
-    else if (prefix == "HECTO") {
-        return 1e2f;
-    }
-    else if (prefix == "DECA") {
-        return 1e-0f;
-    }
-    else if (prefix == "DECI") {
-        return 1e-1f;
-    }
-    else if (prefix == "CENTI") {
-        return 1e-2f;
-    }
-    else if (prefix == "MILLI") {
-        return 1e-3f;
-    }
-    else if (prefix == "MICRO") {
-        return 1e-6f;
-    }
-    else if (prefix == "NANO") {
-        return 1e-9f;
-    }
-    else if (prefix == "PICO") {
-        return 1e-12f;
-    }
-    else if (prefix == "FEMTO") {
-        return 1e-15f;
-    }
-    else if (prefix == "ATTO") {
-        return 1e-18f;
-    }
-    else {
-        IFCImporter::LogError("Unrecognized SI prefix: ", prefix);
-        return 1;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourRgb& in)
-{
-    out.r = static_cast<float>( in.Red );
-    out.g = static_cast<float>( in.Green );
-    out.b = static_cast<float>( in.Blue );
-    out.a = static_cast<float>( 1.f );
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base)
-{
-    if (const ::Assimp::STEP::EXPRESS::REAL* const r = in.ToPtr<::Assimp::STEP::EXPRESS::REAL>()) {
-        out.r = out.g = out.b = static_cast<float>(*r);
-        if(base) {
-            out.r *= static_cast<float>( base->r );
-            out.g *= static_cast<float>( base->g );
-            out.b *= static_cast<float>( base->b );
-            out.a = static_cast<float>( base->a );
-        }
-        else out.a = 1.0;
-    }
-    else if (const Schema_2x3::IfcColourRgb* const rgb = in.ResolveSelectPtr<Schema_2x3::IfcColourRgb>(conv.db)) {
-        ConvertColor(out,*rgb);
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcColourOrFactor entity");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertCartesianPoint(IfcVector3& out, const Schema_2x3::IfcCartesianPoint& in)
-{
-    out = IfcVector3();
-    for(size_t i = 0; i < in.Coordinates.size(); ++i) {
-        out[static_cast<unsigned int>(i)] = in.Coordinates[i];
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertVector(IfcVector3& out, const Schema_2x3::IfcVector& in)
-{
-    ConvertDirection(out,in.Orientation);
-    out *= in.Magnitude;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertDirection(IfcVector3& out, const Schema_2x3::IfcDirection& in)
-{
-    out = IfcVector3();
-    for(size_t i = 0; i < in.DirectionRatios.size(); ++i) {
-        out[static_cast<unsigned int>(i)] = in.DirectionRatios[i];
-    }
-    const IfcFloat len = out.Length();
-    if (len < ai_epsilon) {
-        IFCImporter::LogWarn("direction vector magnitude too small, normalization would result in a division by zero");
-        return;
-    }
-    out /= len;
-}
-
-// ------------------------------------------------------------------------------------------------
-void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y, const IfcVector3& z)
-{
-    out.a1 = x.x;
-    out.b1 = x.y;
-    out.c1 = x.z;
-
-    out.a2 = y.x;
-    out.b2 = y.y;
-    out.c2 = y.z;
-
-    out.a3 = z.x;
-    out.b3 = z.y;
-    out.c3 = z.z;
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement3D& in)
-{
-    IfcVector3 loc;
-    ConvertCartesianPoint(loc,in.Location);
-
-    IfcVector3 z(0.f,0.f,1.f),r(1.f,0.f,0.f),x;
-
-    if (in.Axis) {
-        ConvertDirection(z,*in.Axis.Get());
-    }
-    if (in.RefDirection) {
-        ConvertDirection(r,*in.RefDirection.Get());
-    }
-
-    IfcVector3 v = r.Normalize();
-    IfcVector3 tmpx = z * (v*z);
-
-    x = (v-tmpx).Normalize();
-    IfcVector3 y = (z^x);
-
-    IfcMatrix4::Translation(loc,out);
-    AssignMatrixAxes(out,x,y,z);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement2D& in)
-{
-    IfcVector3 loc;
-    ConvertCartesianPoint(loc,in.Location);
-
-    IfcVector3 x(1.f,0.f,0.f);
-    if (in.RefDirection) {
-        ConvertDirection(x,*in.RefDirection.Get());
-    }
-
-    const IfcVector3 y = IfcVector3(x.y,-x.x,0.f);
-
-    IfcMatrix4::Translation(loc,out);
-    AssignMatrixAxes(out,x,y,IfcVector3(0.f,0.f,1.f));
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const Schema_2x3::IfcAxis1Placement& in)
-{
-    ConvertCartesianPoint(pos,in.Location);
-    if (in.Axis) {
-        ConvertDirection(axis,in.Axis.Get());
-    }
-    else {
-        axis = IfcVector3(0.f,0.f,1.f);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement& in, ConversionData& conv)
-{
-    if(const Schema_2x3::IfcAxis2Placement3D* pl3 = in.ResolveSelectPtr<Schema_2x3::IfcAxis2Placement3D>(conv.db)) {
-        ConvertAxisPlacement(out,*pl3);
-    }
-    else if(const Schema_2x3::IfcAxis2Placement2D* pl2 = in.ResolveSelectPtr<Schema_2x3::IfcAxis2Placement2D>(conv.db)) {
-        ConvertAxisPlacement(out,*pl2);
-    }
-    else {
-        IFCImporter::LogWarn("skipping unknown IfcAxis2Placement entity");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertTransformOperator(IfcMatrix4& out, const Schema_2x3::IfcCartesianTransformationOperator& op)
-{
-    IfcVector3 loc;
-    ConvertCartesianPoint(loc,op.LocalOrigin);
-
-    IfcVector3 x(1.f,0.f,0.f),y(0.f,1.f,0.f),z(0.f,0.f,1.f);
-    if (op.Axis1) {
-        ConvertDirection(x,*op.Axis1.Get());
-    }
-    if (op.Axis2) {
-        ConvertDirection(y,*op.Axis2.Get());
-    }
-    if (const Schema_2x3::IfcCartesianTransformationOperator3D* op2 = op.ToPtr<Schema_2x3::IfcCartesianTransformationOperator3D>()) {
-        if(op2->Axis3) {
-            ConvertDirection(z,*op2->Axis3.Get());
-        }
-    }
-
-    IfcMatrix4 locm;
-    IfcMatrix4::Translation(loc,locm);
-    AssignMatrixAxes(out,x,y,z);
-
-
-    IfcVector3 vscale;
-    if (const Schema_2x3::IfcCartesianTransformationOperator3DnonUniform* nuni = op.ToPtr<Schema_2x3::IfcCartesianTransformationOperator3DnonUniform>()) {
-        vscale.x = nuni->Scale?op.Scale.Get():1.f;
-        vscale.y = nuni->Scale2?nuni->Scale2.Get():1.f;
-        vscale.z = nuni->Scale3?nuni->Scale3.Get():1.f;
-    }
-    else {
-        const IfcFloat sc = op.Scale?op.Scale.Get():1.f;
-        vscale = IfcVector3(sc,sc,sc);
-    }
-
-    IfcMatrix4 s;
-    IfcMatrix4::Scaling(vscale,s);
-
-    out = locm * out * s;
-}
-
-
-} // ! IFC
-} // ! Assimp
-
-#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.h b/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.h
deleted file mode 100644
index b5f72a5..0000000
--- a/src/mesh/assimp-master/code/AssetLib/IFC/IFCUtil.h
+++ /dev/null
@@ -1,411 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2022, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  IFC.cpp
- *  @brief Implementation of the Industry Foundation Classes loader.
- */
-
-#ifndef INCLUDED_IFCUTIL_H
-#define INCLUDED_IFCUTIL_H
-
-#include "AssetLib/IFC/IFCReaderGen_2x3.h"
-#include "AssetLib/IFC/IFCLoader.h"
-#include "AssetLib/Step/STEPFile.h"
-
-#include <assimp/mesh.h>
-#include <assimp/material.h>
-
-#include <utility>
-
-struct aiNode;
-
-namespace Assimp {
-namespace IFC {
-
-    typedef double IfcFloat;
-
-    // IfcFloat-precision math data types
-    typedef aiVector2t<IfcFloat> IfcVector2;
-    typedef aiVector3t<IfcFloat> IfcVector3;
-    typedef aiMatrix4x4t<IfcFloat> IfcMatrix4;
-    typedef aiMatrix3x3t<IfcFloat> IfcMatrix3;
-    typedef aiColor4t<IfcFloat> IfcColor4;
-
-
-// ------------------------------------------------------------------------------------------------
-// Helper for std::for_each to delete all heap-allocated items in a container
-// ------------------------------------------------------------------------------------------------
-template<typename T>
-struct delete_fun {
-    void operator()(T* del) {
-        delete del;
-    }
-};
-
-
-
-// ------------------------------------------------------------------------------------------------
-// Helper used during mesh construction. Aids at creating aiMesh'es out of relatively few polygons.
-// ------------------------------------------------------------------------------------------------
-struct TempMesh {
-    std::vector<IfcVector3> mVerts;
-    std::vector<unsigned int> mVertcnt;
-
-    // utilities
-    aiMesh* ToMesh();
-    void Clear();
-    void Transform(const IfcMatrix4& mat);
-    IfcVector3 Center() const;
-    void Append(const TempMesh& other);
-    bool IsEmpty() const;
-    void RemoveAdjacentDuplicates();
-    void RemoveDegenerates();
-    void FixupFaceOrientation();
-    static IfcVector3 ComputePolygonNormal(const IfcVector3* vtcs, size_t cnt, bool normalize = true);
-    IfcVector3 ComputeLastPolygonNormal(bool normalize = true) const;
-    void ComputePolygonNormals(std::vector<IfcVector3>& normals, bool normalize = true, size_t ofs = 0) const;
-    void Swap(TempMesh& other);
-};
-
-inline
-bool TempMesh::IsEmpty() const {
-    return mVerts.empty() && mVertcnt.empty();
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Temporary representation of an opening in a wall or a floor
-// ------------------------------------------------------------------------------------------------
-struct TempOpening
-{
-    const IFC::Schema_2x3::IfcSolidModel *solid;
-    IfcVector3 extrusionDir;
-
-    std::shared_ptr<TempMesh> profileMesh;
-    std::shared_ptr<TempMesh> profileMesh2D;
-
-    // list of points generated for this opening. This is used to
-    // create connections between two opposing holes created
-    // from a single opening instance (two because walls tend to
-    // have two sides). If !empty(), the other side of the wall
-    // has already been processed.
-    std::vector<IfcVector3> wallPoints;
-
-    // ------------------------------------------------------------------------------
-    TempOpening()
-        : solid()
-        , extrusionDir()
-        , profileMesh()
-    {
-    }
-
-    // ------------------------------------------------------------------------------
-    TempOpening(const IFC::Schema_2x3::IfcSolidModel *solid, IfcVector3 extrusionDir,
-            std::shared_ptr<TempMesh> profileMesh,
-            std::shared_ptr<TempMesh> profileMesh2D) :
-            solid(solid), extrusionDir(extrusionDir), profileMesh(std::move(profileMesh)), profileMesh2D(std::move(profileMesh2D)) {
-    }
-
-    // ------------------------------------------------------------------------------
-    void Transform(const IfcMatrix4& mat); // defined later since TempMesh is not complete yet
-
-
-
-    // ------------------------------------------------------------------------------
-    // Helper to sort openings by distance from a given base point
-    struct DistanceSorter {
-
-        DistanceSorter(const IfcVector3& base) : base(base) {}
-
-        bool operator () (const TempOpening& a, const TempOpening& b) const {
-            return (a.profileMesh->Center()-base).SquareLength() < (b.profileMesh->Center()-base).SquareLength();
-        }
-
-        IfcVector3 base;
-    };
-};
-
-
-// ------------------------------------------------------------------------------------------------
-// Intermediate data storage during conversion. Keeps everything and a bit more.
-// ------------------------------------------------------------------------------------------------
-struct ConversionData
-{
-    ConversionData(const STEP::DB& db, const IFC::Schema_2x3::IfcProject& proj, aiScene* out,const IFCImporter::Settings& settings)
-        : len_scale(1.0)
-        , angle_scale(-1.0)
-        , db(db)
-        , proj(proj)
-        , out(out)
-        , settings(settings)
-        , apply_openings()
-        , collect_openings()
-    {}
-
-    ~ConversionData() {
-        std::for_each(meshes.begin(),meshes.end(),delete_fun<aiMesh>());
-        std::for_each(materials.begin(),materials.end(),delete_fun<aiMaterial>());
-    }
-
-    IfcFloat len_scale, angle_scale;
-    bool plane_angle_in_radians;
-
-    const STEP::DB& db;
-    const IFC::Schema_2x3::IfcProject& proj;
-    aiScene* out;
-
-    IfcMatrix4 wcs;
-    std::vector<aiMesh*> meshes;
-    std::vector<aiMaterial*> materials;
-
-    struct MeshCacheIndex {
-        const IFC::Schema_2x3::IfcRepresentationItem* item; unsigned int matindex;
-        MeshCacheIndex() : item(nullptr), matindex(0) { }
-        MeshCacheIndex(const IFC::Schema_2x3::IfcRepresentationItem* i, unsigned int mi) : item(i), matindex(mi) { }
-        bool operator == (const MeshCacheIndex& o) const { return item == o.item && matindex == o.matindex; }
-        bool operator < (const MeshCacheIndex& o) const { return item < o.item || (item == o.item && matindex < o.matindex); }
-    };
-    typedef std::map<MeshCacheIndex, std::set<unsigned int> > MeshCache;
-    MeshCache cached_meshes;
-
-    typedef std::map<const IFC::Schema_2x3::IfcSurfaceStyle*, unsigned int> MaterialCache;
-    MaterialCache cached_materials;
-
-    const IFCImporter::Settings& settings;
-
-    // Intermediate arrays used to resolve openings in walls: only one of them
-    // can be given at a time. apply_openings if present if the current element
-    // is a wall and needs its openings to be poured into its geometry while
-    // collect_openings is present only if the current element is an
-    // IfcOpeningElement, for which all the geometry needs to be preserved
-    // for later processing by a parent, which is a wall.
-    std::vector<TempOpening>* apply_openings;
-    std::vector<TempOpening>* collect_openings;
-
-    std::set<uint64_t> already_processed;
-};
-
-
-// ------------------------------------------------------------------------------------------------
-// Binary predicate to compare vectors with a given, quadratic epsilon.
-// ------------------------------------------------------------------------------------------------
-struct FuzzyVectorCompare {
-
-    FuzzyVectorCompare(IfcFloat epsilon) : epsilon(epsilon) {}
-    bool operator()(const IfcVector3& a, const IfcVector3& b) {
-        return std::abs((a-b).SquareLength()) < epsilon;
-    }
-
-    const IfcFloat epsilon;
-};
-
-
-// ------------------------------------------------------------------------------------------------
-// Ordering predicate to totally order R^2 vectors first by x and then by y
-// ------------------------------------------------------------------------------------------------
-struct XYSorter {
-
-    // sort first by X coordinates, then by Y coordinates
-    bool operator () (const IfcVector2&a, const IfcVector2& b) const {
-        if (a.x == b.x) {
-            return a.y < b.y;
-        }
-        return a.x < b.x;
-    }
-};
-
-
-
-// conversion routines for common IFC entities, implemented in IFCUtil.cpp
-void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourRgb& in);
-void ConvertColor(aiColor4D& out, const Schema_2x3::IfcColourOrFactor& in,ConversionData& conv,const aiColor4D* base);
-void ConvertCartesianPoint(IfcVector3& out, const Schema_2x3::IfcCartesianPoint& in);
-void ConvertDirection(IfcVector3& out, const Schema_2x3::IfcDirection& in);
-void ConvertVector(IfcVector3& out, const Schema_2x3::IfcVector& in);
-void AssignMatrixAxes(IfcMatrix4& out, const IfcVector3& x, const IfcVector3& y, const IfcVector3& z);
-void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement3D& in);
-void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement2D& in);
-void ConvertAxisPlacement(IfcVector3& axis, IfcVector3& pos, const IFC::Schema_2x3::IfcAxis1Placement& in);
-void ConvertAxisPlacement(IfcMatrix4& out, const Schema_2x3::IfcAxis2Placement& in, ConversionData& conv);
-void ConvertTransformOperator(IfcMatrix4& out, const Schema_2x3::IfcCartesianTransformationOperator& op);
-bool IsTrue(const Assimp::STEP::EXPRESS::BOOLEAN& in);
-IfcFloat ConvertSIPrefix(const std::string& prefix);
-
-
-// IFCProfile.cpp
-bool ProcessProfile(const Schema_2x3::IfcProfileDef& prof, TempMesh& meshout, ConversionData& conv);
-bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
-
-// IFCMaterial.cpp
-unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionData& conv, bool forceDefaultMat);
-
-// IFCGeometry.cpp
-IfcMatrix3 DerivePlaneCoordinateSpace(const TempMesh& curmesh, bool& ok, IfcVector3& norOut);
-bool ProcessRepresentationItem(const Schema_2x3::IfcRepresentationItem& item, unsigned int matid, std::set<unsigned int>& mesh_indices, ConversionData& conv);
-void AssignAddedMeshes(std::set<unsigned int>& mesh_indices,aiNode* nd,ConversionData& /*conv*/);
-
-void ProcessSweptAreaSolid(const Schema_2x3::IfcSweptAreaSolid& swept, TempMesh& meshout,
-                           ConversionData& conv);
-
-void ProcessExtrudedAreaSolid(const Schema_2x3::IfcExtrudedAreaSolid& solid, TempMesh& result,
-                              ConversionData& conv, bool collect_openings);
-
-// IFCBoolean.cpp
-
-void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv);
-void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs, TempMesh& result,
-                                       const TempMesh& first_operand,
-                                       ConversionData& conv);
-
-void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
-                                                       const TempMesh& first_operand,
-                                                       ConversionData& conv);
-void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid* as, TempMesh& result,
-                                               const TempMesh& first_operand,
-                                               ConversionData& conv);
-
-
-// IFCOpenings.cpp
-
-bool GenerateOpenings(std::vector<TempOpening>& openings,
-                      TempMesh& curmesh,
-                      bool check_intersection,
-                      bool generate_connection_geometry,
-                      const IfcVector3& wall_extrusion_axis = IfcVector3(0,1,0));
-
-
-
-// IFCCurve.cpp
-
-// ------------------------------------------------------------------------------------------------
-// Custom exception for use by members of the Curve class
-// ------------------------------------------------------------------------------------------------
-class CurveError {
-public:
-    CurveError(const std::string& s)
-    : mStr(s) {
-        // empty
-    }
-
-    std::string mStr;
-};
-
-// ------------------------------------------------------------------------------------------------
-// Temporary representation for an arbitrary sub-class of IfcCurve. Used to sample the curves
-// to obtain a list of line segments.
-// ------------------------------------------------------------------------------------------------
-class Curve {
-protected:
-    Curve(const Schema_2x3::IfcCurve& base_entity, ConversionData& conv)
-    : base_entity(base_entity)
-    , conv(conv) {
-        // empty
-    }
-
-public:
-    typedef std::pair<IfcFloat, IfcFloat> ParamRange;
-
-    virtual ~Curve() {}
-
-
-    // check if a curve is closed
-    virtual bool IsClosed() const = 0;
-
-    // evaluate the curve at the given parametric position
-    virtual IfcVector3 Eval(IfcFloat p) const = 0;
-
-    // try to match a point on the curve to a given parameter
-    // for self-intersecting curves, the result is not ambiguous and
-    // it is undefined which parameter is returned.
-    virtual bool ReverseEval(const IfcVector3& val, IfcFloat& paramOut) const;
-
-    // get the range of the curve (both inclusive).
-    // +inf and -inf are valid return values, the curve is not bounded in such a case.
-    virtual std::pair<IfcFloat,IfcFloat> GetParametricRange() const = 0;
-    IfcFloat GetParametricRangeDelta() const;
-
-    // estimate the number of sample points that this curve will require
-    virtual size_t EstimateSampleCount(IfcFloat start,IfcFloat end) const;
-
-    // intelligently sample the curve based on the current settings
-    // and append the result to the mesh
-    virtual void SampleDiscrete(TempMesh& out,IfcFloat start,IfcFloat end) const;
-
-#ifdef ASSIMP_BUILD_DEBUG
-    // check if a particular parameter value lies within the well-defined range
-    bool InRange(IfcFloat) const;
-#endif
-    static Curve* Convert(const IFC::Schema_2x3::IfcCurve&,ConversionData& conv);
-
-protected:
-    const Schema_2x3::IfcCurve& base_entity;
-    ConversionData& conv;
-};
-
-
-// --------------------------------------------------------------------------------
-// A BoundedCurve always holds the invariant that GetParametricRange()
-// never returns infinite values.
-// --------------------------------------------------------------------------------
-class BoundedCurve : public Curve {
-public:
-    BoundedCurve(const Schema_2x3::IfcBoundedCurve& entity, ConversionData& conv)
-        : Curve(entity,conv)
-    {}
-
-public:
-
-    bool IsClosed() const;
-
-public:
-
-    // sample the entire curve
-    void SampleDiscrete(TempMesh& out) const;
-    using Curve::SampleDiscrete;
-};
-
-// IfcProfile.cpp
-bool ProcessCurve(const Schema_2x3::IfcCurve& curve,  TempMesh& meshout, ConversionData& conv);
-}
-}
-
-#endif