1/*
2Open Asset Import Library (ASSIMP)
3----------------------------------------------------------------------
4
5Copyright (c) 2006-2010, ASSIMP Development Team
6All rights reserved.
7
8Redistribution and use of this software in source and binary forms,
9with or without modification, are permitted provided that the
10following conditions are met:
11
12* Redistributions of source code must retain the above
13 copyright notice, this list of conditions and the
14 following disclaimer.
15
16* Redistributions in binary form must reproduce the above
17 copyright notice, this list of conditions and the
18 following disclaimer in the documentation and/or other
19 materials provided with the distribution.
20
21* Neither the name of the ASSIMP team, nor the names of its
22 contributors may be used to endorse or promote products
23 derived from this software without specific prior
24 written permission of the ASSIMP Development Team.
25
26THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37
38----------------------------------------------------------------------
39*/
40
41//#include "AssimpPCH.h"
42#ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
43
44#include "IFCReaderGen.h"
45
46namespace Assimp {
47using namespace IFC;
48
49namespace STEP {
50
51template <> size_t GenericFill<IfcSurfaceStyle>(const DB& db, const LIST& params, IfcSurfaceStyle* in)
52{
53 size_t base = GenericFill(db,params,static_cast<IfcPresentationStyle*>(in));
54 if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcSurfaceStyle"); } do { // convert the 'Side' argument
55 std::shared_ptr<const DataType> arg = params[base++];
56 try { GenericConvert( in->Side, arg, db ); break; }
57 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyle to be a `IfcSurfaceSide`")); }
58 } while(0);
59 do { // convert the 'Styles' argument
60 std::shared_ptr<const DataType> arg = params[ base++ ];
61 try { GenericConvert( in->Styles, arg, db ); break; }
62 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyle to be a `SET [1:5] OF IfcSurfaceStyleElementSelect`")); }
63 } while(0);
64 return base;
65}
66// -----------------------------------------------------------------------------------------------------------
67template <> size_t GenericFill<IfcAnnotationSurface>(const DB& db, const LIST& params, IfcAnnotationSurface* in)
68{
69 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
70// this data structure is not used yet, so there is no code generated to fill its members
71 return base;
72}
73// -----------------------------------------------------------------------------------------------------------
74template <> size_t GenericFill<IfcFlowController>(const DB& db, const LIST& params, IfcFlowController* in)
75{
76 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
77// this data structure is not used yet, so there is no code generated to fill its members
78 return base;
79}
80// -----------------------------------------------------------------------------------------------------------
81template <> size_t GenericFill<IfcBuildingStorey>(const DB& db, const LIST& params, IfcBuildingStorey* in)
82{
83 size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
84// this data structure is not used yet, so there is no code generated to fill its members
85 return base;
86}
87// -----------------------------------------------------------------------------------------------------------
88template <> size_t GenericFill<IfcWorkControl>(const DB& db, const LIST& params, IfcWorkControl* in)
89{
90 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
91// this data structure is not used yet, so there is no code generated to fill its members
92 return base;
93}
94// -----------------------------------------------------------------------------------------------------------
95template <> size_t GenericFill<IfcWorkSchedule>(const DB& db, const LIST& params, IfcWorkSchedule* in)
96{
97 size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
98// this data structure is not used yet, so there is no code generated to fill its members
99 return base;
100}
101// -----------------------------------------------------------------------------------------------------------
102template <> size_t GenericFill<IfcDuctSegmentType>(const DB& db, const LIST& params, IfcDuctSegmentType* in)
103{
104 size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
105// this data structure is not used yet, so there is no code generated to fill its members
106 return base;
107}
108// -----------------------------------------------------------------------------------------------------------
109template <> size_t GenericFill<IfcFace>(const DB& db, const LIST& params, IfcFace* in)
110{
111 size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
112 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFace"); } do { // convert the 'Bounds' argument
113 std::shared_ptr<const DataType> arg = params[base++];
114 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFace,1>::aux_is_derived[0]=true; break; }
115 try { GenericConvert( in->Bounds, arg, db ); break; }
116 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFace to be a `SET [1:?] OF IfcFaceBound`")); }
117 } while(0);
118 return base;
119}
120// -----------------------------------------------------------------------------------------------------------
121template <> size_t GenericFill<IfcStructuralSurfaceMember>(const DB& db, const LIST& params, IfcStructuralSurfaceMember* in)
122{
123 size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
124// this data structure is not used yet, so there is no code generated to fill its members
125 return base;
126}
127// -----------------------------------------------------------------------------------------------------------
128template <> size_t GenericFill<IfcStructuralSurfaceMemberVarying>(const DB& db, const LIST& params, IfcStructuralSurfaceMemberVarying* in)
129{
130 size_t base = GenericFill(db,params,static_cast<IfcStructuralSurfaceMember*>(in));
131// this data structure is not used yet, so there is no code generated to fill its members
132 return base;
133}
134// -----------------------------------------------------------------------------------------------------------
135template <> size_t GenericFill<IfcFaceSurface>(const DB& db, const LIST& params, IfcFaceSurface* in)
136{
137 size_t base = GenericFill(db,params,static_cast<IfcFace*>(in));
138// this data structure is not used yet, so there is no code generated to fill its members
139 return base;
140}
141// -----------------------------------------------------------------------------------------------------------
142template <> size_t GenericFill<IfcCostSchedule>(const DB& db, const LIST& params, IfcCostSchedule* in)
143{
144 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
145// this data structure is not used yet, so there is no code generated to fill its members
146 return base;
147}
148// -----------------------------------------------------------------------------------------------------------
149template <> size_t GenericFill<IfcPlanarExtent>(const DB& db, const LIST& params, IfcPlanarExtent* in)
150{
151 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
152// this data structure is not used yet, so there is no code generated to fill its members
153 return base;
154}
155// -----------------------------------------------------------------------------------------------------------
156template <> size_t GenericFill<IfcPlanarBox>(const DB& db, const LIST& params, IfcPlanarBox* in)
157{
158 size_t base = GenericFill(db,params,static_cast<IfcPlanarExtent*>(in));
159// this data structure is not used yet, so there is no code generated to fill its members
160 return base;
161}
162// -----------------------------------------------------------------------------------------------------------
163template <> size_t GenericFill<IfcColourSpecification>(const DB& db, const LIST& params, IfcColourSpecification* in)
164{
165 size_t base = 0;
166 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcColourSpecification"); } do { // convert the 'Name' argument
167 std::shared_ptr<const DataType> arg = params[base++];
168 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcColourSpecification,1>::aux_is_derived[0]=true; break; }
169 if (dynamic_cast<const UNSET*>(&*arg)) break;
170 try { GenericConvert( in->Name, arg, db ); break; }
171 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcColourSpecification to be a `IfcLabel`")); }
172 } while(0);
173 return base;
174}
175// -----------------------------------------------------------------------------------------------------------
176template <> size_t GenericFill<IfcVector>(const DB& db, const LIST& params, IfcVector* in)
177{
178 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
179 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcVector"); } do { // convert the 'Orientation' argument
180 std::shared_ptr<const DataType> arg = params[base++];
181 try { GenericConvert( in->Orientation, arg, db ); break; }
182 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcVector to be a `IfcDirection`")); }
183 } while(0);
184 do { // convert the 'Magnitude' argument
185 std::shared_ptr<const DataType> arg = params[base++];
186 try { GenericConvert( in->Magnitude, arg, db ); break; }
187 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcVector to be a `IfcLengthMeasure`")); }
188 } while(0);
189 return base;
190}
191// -----------------------------------------------------------------------------------------------------------
192template <> size_t GenericFill<IfcBeam>(const DB& db, const LIST& params, IfcBeam* in)
193{
194 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
195// this data structure is not used yet, so there is no code generated to fill its members
196 return base;
197}
198// -----------------------------------------------------------------------------------------------------------
199template <> size_t GenericFill<IfcColourRgb>(const DB& db, const LIST& params, IfcColourRgb* in)
200{
201 size_t base = GenericFill(db,params,static_cast<IfcColourSpecification*>(in));
202 if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcColourRgb"); } do { // convert the 'Red' argument
203 std::shared_ptr<const DataType> arg = params[base++];
204 try { GenericConvert( in->Red, arg, db ); break; }
205 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
206 } while(0);
207 do { // convert the 'Green' argument
208 std::shared_ptr<const DataType> arg = params[base++];
209 try { GenericConvert( in->Green, arg, db ); break; }
210 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
211 } while(0);
212 do { // convert the 'Blue' argument
213 std::shared_ptr<const DataType> arg = params[base++];
214 try { GenericConvert( in->Blue, arg, db ); break; }
215 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcColourRgb to be a `IfcNormalisedRatioMeasure`")); }
216 } while(0);
217 return base;
218}
219// -----------------------------------------------------------------------------------------------------------
220template <> size_t GenericFill<IfcStructuralPlanarAction>(const DB& db, const LIST& params, IfcStructuralPlanarAction* in)
221{
222 size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
223// this data structure is not used yet, so there is no code generated to fill its members
224 return base;
225}
226// -----------------------------------------------------------------------------------------------------------
227template <> size_t GenericFill<IfcStructuralPlanarActionVarying>(const DB& db, const LIST& params, IfcStructuralPlanarActionVarying* in)
228{
229 size_t base = GenericFill(db,params,static_cast<IfcStructuralPlanarAction*>(in));
230// this data structure is not used yet, so there is no code generated to fill its members
231 return base;
232}
233// -----------------------------------------------------------------------------------------------------------
234template <> size_t GenericFill<IfcSite>(const DB& db, const LIST& params, IfcSite* in)
235{
236 size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
237 if (params.GetSize() < 14) { throw STEP::TypeError("expected 14 arguments to IfcSite"); } do { // convert the 'RefLatitude' argument
238 std::shared_ptr<const DataType> arg = params[base++];
239 if (dynamic_cast<const UNSET*>(&*arg)) break;
240 try { GenericConvert( in->RefLatitude, arg, db ); break; }
241 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
242 } while(0);
243 do { // convert the 'RefLongitude' argument
244 std::shared_ptr<const DataType> arg = params[base++];
245 if (dynamic_cast<const UNSET*>(&*arg)) break;
246 try { GenericConvert( in->RefLongitude, arg, db ); break; }
247 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSite to be a `IfcCompoundPlaneAngleMeasure`")); }
248 } while(0);
249 do { // convert the 'RefElevation' argument
250 std::shared_ptr<const DataType> arg = params[base++];
251 if (dynamic_cast<const UNSET*>(&*arg)) break;
252 try { GenericConvert( in->RefElevation, arg, db ); break; }
253 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 11 to IfcSite to be a `IfcLengthMeasure`")); }
254 } while(0);
255 do { // convert the 'LandTitleNumber' argument
256 std::shared_ptr<const DataType> arg = params[base++];
257 if (dynamic_cast<const UNSET*>(&*arg)) break;
258 try { GenericConvert( in->LandTitleNumber, arg, db ); break; }
259 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 12 to IfcSite to be a `IfcLabel`")); }
260 } while(0);
261 do { // convert the 'SiteAddress' argument
262 std::shared_ptr<const DataType> arg = params[base++];
263 if (dynamic_cast<const UNSET*>(&*arg)) break;
264 try { GenericConvert( in->SiteAddress, arg, db ); break; }
265 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 13 to IfcSite to be a `IfcPostalAddress`")); }
266 } while(0);
267 return base;
268}
269// -----------------------------------------------------------------------------------------------------------
270template <> size_t GenericFill<IfcDiscreteAccessoryType>(const DB& db, const LIST& params, IfcDiscreteAccessoryType* in)
271{
272 size_t base = GenericFill(db,params,static_cast<IfcElementComponentType*>(in));
273// this data structure is not used yet, so there is no code generated to fill its members
274 return base;
275}
276// -----------------------------------------------------------------------------------------------------------
277template <> size_t GenericFill<IfcVibrationIsolatorType>(const DB& db, const LIST& params, IfcVibrationIsolatorType* in)
278{
279 size_t base = GenericFill(db,params,static_cast<IfcDiscreteAccessoryType*>(in));
280// this data structure is not used yet, so there is no code generated to fill its members
281 return base;
282}
283// -----------------------------------------------------------------------------------------------------------
284template <> size_t GenericFill<IfcEvaporativeCoolerType>(const DB& db, const LIST& params, IfcEvaporativeCoolerType* in)
285{
286 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
287// this data structure is not used yet, so there is no code generated to fill its members
288 return base;
289}
290// -----------------------------------------------------------------------------------------------------------
291template <> size_t GenericFill<IfcDistributionChamberElementType>(const DB& db, const LIST& params, IfcDistributionChamberElementType* in)
292{
293 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
294// this data structure is not used yet, so there is no code generated to fill its members
295 return base;
296}
297// -----------------------------------------------------------------------------------------------------------
298template <> size_t GenericFill<IfcFeatureElementAddition>(const DB& db, const LIST& params, IfcFeatureElementAddition* in)
299{
300 size_t base = GenericFill(db,params,static_cast<IfcFeatureElement*>(in));
301// this data structure is not used yet, so there is no code generated to fill its members
302 return base;
303}
304// -----------------------------------------------------------------------------------------------------------
305template <> size_t GenericFill<IfcStructuredDimensionCallout>(const DB& db, const LIST& params, IfcStructuredDimensionCallout* in)
306{
307 size_t base = GenericFill(db,params,static_cast<IfcDraughtingCallout*>(in));
308// this data structure is not used yet, so there is no code generated to fill its members
309 return base;
310}
311// -----------------------------------------------------------------------------------------------------------
312template <> size_t GenericFill<IfcCoolingTowerType>(const DB& db, const LIST& params, IfcCoolingTowerType* in)
313{
314 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
315// this data structure is not used yet, so there is no code generated to fill its members
316 return base;
317}
318// -----------------------------------------------------------------------------------------------------------
319template <> size_t GenericFill<IfcCenterLineProfileDef>(const DB& db, const LIST& params, IfcCenterLineProfileDef* in)
320{
321 size_t base = GenericFill(db,params,static_cast<IfcArbitraryOpenProfileDef*>(in));
322// this data structure is not used yet, so there is no code generated to fill its members
323 return base;
324}
325// -----------------------------------------------------------------------------------------------------------
326template <> size_t GenericFill<IfcWindowStyle>(const DB& db, const LIST& params, IfcWindowStyle* in)
327{
328 size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
329// this data structure is not used yet, so there is no code generated to fill its members
330 return base;
331}
332// -----------------------------------------------------------------------------------------------------------
333template <> size_t GenericFill<IfcLightSourceGoniometric>(const DB& db, const LIST& params, IfcLightSourceGoniometric* in)
334{
335 size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
336// this data structure is not used yet, so there is no code generated to fill its members
337 return base;
338}
339// -----------------------------------------------------------------------------------------------------------
340template <> size_t GenericFill<IfcTransformerType>(const DB& db, const LIST& params, IfcTransformerType* in)
341{
342 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
343// this data structure is not used yet, so there is no code generated to fill its members
344 return base;
345}
346// -----------------------------------------------------------------------------------------------------------
347template <> size_t GenericFill<IfcMemberType>(const DB& db, const LIST& params, IfcMemberType* in)
348{
349 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
350// this data structure is not used yet, so there is no code generated to fill its members
351 return base;
352}
353// -----------------------------------------------------------------------------------------------------------
354template <> size_t GenericFill<IfcSurfaceOfLinearExtrusion>(const DB& db, const LIST& params, IfcSurfaceOfLinearExtrusion* in)
355{
356 size_t base = GenericFill(db,params,static_cast<IfcSweptSurface*>(in));
357// this data structure is not used yet, so there is no code generated to fill its members
358 return base;
359}
360// -----------------------------------------------------------------------------------------------------------
361template <> size_t GenericFill<IfcMotorConnectionType>(const DB& db, const LIST& params, IfcMotorConnectionType* in)
362{
363 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
364// this data structure is not used yet, so there is no code generated to fill its members
365 return base;
366}
367// -----------------------------------------------------------------------------------------------------------
368template <> size_t GenericFill<IfcFlowTreatmentDeviceType>(const DB& db, const LIST& params, IfcFlowTreatmentDeviceType* in)
369{
370 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
371// this data structure is not used yet, so there is no code generated to fill its members
372 return base;
373}
374// -----------------------------------------------------------------------------------------------------------
375template <> size_t GenericFill<IfcDuctSilencerType>(const DB& db, const LIST& params, IfcDuctSilencerType* in)
376{
377 size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
378// this data structure is not used yet, so there is no code generated to fill its members
379 return base;
380}
381// -----------------------------------------------------------------------------------------------------------
382template <> size_t GenericFill<IfcFurnishingElementType>(const DB& db, const LIST& params, IfcFurnishingElementType* in)
383{
384 size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
385// this data structure is not used yet, so there is no code generated to fill its members
386 return base;
387}
388// -----------------------------------------------------------------------------------------------------------
389template <> size_t GenericFill<IfcSystemFurnitureElementType>(const DB& db, const LIST& params, IfcSystemFurnitureElementType* in)
390{
391 size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
392// this data structure is not used yet, so there is no code generated to fill its members
393 return base;
394}
395// -----------------------------------------------------------------------------------------------------------
396template <> size_t GenericFill<IfcWasteTerminalType>(const DB& db, const LIST& params, IfcWasteTerminalType* in)
397{
398 size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
399// this data structure is not used yet, so there is no code generated to fill its members
400 return base;
401}
402// -----------------------------------------------------------------------------------------------------------
403template <> size_t GenericFill<IfcBSplineCurve>(const DB& db, const LIST& params, IfcBSplineCurve* in)
404{
405 size_t base = GenericFill(db,params,static_cast<IfcBoundedCurve*>(in));
406 if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcBSplineCurve"); } do { // convert the 'Degree' argument
407 std::shared_ptr<const DataType> arg = params[base++];
408 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[0]=true; break; }
409 try { GenericConvert( in->Degree, arg, db ); break; }
410 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBSplineCurve to be a `INTEGER`")); }
411 } while(0);
412 do { // convert the 'ControlPointsList' argument
413 std::shared_ptr<const DataType> arg = params[base++];
414 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[1]=true; break; }
415 try { GenericConvert( in->ControlPointsList, arg, db ); break; }
416 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBSplineCurve to be a `LIST [2:?] OF IfcCartesianPoint`")); }
417 } while(0);
418 do { // convert the 'CurveForm' argument
419 std::shared_ptr<const DataType> arg = params[base++];
420 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[2]=true; break; }
421 try { GenericConvert( in->CurveForm, arg, db ); break; }
422 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBSplineCurve to be a `IfcBSplineCurveForm`")); }
423 } while(0);
424 do { // convert the 'ClosedCurve' argument
425 std::shared_ptr<const DataType> arg = params[base++];
426 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[3]=true; break; }
427 try { GenericConvert( in->ClosedCurve, arg, db ); break; }
428 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBSplineCurve to be a `LOGICAL`")); }
429 } while(0);
430 do { // convert the 'SelfIntersect' argument
431 std::shared_ptr<const DataType> arg = params[base++];
432 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcBSplineCurve,5>::aux_is_derived[4]=true; break; }
433 try { GenericConvert( in->SelfIntersect, arg, db ); break; }
434 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcBSplineCurve to be a `LOGICAL`")); }
435 } while(0);
436 return base;
437}
438// -----------------------------------------------------------------------------------------------------------
439template <> size_t GenericFill<IfcBezierCurve>(const DB& db, const LIST& params, IfcBezierCurve* in)
440{
441 size_t base = GenericFill(db,params,static_cast<IfcBSplineCurve*>(in));
442// this data structure is not used yet, so there is no code generated to fill its members
443 return base;
444}
445// -----------------------------------------------------------------------------------------------------------
446template <> size_t GenericFill<IfcActuatorType>(const DB& db, const LIST& params, IfcActuatorType* in)
447{
448 size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
449// this data structure is not used yet, so there is no code generated to fill its members
450 return base;
451}
452// -----------------------------------------------------------------------------------------------------------
453template <> size_t GenericFill<IfcDistributionControlElement>(const DB& db, const LIST& params, IfcDistributionControlElement* in)
454{
455 size_t base = GenericFill(db,params,static_cast<IfcDistributionElement*>(in));
456// this data structure is not used yet, so there is no code generated to fill its members
457 return base;
458}
459// -----------------------------------------------------------------------------------------------------------
460template <> size_t GenericFill<IfcAnnotation>(const DB& db, const LIST& params, IfcAnnotation* in)
461{
462 size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
463 if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcAnnotation"); } return base;
464}
465// -----------------------------------------------------------------------------------------------------------
466template <> size_t GenericFill<IfcShellBasedSurfaceModel>(const DB& db, const LIST& params, IfcShellBasedSurfaceModel* in)
467{
468 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
469 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcShellBasedSurfaceModel"); } do { // convert the 'SbsmBoundary' argument
470 std::shared_ptr<const DataType> arg = params[base++];
471 try { GenericConvert( in->SbsmBoundary, arg, db ); break; }
472 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcShellBasedSurfaceModel to be a `SET [1:?] OF IfcShell`")); }
473 } while(0);
474 return base;
475}
476// -----------------------------------------------------------------------------------------------------------
477template <> size_t GenericFill<IfcActionRequest>(const DB& db, const LIST& params, IfcActionRequest* in)
478{
479 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
480// this data structure is not used yet, so there is no code generated to fill its members
481 return base;
482}
483// -----------------------------------------------------------------------------------------------------------
484template <> size_t GenericFill<IfcExtrudedAreaSolid>(const DB& db, const LIST& params, IfcExtrudedAreaSolid* in)
485{
486 size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
487 if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcExtrudedAreaSolid"); } do { // convert the 'ExtrudedDirection' argument
488 std::shared_ptr<const DataType> arg = params[base++];
489 try { GenericConvert( in->ExtrudedDirection, arg, db ); break; }
490 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcExtrudedAreaSolid to be a `IfcDirection`")); }
491 } while(0);
492 do { // convert the 'Depth' argument
493 std::shared_ptr<const DataType> arg = params[base++];
494 try { GenericConvert( in->Depth, arg, db ); break; }
495 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcExtrudedAreaSolid to be a `IfcPositiveLengthMeasure`")); }
496 } while(0);
497 return base;
498}
499// -----------------------------------------------------------------------------------------------------------
500template <> size_t GenericFill<IfcSystem>(const DB& db, const LIST& params, IfcSystem* in)
501{
502 size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
503// this data structure is not used yet, so there is no code generated to fill its members
504 return base;
505}
506// -----------------------------------------------------------------------------------------------------------
507template <> size_t GenericFill<IfcFillAreaStyleHatching>(const DB& db, const LIST& params, IfcFillAreaStyleHatching* in)
508{
509 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
510// this data structure is not used yet, so there is no code generated to fill its members
511 return base;
512}
513// -----------------------------------------------------------------------------------------------------------
514template <> size_t GenericFill<IfcRelVoidsElement>(const DB& db, const LIST& params, IfcRelVoidsElement* in)
515{
516 size_t base = GenericFill(db,params,static_cast<IfcRelConnects*>(in));
517 if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelVoidsElement"); } do { // convert the 'RelatingBuildingElement' argument
518 std::shared_ptr<const DataType> arg = params[base++];
519 try { GenericConvert( in->RelatingBuildingElement, arg, db ); break; }
520 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcRelVoidsElement to be a `IfcElement`")); }
521 } while(0);
522 do { // convert the 'RelatedOpeningElement' argument
523 std::shared_ptr<const DataType> arg = params[base++];
524 try { GenericConvert( in->RelatedOpeningElement, arg, db ); break; }
525 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcRelVoidsElement to be a `IfcFeatureElementSubtraction`")); }
526 } while(0);
527 return base;
528}
529// -----------------------------------------------------------------------------------------------------------
530template <> size_t GenericFill<IfcSurfaceCurveSweptAreaSolid>(const DB& db, const LIST& params, IfcSurfaceCurveSweptAreaSolid* in)
531{
532 size_t base = GenericFill(db,params,static_cast<IfcSweptAreaSolid*>(in));
533// this data structure is not used yet, so there is no code generated to fill its members
534 return base;
535}
536// -----------------------------------------------------------------------------------------------------------
537template <> size_t GenericFill<IfcCartesianTransformationOperator3DnonUniform>(const DB& db, const LIST& params, IfcCartesianTransformationOperator3DnonUniform* in)
538{
539 size_t base = GenericFill(db,params,static_cast<IfcCartesianTransformationOperator3D*>(in));
540 if (params.GetSize() < 7) { throw STEP::TypeError("expected 7 arguments to IfcCartesianTransformationOperator3DnonUniform"); } do { // convert the 'Scale2' argument
541 std::shared_ptr<const DataType> arg = params[base++];
542 if (dynamic_cast<const UNSET*>(&*arg)) break;
543 try { GenericConvert( in->Scale2, arg, db ); break; }
544 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
545 } while(0);
546 do { // convert the 'Scale3' argument
547 std::shared_ptr<const DataType> arg = params[base++];
548 if (dynamic_cast<const UNSET*>(&*arg)) break;
549 try { GenericConvert( in->Scale3, arg, db ); break; }
550 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcCartesianTransformationOperator3DnonUniform to be a `REAL`")); }
551 } while(0);
552 return base;
553}
554// -----------------------------------------------------------------------------------------------------------
555template <> size_t GenericFill<IfcCurtainWallType>(const DB& db, const LIST& params, IfcCurtainWallType* in)
556{
557 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
558// this data structure is not used yet, so there is no code generated to fill its members
559 return base;
560}
561// -----------------------------------------------------------------------------------------------------------
562template <> size_t GenericFill<IfcEquipmentStandard>(const DB& db, const LIST& params, IfcEquipmentStandard* in)
563{
564 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
565// this data structure is not used yet, so there is no code generated to fill its members
566 return base;
567}
568// -----------------------------------------------------------------------------------------------------------
569template <> size_t GenericFill<IfcFlowStorageDeviceType>(const DB& db, const LIST& params, IfcFlowStorageDeviceType* in)
570{
571 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElementType*>(in));
572// this data structure is not used yet, so there is no code generated to fill its members
573 return base;
574}
575// -----------------------------------------------------------------------------------------------------------
576template <> size_t GenericFill<IfcDiameterDimension>(const DB& db, const LIST& params, IfcDiameterDimension* in)
577{
578 size_t base = GenericFill(db,params,static_cast<IfcDimensionCurveDirectedCallout*>(in));
579// this data structure is not used yet, so there is no code generated to fill its members
580 return base;
581}
582// -----------------------------------------------------------------------------------------------------------
583template <> size_t GenericFill<IfcSwitchingDeviceType>(const DB& db, const LIST& params, IfcSwitchingDeviceType* in)
584{
585 size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
586// this data structure is not used yet, so there is no code generated to fill its members
587 return base;
588}
589// -----------------------------------------------------------------------------------------------------------
590template <> size_t GenericFill<IfcWindow>(const DB& db, const LIST& params, IfcWindow* in)
591{
592 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
593// this data structure is not used yet, so there is no code generated to fill its members
594 return base;
595}
596// -----------------------------------------------------------------------------------------------------------
597template <> size_t GenericFill<IfcFlowTreatmentDevice>(const DB& db, const LIST& params, IfcFlowTreatmentDevice* in)
598{
599 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
600// this data structure is not used yet, so there is no code generated to fill its members
601 return base;
602}
603// -----------------------------------------------------------------------------------------------------------
604template <> size_t GenericFill<IfcChillerType>(const DB& db, const LIST& params, IfcChillerType* in)
605{
606 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
607// this data structure is not used yet, so there is no code generated to fill its members
608 return base;
609}
610// -----------------------------------------------------------------------------------------------------------
611template <> size_t GenericFill<IfcRectangleHollowProfileDef>(const DB& db, const LIST& params, IfcRectangleHollowProfileDef* in)
612{
613 size_t base = GenericFill(db,params,static_cast<IfcRectangleProfileDef*>(in));
614// this data structure is not used yet, so there is no code generated to fill its members
615 return base;
616}
617// -----------------------------------------------------------------------------------------------------------
618template <> size_t GenericFill<IfcBoxedHalfSpace>(const DB& db, const LIST& params, IfcBoxedHalfSpace* in)
619{
620 size_t base = GenericFill(db,params,static_cast<IfcHalfSpaceSolid*>(in));
621// this data structure is not used yet, so there is no code generated to fill its members
622 return base;
623}
624// -----------------------------------------------------------------------------------------------------------
625template <> size_t GenericFill<IfcAxis2Placement2D>(const DB& db, const LIST& params, IfcAxis2Placement2D* in)
626{
627 size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
628 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis2Placement2D"); } do { // convert the 'RefDirection' argument
629 std::shared_ptr<const DataType> arg = params[base++];
630 if (dynamic_cast<const UNSET*>(&*arg)) break;
631 try { GenericConvert( in->RefDirection, arg, db ); break; }
632 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis2Placement2D to be a `IfcDirection`")); }
633 } while(0);
634 return base;
635}
636// -----------------------------------------------------------------------------------------------------------
637template <> size_t GenericFill<IfcSpaceProgram>(const DB& db, const LIST& params, IfcSpaceProgram* in)
638{
639 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
640// this data structure is not used yet, so there is no code generated to fill its members
641 return base;
642}
643// -----------------------------------------------------------------------------------------------------------
644template <> size_t GenericFill<IfcPoint>(const DB& db, const LIST& params, IfcPoint* in)
645{
646 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
647 return base;
648}
649// -----------------------------------------------------------------------------------------------------------
650template <> size_t GenericFill<IfcCartesianPoint>(const DB& db, const LIST& params, IfcCartesianPoint* in)
651{
652 size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
653 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcCartesianPoint"); } do { // convert the 'Coordinates' argument
654 std::shared_ptr<const DataType> arg = params[base++];
655 try { GenericConvert( in->Coordinates, arg, db ); break; }
656 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcCartesianPoint to be a `LIST [1:3] OF IfcLengthMeasure`")); }
657 } while(0);
658 return base;
659}
660// -----------------------------------------------------------------------------------------------------------
661template <> size_t GenericFill<IfcBoundedSurface>(const DB& db, const LIST& params, IfcBoundedSurface* in)
662{
663 size_t base = GenericFill(db,params,static_cast<IfcSurface*>(in));
664// this data structure is not used yet, so there is no code generated to fill its members
665 return base;
666}
667// -----------------------------------------------------------------------------------------------------------
668template <> size_t GenericFill<IfcLoop>(const DB& db, const LIST& params, IfcLoop* in)
669{
670 size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
671 return base;
672}
673// -----------------------------------------------------------------------------------------------------------
674template <> size_t GenericFill<IfcPolyLoop>(const DB& db, const LIST& params, IfcPolyLoop* in)
675{
676 size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
677 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPolyLoop"); } do { // convert the 'Polygon' argument
678 std::shared_ptr<const DataType> arg = params[base++];
679 try { GenericConvert( in->Polygon, arg, db ); break; }
680 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPolyLoop to be a `LIST [3:?] OF IfcCartesianPoint`")); }
681 } while(0);
682 return base;
683}
684// -----------------------------------------------------------------------------------------------------------
685template <> size_t GenericFill<IfcTerminatorSymbol>(const DB& db, const LIST& params, IfcTerminatorSymbol* in)
686{
687 size_t base = GenericFill(db,params,static_cast<IfcAnnotationSymbolOccurrence*>(in));
688// this data structure is not used yet, so there is no code generated to fill its members
689 return base;
690}
691// -----------------------------------------------------------------------------------------------------------
692template <> size_t GenericFill<IfcDimensionCurveTerminator>(const DB& db, const LIST& params, IfcDimensionCurveTerminator* in)
693{
694 size_t base = GenericFill(db,params,static_cast<IfcTerminatorSymbol*>(in));
695// this data structure is not used yet, so there is no code generated to fill its members
696 return base;
697}
698// -----------------------------------------------------------------------------------------------------------
699template <> size_t GenericFill<IfcTrapeziumProfileDef>(const DB& db, const LIST& params, IfcTrapeziumProfileDef* in)
700{
701 size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
702// this data structure is not used yet, so there is no code generated to fill its members
703 return base;
704}
705// -----------------------------------------------------------------------------------------------------------
706template <> size_t GenericFill<IfcRepresentationContext>(const DB& db, const LIST& params, IfcRepresentationContext* in)
707{
708 size_t base = 0;
709 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationContext"); } do { // convert the 'ContextIdentifier' argument
710 std::shared_ptr<const DataType> arg = params[base++];
711 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[0]=true; break; }
712 if (dynamic_cast<const UNSET*>(&*arg)) break;
713 try { GenericConvert( in->ContextIdentifier, arg, db ); break; }
714 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationContext to be a `IfcLabel`")); }
715 } while(0);
716 do { // convert the 'ContextType' argument
717 std::shared_ptr<const DataType> arg = params[base++];
718 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcRepresentationContext,2>::aux_is_derived[1]=true; break; }
719 if (dynamic_cast<const UNSET*>(&*arg)) break;
720 try { GenericConvert( in->ContextType, arg, db ); break; }
721 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationContext to be a `IfcLabel`")); }
722 } while(0);
723 return base;
724}
725// -----------------------------------------------------------------------------------------------------------
726template <> size_t GenericFill<IfcGeometricRepresentationContext>(const DB& db, const LIST& params, IfcGeometricRepresentationContext* in)
727{
728 size_t base = GenericFill(db,params,static_cast<IfcRepresentationContext*>(in));
729 if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcGeometricRepresentationContext"); } do { // convert the 'CoordinateSpaceDimension' argument
730 std::shared_ptr<const DataType> arg = params[base++];
731 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[0]=true; break; }
732 try { GenericConvert( in->CoordinateSpaceDimension, arg, db ); break; }
733 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcGeometricRepresentationContext to be a `IfcDimensionCount`")); }
734 } while(0);
735 do { // convert the 'Precision' argument
736 std::shared_ptr<const DataType> arg = params[base++];
737 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[1]=true; break; }
738 if (dynamic_cast<const UNSET*>(&*arg)) break;
739 try { GenericConvert( in->Precision, arg, db ); break; }
740 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcGeometricRepresentationContext to be a `REAL`")); }
741 } while(0);
742 do { // convert the 'WorldCoordinateSystem' argument
743 std::shared_ptr<const DataType> arg = params[base++];
744 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[2]=true; break; }
745 try { GenericConvert( in->WorldCoordinateSystem, arg, db ); break; }
746 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcGeometricRepresentationContext to be a `IfcAxis2Placement`")); }
747 } while(0);
748 do { // convert the 'TrueNorth' argument
749 std::shared_ptr<const DataType> arg = params[base++];
750 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcGeometricRepresentationContext,4>::aux_is_derived[3]=true; break; }
751 if (dynamic_cast<const UNSET*>(&*arg)) break;
752 try { GenericConvert( in->TrueNorth, arg, db ); break; }
753 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcGeometricRepresentationContext to be a `IfcDirection`")); }
754 } while(0);
755 return base;
756}
757// -----------------------------------------------------------------------------------------------------------
758template <> size_t GenericFill<IfcCurveBoundedPlane>(const DB& db, const LIST& params, IfcCurveBoundedPlane* in)
759{
760 size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
761// this data structure is not used yet, so there is no code generated to fill its members
762 return base;
763}
764// -----------------------------------------------------------------------------------------------------------
765template <> size_t GenericFill<IfcSIUnit>(const DB& db, const LIST& params, IfcSIUnit* in)
766{
767 size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
768 if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcSIUnit"); } do { // convert the 'Prefix' argument
769 std::shared_ptr<const DataType> arg = params[base++];
770 if (dynamic_cast<const UNSET*>(&*arg)) break;
771 try { GenericConvert( in->Prefix, arg, db ); break; }
772 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSIUnit to be a `IfcSIPrefix`")); }
773 } while(0);
774 do { // convert the 'Name' argument
775 std::shared_ptr<const DataType> arg = params[base++];
776 try { GenericConvert( in->Name, arg, db ); break; }
777 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSIUnit to be a `IfcSIUnitName`")); }
778 } while(0);
779 return base;
780}
781// -----------------------------------------------------------------------------------------------------------
782template <> size_t GenericFill<IfcStructuralReaction>(const DB& db, const LIST& params, IfcStructuralReaction* in)
783{
784 size_t base = GenericFill(db,params,static_cast<IfcStructuralActivity*>(in));
785// this data structure is not used yet, so there is no code generated to fill its members
786 return base;
787}
788// -----------------------------------------------------------------------------------------------------------
789template <> size_t GenericFill<IfcStructuralPointReaction>(const DB& db, const LIST& params, IfcStructuralPointReaction* in)
790{
791 size_t base = GenericFill(db,params,static_cast<IfcStructuralReaction*>(in));
792// this data structure is not used yet, so there is no code generated to fill its members
793 return base;
794}
795// -----------------------------------------------------------------------------------------------------------
796template <> size_t GenericFill<IfcAxis1Placement>(const DB& db, const LIST& params, IfcAxis1Placement* in)
797{
798 size_t base = GenericFill(db,params,static_cast<IfcPlacement*>(in));
799 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcAxis1Placement"); } do { // convert the 'Axis' argument
800 std::shared_ptr<const DataType> arg = params[base++];
801 if (dynamic_cast<const UNSET*>(&*arg)) break;
802 try { GenericConvert( in->Axis, arg, db ); break; }
803 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcAxis1Placement to be a `IfcDirection`")); }
804 } while(0);
805 return base;
806}
807// -----------------------------------------------------------------------------------------------------------
808template <> size_t GenericFill<IfcElectricApplianceType>(const DB& db, const LIST& params, IfcElectricApplianceType* in)
809{
810 size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
811// this data structure is not used yet, so there is no code generated to fill its members
812 return base;
813}
814// -----------------------------------------------------------------------------------------------------------
815template <> size_t GenericFill<IfcSensorType>(const DB& db, const LIST& params, IfcSensorType* in)
816{
817 size_t base = GenericFill(db,params,static_cast<IfcDistributionControlElementType*>(in));
818// this data structure is not used yet, so there is no code generated to fill its members
819 return base;
820}
821// -----------------------------------------------------------------------------------------------------------
822template <> size_t GenericFill<IfcFurnishingElement>(const DB& db, const LIST& params, IfcFurnishingElement* in)
823{
824 size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
825// this data structure is not used yet, so there is no code generated to fill its members
826 return base;
827}
828// -----------------------------------------------------------------------------------------------------------
829template <> size_t GenericFill<IfcProtectiveDeviceType>(const DB& db, const LIST& params, IfcProtectiveDeviceType* in)
830{
831 size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
832// this data structure is not used yet, so there is no code generated to fill its members
833 return base;
834}
835// -----------------------------------------------------------------------------------------------------------
836template <> size_t GenericFill<IfcZShapeProfileDef>(const DB& db, const LIST& params, IfcZShapeProfileDef* in)
837{
838 size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
839// this data structure is not used yet, so there is no code generated to fill its members
840 return base;
841}
842// -----------------------------------------------------------------------------------------------------------
843template <> size_t GenericFill<IfcScheduleTimeControl>(const DB& db, const LIST& params, IfcScheduleTimeControl* in)
844{
845 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
846// this data structure is not used yet, so there is no code generated to fill its members
847 return base;
848}
849// -----------------------------------------------------------------------------------------------------------
850template <> size_t GenericFill<IfcRepresentationMap>(const DB& db, const LIST& params, IfcRepresentationMap* in)
851{
852 size_t base = 0;
853 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcRepresentationMap"); } do { // convert the 'MappingOrigin' argument
854 std::shared_ptr<const DataType> arg = params[base++];
855 try { GenericConvert( in->MappingOrigin, arg, db ); break; }
856 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcRepresentationMap to be a `IfcAxis2Placement`")); }
857 } while(0);
858 do { // convert the 'MappedRepresentation' argument
859 std::shared_ptr<const DataType> arg = params[base++];
860 try { GenericConvert( in->MappedRepresentation, arg, db ); break; }
861 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcRepresentationMap to be a `IfcRepresentation`")); }
862 } while(0);
863 return base;
864}
865// -----------------------------------------------------------------------------------------------------------
866template <> size_t GenericFill<IfcClosedShell>(const DB& db, const LIST& params, IfcClosedShell* in)
867{
868 size_t base = GenericFill(db,params,static_cast<IfcConnectedFaceSet*>(in));
869 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcClosedShell"); } return base;
870}
871// -----------------------------------------------------------------------------------------------------------
872template <> size_t GenericFill<IfcBuildingElementPart>(const DB& db, const LIST& params, IfcBuildingElementPart* in)
873{
874 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementComponent*>(in));
875// this data structure is not used yet, so there is no code generated to fill its members
876 return base;
877}
878// -----------------------------------------------------------------------------------------------------------
879template <> size_t GenericFill<IfcBlock>(const DB& db, const LIST& params, IfcBlock* in)
880{
881 size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
882// this data structure is not used yet, so there is no code generated to fill its members
883 return base;
884}
885// -----------------------------------------------------------------------------------------------------------
886template <> size_t GenericFill<IfcLightFixtureType>(const DB& db, const LIST& params, IfcLightFixtureType* in)
887{
888 size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
889// this data structure is not used yet, so there is no code generated to fill its members
890 return base;
891}
892// -----------------------------------------------------------------------------------------------------------
893template <> size_t GenericFill<IfcOpeningElement>(const DB& db, const LIST& params, IfcOpeningElement* in)
894{
895 size_t base = GenericFill(db,params,static_cast<IfcFeatureElementSubtraction*>(in));
896 if (params.GetSize() < 8) { throw STEP::TypeError("expected 8 arguments to IfcOpeningElement"); } return base;
897}
898// -----------------------------------------------------------------------------------------------------------
899template <> size_t GenericFill<IfcLightSourceSpot>(const DB& db, const LIST& params, IfcLightSourceSpot* in)
900{
901 size_t base = GenericFill(db,params,static_cast<IfcLightSourcePositional*>(in));
902// this data structure is not used yet, so there is no code generated to fill its members
903 return base;
904}
905// -----------------------------------------------------------------------------------------------------------
906template <> size_t GenericFill<IfcTendonAnchor>(const DB& db, const LIST& params, IfcTendonAnchor* in)
907{
908 size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
909// this data structure is not used yet, so there is no code generated to fill its members
910 return base;
911}
912// -----------------------------------------------------------------------------------------------------------
913template <> size_t GenericFill<IfcElectricFlowStorageDeviceType>(const DB& db, const LIST& params, IfcElectricFlowStorageDeviceType* in)
914{
915 size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
916// this data structure is not used yet, so there is no code generated to fill its members
917 return base;
918}
919// -----------------------------------------------------------------------------------------------------------
920template <> size_t GenericFill<IfcSphere>(const DB& db, const LIST& params, IfcSphere* in)
921{
922 size_t base = GenericFill(db,params,static_cast<IfcCsgPrimitive3D*>(in));
923// this data structure is not used yet, so there is no code generated to fill its members
924 return base;
925}
926// -----------------------------------------------------------------------------------------------------------
927template <> size_t GenericFill<IfcDamperType>(const DB& db, const LIST& params, IfcDamperType* in)
928{
929 size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
930// this data structure is not used yet, so there is no code generated to fill its members
931 return base;
932}
933// -----------------------------------------------------------------------------------------------------------
934template <> size_t GenericFill<IfcProjectOrderRecord>(const DB& db, const LIST& params, IfcProjectOrderRecord* in)
935{
936 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
937// this data structure is not used yet, so there is no code generated to fill its members
938 return base;
939}
940// -----------------------------------------------------------------------------------------------------------
941template <> size_t GenericFill<IfcDistributionChamberElement>(const DB& db, const LIST& params, IfcDistributionChamberElement* in)
942{
943 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
944// this data structure is not used yet, so there is no code generated to fill its members
945 return base;
946}
947// -----------------------------------------------------------------------------------------------------------
948template <> size_t GenericFill<IfcMechanicalFastener>(const DB& db, const LIST& params, IfcMechanicalFastener* in)
949{
950 size_t base = GenericFill(db,params,static_cast<IfcFastener*>(in));
951// this data structure is not used yet, so there is no code generated to fill its members
952 return base;
953}
954// -----------------------------------------------------------------------------------------------------------
955template <> size_t GenericFill<IfcRectangularTrimmedSurface>(const DB& db, const LIST& params, IfcRectangularTrimmedSurface* in)
956{
957 size_t base = GenericFill(db,params,static_cast<IfcBoundedSurface*>(in));
958// this data structure is not used yet, so there is no code generated to fill its members
959 return base;
960}
961// -----------------------------------------------------------------------------------------------------------
962template <> size_t GenericFill<IfcZone>(const DB& db, const LIST& params, IfcZone* in)
963{
964 size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
965// this data structure is not used yet, so there is no code generated to fill its members
966 return base;
967}
968// -----------------------------------------------------------------------------------------------------------
969template <> size_t GenericFill<IfcFanType>(const DB& db, const LIST& params, IfcFanType* in)
970{
971 size_t base = GenericFill(db,params,static_cast<IfcFlowMovingDeviceType*>(in));
972// this data structure is not used yet, so there is no code generated to fill its members
973 return base;
974}
975// -----------------------------------------------------------------------------------------------------------
976template <> size_t GenericFill<IfcGeometricSet>(const DB& db, const LIST& params, IfcGeometricSet* in)
977{
978 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
979// this data structure is not used yet, so there is no code generated to fill its members
980 return base;
981}
982// -----------------------------------------------------------------------------------------------------------
983template <> size_t GenericFill<IfcFillAreaStyleTiles>(const DB& db, const LIST& params, IfcFillAreaStyleTiles* in)
984{
985 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
986// this data structure is not used yet, so there is no code generated to fill its members
987 return base;
988}
989// -----------------------------------------------------------------------------------------------------------
990template <> size_t GenericFill<IfcCableSegmentType>(const DB& db, const LIST& params, IfcCableSegmentType* in)
991{
992 size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
993// this data structure is not used yet, so there is no code generated to fill its members
994 return base;
995}
996// -----------------------------------------------------------------------------------------------------------
997template <> size_t GenericFill<IfcRelOverridesProperties>(const DB& db, const LIST& params, IfcRelOverridesProperties* in)
998{
999 size_t base = GenericFill(db,params,static_cast<IfcRelDefinesByProperties*>(in));
1000// this data structure is not used yet, so there is no code generated to fill its members
1001 return base;
1002}
1003// -----------------------------------------------------------------------------------------------------------
1004template <> size_t GenericFill<IfcMeasureWithUnit>(const DB& db, const LIST& params, IfcMeasureWithUnit* in)
1005{
1006 size_t base = 0;
1007 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcMeasureWithUnit"); } do { // convert the 'ValueComponent' argument
1008 std::shared_ptr<const DataType> arg = params[base++];
1009 try { GenericConvert( in->ValueComponent, arg, db ); break; }
1010 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcMeasureWithUnit to be a `IfcValue`")); }
1011 } while(0);
1012 do { // convert the 'UnitComponent' argument
1013 std::shared_ptr<const DataType> arg = params[base++];
1014 try { GenericConvert( in->UnitComponent, arg, db ); break; }
1015 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcMeasureWithUnit to be a `IfcUnit`")); }
1016 } while(0);
1017 return base;
1018}
1019// -----------------------------------------------------------------------------------------------------------
1020template <> size_t GenericFill<IfcSlabType>(const DB& db, const LIST& params, IfcSlabType* in)
1021{
1022 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
1023// this data structure is not used yet, so there is no code generated to fill its members
1024 return base;
1025}
1026// -----------------------------------------------------------------------------------------------------------
1027template <> size_t GenericFill<IfcServiceLife>(const DB& db, const LIST& params, IfcServiceLife* in)
1028{
1029 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
1030// this data structure is not used yet, so there is no code generated to fill its members
1031 return base;
1032}
1033// -----------------------------------------------------------------------------------------------------------
1034template <> size_t GenericFill<IfcFurnitureType>(const DB& db, const LIST& params, IfcFurnitureType* in)
1035{
1036 size_t base = GenericFill(db,params,static_cast<IfcFurnishingElementType*>(in));
1037// this data structure is not used yet, so there is no code generated to fill its members
1038 return base;
1039}
1040// -----------------------------------------------------------------------------------------------------------
1041template <> size_t GenericFill<IfcCostItem>(const DB& db, const LIST& params, IfcCostItem* in)
1042{
1043 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
1044// this data structure is not used yet, so there is no code generated to fill its members
1045 return base;
1046}
1047// -----------------------------------------------------------------------------------------------------------
1048template <> size_t GenericFill<IfcReinforcingMesh>(const DB& db, const LIST& params, IfcReinforcingMesh* in)
1049{
1050 size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
1051// this data structure is not used yet, so there is no code generated to fill its members
1052 return base;
1053}
1054// -----------------------------------------------------------------------------------------------------------
1055template <> size_t GenericFill<IfcFacetedBrepWithVoids>(const DB& db, const LIST& params, IfcFacetedBrepWithVoids* in)
1056{
1057 size_t base = GenericFill(db,params,static_cast<IfcManifoldSolidBrep*>(in));
1058// this data structure is not used yet, so there is no code generated to fill its members
1059 return base;
1060}
1061// -----------------------------------------------------------------------------------------------------------
1062template <> size_t GenericFill<IfcGasTerminalType>(const DB& db, const LIST& params, IfcGasTerminalType* in)
1063{
1064 size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
1065// this data structure is not used yet, so there is no code generated to fill its members
1066 return base;
1067}
1068// -----------------------------------------------------------------------------------------------------------
1069template <> size_t GenericFill<IfcPile>(const DB& db, const LIST& params, IfcPile* in)
1070{
1071 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1072// this data structure is not used yet, so there is no code generated to fill its members
1073 return base;
1074}
1075// -----------------------------------------------------------------------------------------------------------
1076template <> size_t GenericFill<IfcFillAreaStyleTileSymbolWithStyle>(const DB& db, const LIST& params, IfcFillAreaStyleTileSymbolWithStyle* in)
1077{
1078 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
1079// this data structure is not used yet, so there is no code generated to fill its members
1080 return base;
1081}
1082// -----------------------------------------------------------------------------------------------------------
1083template <> size_t GenericFill<IfcConstructionMaterialResource>(const DB& db, const LIST& params, IfcConstructionMaterialResource* in)
1084{
1085 size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
1086// this data structure is not used yet, so there is no code generated to fill its members
1087 return base;
1088}
1089// -----------------------------------------------------------------------------------------------------------
1090template <> size_t GenericFill<IfcAnnotationCurveOccurrence>(const DB& db, const LIST& params, IfcAnnotationCurveOccurrence* in)
1091{
1092 size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
1093// this data structure is not used yet, so there is no code generated to fill its members
1094 return base;
1095}
1096// -----------------------------------------------------------------------------------------------------------
1097template <> size_t GenericFill<IfcDimensionCurve>(const DB& db, const LIST& params, IfcDimensionCurve* in)
1098{
1099 size_t base = GenericFill(db,params,static_cast<IfcAnnotationCurveOccurrence*>(in));
1100// this data structure is not used yet, so there is no code generated to fill its members
1101 return base;
1102}
1103// -----------------------------------------------------------------------------------------------------------
1104template <> size_t GenericFill<IfcGeometricCurveSet>(const DB& db, const LIST& params, IfcGeometricCurveSet* in)
1105{
1106 size_t base = GenericFill(db,params,static_cast<IfcGeometricSet*>(in));
1107// this data structure is not used yet, so there is no code generated to fill its members
1108 return base;
1109}
1110// -----------------------------------------------------------------------------------------------------------
1111template <> size_t GenericFill<IfcRelAggregates>(const DB& db, const LIST& params, IfcRelAggregates* in)
1112{
1113 size_t base = GenericFill(db,params,static_cast<IfcRelDecomposes*>(in));
1114 if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcRelAggregates"); } return base;
1115}
1116// -----------------------------------------------------------------------------------------------------------
1117template <> size_t GenericFill<IfcFaceBasedSurfaceModel>(const DB& db, const LIST& params, IfcFaceBasedSurfaceModel* in)
1118{
1119 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
1120 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcFaceBasedSurfaceModel"); } do { // convert the 'FbsmFaces' argument
1121 std::shared_ptr<const DataType> arg = params[base++];
1122 try { GenericConvert( in->FbsmFaces, arg, db ); break; }
1123 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBasedSurfaceModel to be a `SET [1:?] OF IfcConnectedFaceSet`")); }
1124 } while(0);
1125 return base;
1126}
1127// -----------------------------------------------------------------------------------------------------------
1128template <> size_t GenericFill<IfcEnergyConversionDevice>(const DB& db, const LIST& params, IfcEnergyConversionDevice* in)
1129{
1130 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
1131// this data structure is not used yet, so there is no code generated to fill its members
1132 return base;
1133}
1134// -----------------------------------------------------------------------------------------------------------
1135template <> size_t GenericFill<IfcRampFlight>(const DB& db, const LIST& params, IfcRampFlight* in)
1136{
1137 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1138// this data structure is not used yet, so there is no code generated to fill its members
1139 return base;
1140}
1141// -----------------------------------------------------------------------------------------------------------
1142template <> size_t GenericFill<IfcVertexLoop>(const DB& db, const LIST& params, IfcVertexLoop* in)
1143{
1144 size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
1145// this data structure is not used yet, so there is no code generated to fill its members
1146 return base;
1147}
1148// -----------------------------------------------------------------------------------------------------------
1149template <> size_t GenericFill<IfcPlate>(const DB& db, const LIST& params, IfcPlate* in)
1150{
1151 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1152// this data structure is not used yet, so there is no code generated to fill its members
1153 return base;
1154}
1155// -----------------------------------------------------------------------------------------------------------
1156template <> size_t GenericFill<IfcUShapeProfileDef>(const DB& db, const LIST& params, IfcUShapeProfileDef* in)
1157{
1158 size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
1159// this data structure is not used yet, so there is no code generated to fill its members
1160 return base;
1161}
1162// -----------------------------------------------------------------------------------------------------------
1163template <> size_t GenericFill<IfcFaceBound>(const DB& db, const LIST& params, IfcFaceBound* in)
1164{
1165 size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
1166 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceBound"); } do { // convert the 'Bound' argument
1167 std::shared_ptr<const DataType> arg = params[base++];
1168 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[0]=true; break; }
1169 try { GenericConvert( in->Bound, arg, db ); break; }
1170 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcFaceBound to be a `IfcLoop`")); }
1171 } while(0);
1172 do { // convert the 'Orientation' argument
1173 std::shared_ptr<const DataType> arg = params[base++];
1174 if (dynamic_cast<const ISDERIVED*>(&*arg)) { in->ObjectHelper<Assimp::IFC::IfcFaceBound,2>::aux_is_derived[1]=true; break; }
1175 try { GenericConvert( in->Orientation, arg, db ); break; }
1176 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcFaceBound to be a `BOOLEAN`")); }
1177 } while(0);
1178 return base;
1179}
1180// -----------------------------------------------------------------------------------------------------------
1181template <> size_t GenericFill<IfcFaceOuterBound>(const DB& db, const LIST& params, IfcFaceOuterBound* in)
1182{
1183 size_t base = GenericFill(db,params,static_cast<IfcFaceBound*>(in));
1184 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcFaceOuterBound"); } return base;
1185}
1186// -----------------------------------------------------------------------------------------------------------
1187template <> size_t GenericFill<IfcOneDirectionRepeatFactor>(const DB& db, const LIST& params, IfcOneDirectionRepeatFactor* in)
1188{
1189 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
1190// this data structure is not used yet, so there is no code generated to fill its members
1191 return base;
1192}
1193// -----------------------------------------------------------------------------------------------------------
1194template <> size_t GenericFill<IfcBoilerType>(const DB& db, const LIST& params, IfcBoilerType* in)
1195{
1196 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
1197// this data structure is not used yet, so there is no code generated to fill its members
1198 return base;
1199}
1200// -----------------------------------------------------------------------------------------------------------
1201template <> size_t GenericFill<IfcConstructionEquipmentResource>(const DB& db, const LIST& params, IfcConstructionEquipmentResource* in)
1202{
1203 size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
1204// this data structure is not used yet, so there is no code generated to fill its members
1205 return base;
1206}
1207// -----------------------------------------------------------------------------------------------------------
1208template <> size_t GenericFill<IfcComplexProperty>(const DB& db, const LIST& params, IfcComplexProperty* in)
1209{
1210 size_t base = GenericFill(db,params,static_cast<IfcProperty*>(in));
1211 if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcComplexProperty"); } do { // convert the 'UsageName' argument
1212 std::shared_ptr<const DataType> arg = params[base++];
1213 try { GenericConvert( in->UsageName, arg, db ); break; }
1214 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcComplexProperty to be a `IfcIdentifier`")); }
1215 } while(0);
1216 do { // convert the 'HasProperties' argument
1217 std::shared_ptr<const DataType> arg = params[base++];
1218 try { GenericConvert( in->HasProperties, arg, db ); break; }
1219 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcComplexProperty to be a `SET [1:?] OF IfcProperty`")); }
1220 } while(0);
1221 return base;
1222}
1223// -----------------------------------------------------------------------------------------------------------
1224template <> size_t GenericFill<IfcFooting>(const DB& db, const LIST& params, IfcFooting* in)
1225{
1226 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1227// this data structure is not used yet, so there is no code generated to fill its members
1228 return base;
1229}
1230// -----------------------------------------------------------------------------------------------------------
1231template <> size_t GenericFill<IfcConstructionProductResource>(const DB& db, const LIST& params, IfcConstructionProductResource* in)
1232{
1233 size_t base = GenericFill(db,params,static_cast<IfcConstructionResource*>(in));
1234// this data structure is not used yet, so there is no code generated to fill its members
1235 return base;
1236}
1237// -----------------------------------------------------------------------------------------------------------
1238template <> size_t GenericFill<IfcDerivedProfileDef>(const DB& db, const LIST& params, IfcDerivedProfileDef* in)
1239{
1240 size_t base = GenericFill(db,params,static_cast<IfcProfileDef*>(in));
1241// this data structure is not used yet, so there is no code generated to fill its members
1242 return base;
1243}
1244// -----------------------------------------------------------------------------------------------------------
1245template <> size_t GenericFill<IfcPropertyTableValue>(const DB& db, const LIST& params, IfcPropertyTableValue* in)
1246{
1247 size_t base = GenericFill(db,params,static_cast<IfcSimpleProperty*>(in));
1248// this data structure is not used yet, so there is no code generated to fill its members
1249 return base;
1250}
1251// -----------------------------------------------------------------------------------------------------------
1252template <> size_t GenericFill<IfcFlowMeterType>(const DB& db, const LIST& params, IfcFlowMeterType* in)
1253{
1254 size_t base = GenericFill(db,params,static_cast<IfcFlowControllerType*>(in));
1255// this data structure is not used yet, so there is no code generated to fill its members
1256 return base;
1257}
1258// -----------------------------------------------------------------------------------------------------------
1259template <> size_t GenericFill<IfcDoorStyle>(const DB& db, const LIST& params, IfcDoorStyle* in)
1260{
1261 size_t base = GenericFill(db,params,static_cast<IfcTypeProduct*>(in));
1262// this data structure is not used yet, so there is no code generated to fill its members
1263 return base;
1264}
1265// -----------------------------------------------------------------------------------------------------------
1266template <> size_t GenericFill<IfcUnitAssignment>(const DB& db, const LIST& params, IfcUnitAssignment* in)
1267{
1268 size_t base = 0;
1269 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcUnitAssignment"); } do { // convert the 'Units' argument
1270 std::shared_ptr<const DataType> arg = params[base++];
1271 try { GenericConvert( in->Units, arg, db ); break; }
1272 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcUnitAssignment to be a `SET [1:?] OF IfcUnit`")); }
1273 } while(0);
1274 return base;
1275}
1276// -----------------------------------------------------------------------------------------------------------
1277template <> size_t GenericFill<IfcFlowTerminal>(const DB& db, const LIST& params, IfcFlowTerminal* in)
1278{
1279 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
1280// this data structure is not used yet, so there is no code generated to fill its members
1281 return base;
1282}
1283// -----------------------------------------------------------------------------------------------------------
1284template <> size_t GenericFill<IfcCraneRailFShapeProfileDef>(const DB& db, const LIST& params, IfcCraneRailFShapeProfileDef* in)
1285{
1286 size_t base = GenericFill(db,params,static_cast<IfcParameterizedProfileDef*>(in));
1287// this data structure is not used yet, so there is no code generated to fill its members
1288 return base;
1289}
1290// -----------------------------------------------------------------------------------------------------------
1291template <> size_t GenericFill<IfcFlowSegment>(const DB& db, const LIST& params, IfcFlowSegment* in)
1292{
1293 size_t base = GenericFill(db,params,static_cast<IfcDistributionFlowElement*>(in));
1294// this data structure is not used yet, so there is no code generated to fill its members
1295 return base;
1296}
1297// -----------------------------------------------------------------------------------------------------------
1298template <> size_t GenericFill<IfcElementQuantity>(const DB& db, const LIST& params, IfcElementQuantity* in)
1299{
1300 size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
1301 if (params.GetSize() < 6) { throw STEP::TypeError("expected 6 arguments to IfcElementQuantity"); } do { // convert the 'MethodOfMeasurement' argument
1302 std::shared_ptr<const DataType> arg = params[base++];
1303 if (dynamic_cast<const UNSET*>(&*arg)) break;
1304 try { GenericConvert( in->MethodOfMeasurement, arg, db ); break; }
1305 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcElementQuantity to be a `IfcLabel`")); }
1306 } while(0);
1307 do { // convert the 'Quantities' argument
1308 std::shared_ptr<const DataType> arg = params[base++];
1309 try { GenericConvert( in->Quantities, arg, db ); break; }
1310 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcElementQuantity to be a `SET [1:?] OF IfcPhysicalQuantity`")); }
1311 } while(0);
1312 return base;
1313}
1314// -----------------------------------------------------------------------------------------------------------
1315template <> size_t GenericFill<IfcCurtainWall>(const DB& db, const LIST& params, IfcCurtainWall* in)
1316{
1317 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1318// this data structure is not used yet, so there is no code generated to fill its members
1319 return base;
1320}
1321// -----------------------------------------------------------------------------------------------------------
1322template <> size_t GenericFill<IfcDiscreteAccessory>(const DB& db, const LIST& params, IfcDiscreteAccessory* in)
1323{
1324 size_t base = GenericFill(db,params,static_cast<IfcElementComponent*>(in));
1325// this data structure is not used yet, so there is no code generated to fill its members
1326 return base;
1327}
1328// -----------------------------------------------------------------------------------------------------------
1329template <> size_t GenericFill<IfcGrid>(const DB& db, const LIST& params, IfcGrid* in)
1330{
1331 size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
1332// this data structure is not used yet, so there is no code generated to fill its members
1333 return base;
1334}
1335// -----------------------------------------------------------------------------------------------------------
1336template <> size_t GenericFill<IfcSanitaryTerminalType>(const DB& db, const LIST& params, IfcSanitaryTerminalType* in)
1337{
1338 size_t base = GenericFill(db,params,static_cast<IfcFlowTerminalType*>(in));
1339// this data structure is not used yet, so there is no code generated to fill its members
1340 return base;
1341}
1342// -----------------------------------------------------------------------------------------------------------
1343template <> size_t GenericFill<IfcSubedge>(const DB& db, const LIST& params, IfcSubedge* in)
1344{
1345 size_t base = GenericFill(db,params,static_cast<IfcEdge*>(in));
1346// this data structure is not used yet, so there is no code generated to fill its members
1347 return base;
1348}
1349// -----------------------------------------------------------------------------------------------------------
1350template <> size_t GenericFill<IfcFilterType>(const DB& db, const LIST& params, IfcFilterType* in)
1351{
1352 size_t base = GenericFill(db,params,static_cast<IfcFlowTreatmentDeviceType*>(in));
1353// this data structure is not used yet, so there is no code generated to fill its members
1354 return base;
1355}
1356// -----------------------------------------------------------------------------------------------------------
1357template <> size_t GenericFill<IfcTendon>(const DB& db, const LIST& params, IfcTendon* in)
1358{
1359 size_t base = GenericFill(db,params,static_cast<IfcReinforcingElement*>(in));
1360// this data structure is not used yet, so there is no code generated to fill its members
1361 return base;
1362}
1363// -----------------------------------------------------------------------------------------------------------
1364template <> size_t GenericFill<IfcStructuralLoadGroup>(const DB& db, const LIST& params, IfcStructuralLoadGroup* in)
1365{
1366 size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
1367// this data structure is not used yet, so there is no code generated to fill its members
1368 return base;
1369}
1370// -----------------------------------------------------------------------------------------------------------
1371template <> size_t GenericFill<IfcPresentationStyleAssignment>(const DB& db, const LIST& params, IfcPresentationStyleAssignment* in)
1372{
1373 size_t base = 0;
1374 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcPresentationStyleAssignment"); } do { // convert the 'Styles' argument
1375 std::shared_ptr<const DataType> arg = params[base++];
1376 try { GenericConvert( in->Styles, arg, db ); break; }
1377 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcPresentationStyleAssignment to be a `SET [1:?] OF IfcPresentationStyleSelect`")); }
1378 } while(0);
1379 return base;
1380}
1381// -----------------------------------------------------------------------------------------------------------
1382template <> size_t GenericFill<IfcStructuralCurveMember>(const DB& db, const LIST& params, IfcStructuralCurveMember* in)
1383{
1384 size_t base = GenericFill(db,params,static_cast<IfcStructuralMember*>(in));
1385// this data structure is not used yet, so there is no code generated to fill its members
1386 return base;
1387}
1388// -----------------------------------------------------------------------------------------------------------
1389template <> size_t GenericFill<IfcLightSourceAmbient>(const DB& db, const LIST& params, IfcLightSourceAmbient* in)
1390{
1391 size_t base = GenericFill(db,params,static_cast<IfcLightSource*>(in));
1392// this data structure is not used yet, so there is no code generated to fill its members
1393 return base;
1394}
1395// -----------------------------------------------------------------------------------------------------------
1396template <> size_t GenericFill<IfcCondition>(const DB& db, const LIST& params, IfcCondition* in)
1397{
1398 size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
1399// this data structure is not used yet, so there is no code generated to fill its members
1400 return base;
1401}
1402// -----------------------------------------------------------------------------------------------------------
1403template <> size_t GenericFill<IfcPort>(const DB& db, const LIST& params, IfcPort* in)
1404{
1405 size_t base = GenericFill(db,params,static_cast<IfcProduct*>(in));
1406// this data structure is not used yet, so there is no code generated to fill its members
1407 return base;
1408}
1409// -----------------------------------------------------------------------------------------------------------
1410template <> size_t GenericFill<IfcSpace>(const DB& db, const LIST& params, IfcSpace* in)
1411{
1412 size_t base = GenericFill(db,params,static_cast<IfcSpatialStructureElement*>(in));
1413 if (params.GetSize() < 11) { throw STEP::TypeError("expected 11 arguments to IfcSpace"); } do { // convert the 'InteriorOrExteriorSpace' argument
1414 std::shared_ptr<const DataType> arg = params[base++];
1415 try { GenericConvert( in->InteriorOrExteriorSpace, arg, db ); break; }
1416 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 9 to IfcSpace to be a `IfcInternalOrExternalEnum`")); }
1417 } while(0);
1418 do { // convert the 'ElevationWithFlooring' argument
1419 std::shared_ptr<const DataType> arg = params[base++];
1420 if (dynamic_cast<const UNSET*>(&*arg)) break;
1421 try { GenericConvert( in->ElevationWithFlooring, arg, db ); break; }
1422 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 10 to IfcSpace to be a `IfcLengthMeasure`")); }
1423 } while(0);
1424 return base;
1425}
1426// -----------------------------------------------------------------------------------------------------------
1427template <> size_t GenericFill<IfcHeatExchangerType>(const DB& db, const LIST& params, IfcHeatExchangerType* in)
1428{
1429 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
1430// this data structure is not used yet, so there is no code generated to fill its members
1431 return base;
1432}
1433// -----------------------------------------------------------------------------------------------------------
1434template <> size_t GenericFill<IfcTankType>(const DB& db, const LIST& params, IfcTankType* in)
1435{
1436 size_t base = GenericFill(db,params,static_cast<IfcFlowStorageDeviceType*>(in));
1437// this data structure is not used yet, so there is no code generated to fill its members
1438 return base;
1439}
1440// -----------------------------------------------------------------------------------------------------------
1441template <> size_t GenericFill<IfcInventory>(const DB& db, const LIST& params, IfcInventory* in)
1442{
1443 size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
1444// this data structure is not used yet, so there is no code generated to fill its members
1445 return base;
1446}
1447// -----------------------------------------------------------------------------------------------------------
1448template <> size_t GenericFill<IfcTransportElementType>(const DB& db, const LIST& params, IfcTransportElementType* in)
1449{
1450 size_t base = GenericFill(db,params,static_cast<IfcElementType*>(in));
1451// this data structure is not used yet, so there is no code generated to fill its members
1452 return base;
1453}
1454// -----------------------------------------------------------------------------------------------------------
1455template <> size_t GenericFill<IfcAirToAirHeatRecoveryType>(const DB& db, const LIST& params, IfcAirToAirHeatRecoveryType* in)
1456{
1457 size_t base = GenericFill(db,params,static_cast<IfcEnergyConversionDeviceType*>(in));
1458// this data structure is not used yet, so there is no code generated to fill its members
1459 return base;
1460}
1461// -----------------------------------------------------------------------------------------------------------
1462template <> size_t GenericFill<IfcStairFlight>(const DB& db, const LIST& params, IfcStairFlight* in)
1463{
1464 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1465// this data structure is not used yet, so there is no code generated to fill its members
1466 return base;
1467}
1468// -----------------------------------------------------------------------------------------------------------
1469template <> size_t GenericFill<IfcElectricalElement>(const DB& db, const LIST& params, IfcElectricalElement* in)
1470{
1471 size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
1472// this data structure is not used yet, so there is no code generated to fill its members
1473 return base;
1474}
1475// -----------------------------------------------------------------------------------------------------------
1476template <> size_t GenericFill<IfcSurfaceStyleWithTextures>(const DB& db, const LIST& params, IfcSurfaceStyleWithTextures* in)
1477{
1478 size_t base = 0;
1479 if (params.GetSize() < 1) { throw STEP::TypeError("expected 1 arguments to IfcSurfaceStyleWithTextures"); } do { // convert the 'Textures' argument
1480 std::shared_ptr<const DataType> arg = params[base++];
1481 try { GenericConvert( in->Textures, arg, db ); break; }
1482 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcSurfaceStyleWithTextures to be a `LIST [1:?] OF IfcSurfaceTexture`")); }
1483 } while(0);
1484 return base;
1485}
1486// -----------------------------------------------------------------------------------------------------------
1487template <> size_t GenericFill<IfcBoundingBox>(const DB& db, const LIST& params, IfcBoundingBox* in)
1488{
1489 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
1490 if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcBoundingBox"); } do { // convert the 'Corner' argument
1491 std::shared_ptr<const DataType> arg = params[base++];
1492 try { GenericConvert( in->Corner, arg, db ); break; }
1493 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 0 to IfcBoundingBox to be a `IfcCartesianPoint`")); }
1494 } while(0);
1495 do { // convert the 'XDim' argument
1496 std::shared_ptr<const DataType> arg = params[base++];
1497 try { GenericConvert( in->XDim, arg, db ); break; }
1498 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
1499 } while(0);
1500 do { // convert the 'YDim' argument
1501 std::shared_ptr<const DataType> arg = params[base++];
1502 try { GenericConvert( in->YDim, arg, db ); break; }
1503 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
1504 } while(0);
1505 do { // convert the 'ZDim' argument
1506 std::shared_ptr<const DataType> arg = params[base++];
1507 try { GenericConvert( in->ZDim, arg, db ); break; }
1508 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcBoundingBox to be a `IfcPositiveLengthMeasure`")); }
1509 } while(0);
1510 return base;
1511}
1512// -----------------------------------------------------------------------------------------------------------
1513template <> size_t GenericFill<IfcWallType>(const DB& db, const LIST& params, IfcWallType* in)
1514{
1515 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
1516// this data structure is not used yet, so there is no code generated to fill its members
1517 return base;
1518}
1519// -----------------------------------------------------------------------------------------------------------
1520template <> size_t GenericFill<IfcMove>(const DB& db, const LIST& params, IfcMove* in)
1521{
1522 size_t base = GenericFill(db,params,static_cast<IfcTask*>(in));
1523// this data structure is not used yet, so there is no code generated to fill its members
1524 return base;
1525}
1526// -----------------------------------------------------------------------------------------------------------
1527template <> size_t GenericFill<IfcCircle>(const DB& db, const LIST& params, IfcCircle* in)
1528{
1529 size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
1530 if (params.GetSize() < 2) { throw STEP::TypeError("expected 2 arguments to IfcCircle"); } do { // convert the 'Radius' argument
1531 std::shared_ptr<const DataType> arg = params[base++];
1532 try { GenericConvert( in->Radius, arg, db ); break; }
1533 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcCircle to be a `IfcPositiveLengthMeasure`")); }
1534 } while(0);
1535 return base;
1536}
1537// -----------------------------------------------------------------------------------------------------------
1538template <> size_t GenericFill<IfcOffsetCurve2D>(const DB& db, const LIST& params, IfcOffsetCurve2D* in)
1539{
1540 size_t base = GenericFill(db,params,static_cast<IfcCurve*>(in));
1541// this data structure is not used yet, so there is no code generated to fill its members
1542 return base;
1543}
1544// -----------------------------------------------------------------------------------------------------------
1545template <> size_t GenericFill<IfcPointOnCurve>(const DB& db, const LIST& params, IfcPointOnCurve* in)
1546{
1547 size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
1548// this data structure is not used yet, so there is no code generated to fill its members
1549 return base;
1550}
1551// -----------------------------------------------------------------------------------------------------------
1552template <> size_t GenericFill<IfcStructuralResultGroup>(const DB& db, const LIST& params, IfcStructuralResultGroup* in)
1553{
1554 size_t base = GenericFill(db,params,static_cast<IfcGroup*>(in));
1555// this data structure is not used yet, so there is no code generated to fill its members
1556 return base;
1557}
1558// -----------------------------------------------------------------------------------------------------------
1559template <> size_t GenericFill<IfcSectionedSpine>(const DB& db, const LIST& params, IfcSectionedSpine* in)
1560{
1561 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
1562// this data structure is not used yet, so there is no code generated to fill its members
1563 return base;
1564}
1565// -----------------------------------------------------------------------------------------------------------
1566template <> size_t GenericFill<IfcSlab>(const DB& db, const LIST& params, IfcSlab* in)
1567{
1568 size_t base = GenericFill(db,params,static_cast<IfcBuildingElement*>(in));
1569// this data structure is not used yet, so there is no code generated to fill its members
1570 return base;
1571}
1572// -----------------------------------------------------------------------------------------------------------
1573template <> size_t GenericFill<IfcVertex>(const DB& db, const LIST& params, IfcVertex* in)
1574{
1575 size_t base = GenericFill(db,params,static_cast<IfcTopologicalRepresentationItem*>(in));
1576// this data structure is not used yet, so there is no code generated to fill its members
1577 return base;
1578}
1579// -----------------------------------------------------------------------------------------------------------
1580template <> size_t GenericFill<IfcVertexPoint>(const DB& db, const LIST& params, IfcVertexPoint* in)
1581{
1582 size_t base = GenericFill(db,params,static_cast<IfcVertex*>(in));
1583// this data structure is not used yet, so there is no code generated to fill its members
1584 return base;
1585}
1586// -----------------------------------------------------------------------------------------------------------
1587template <> size_t GenericFill<IfcStructuralLinearAction>(const DB& db, const LIST& params, IfcStructuralLinearAction* in)
1588{
1589 size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
1590// this data structure is not used yet, so there is no code generated to fill its members
1591 return base;
1592}
1593// -----------------------------------------------------------------------------------------------------------
1594template <> size_t GenericFill<IfcStructuralLinearActionVarying>(const DB& db, const LIST& params, IfcStructuralLinearActionVarying* in)
1595{
1596 size_t base = GenericFill(db,params,static_cast<IfcStructuralLinearAction*>(in));
1597// this data structure is not used yet, so there is no code generated to fill its members
1598 return base;
1599}
1600// -----------------------------------------------------------------------------------------------------------
1601template <> size_t GenericFill<IfcBuildingElementProxyType>(const DB& db, const LIST& params, IfcBuildingElementProxyType* in)
1602{
1603 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
1604// this data structure is not used yet, so there is no code generated to fill its members
1605 return base;
1606}
1607// -----------------------------------------------------------------------------------------------------------
1608template <> size_t GenericFill<IfcProjectionElement>(const DB& db, const LIST& params, IfcProjectionElement* in)
1609{
1610 size_t base = GenericFill(db,params,static_cast<IfcFeatureElementAddition*>(in));
1611// this data structure is not used yet, so there is no code generated to fill its members
1612 return base;
1613}
1614// -----------------------------------------------------------------------------------------------------------
1615template <> size_t GenericFill<IfcConversionBasedUnit>(const DB& db, const LIST& params, IfcConversionBasedUnit* in)
1616{
1617 size_t base = GenericFill(db,params,static_cast<IfcNamedUnit*>(in));
1618 if (params.GetSize() < 4) { throw STEP::TypeError("expected 4 arguments to IfcConversionBasedUnit"); } do { // convert the 'Name' argument
1619 std::shared_ptr<const DataType> arg = params[base++];
1620 try { GenericConvert( in->Name, arg, db ); break; }
1621 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcConversionBasedUnit to be a `IfcLabel`")); }
1622 } while(0);
1623 do { // convert the 'ConversionFactor' argument
1624 std::shared_ptr<const DataType> arg = params[base++];
1625 try { GenericConvert( in->ConversionFactor, arg, db ); break; }
1626 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcConversionBasedUnit to be a `IfcMeasureWithUnit`")); }
1627 } while(0);
1628 return base;
1629}
1630// -----------------------------------------------------------------------------------------------------------
1631template <> size_t GenericFill<IfcGeometricRepresentationSubContext>(const DB& db, const LIST& params, IfcGeometricRepresentationSubContext* in)
1632{
1633 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationContext*>(in));
1634// this data structure is not used yet, so there is no code generated to fill its members
1635 return base;
1636}
1637// -----------------------------------------------------------------------------------------------------------
1638template <> size_t GenericFill<IfcAnnotationSurfaceOccurrence>(const DB& db, const LIST& params, IfcAnnotationSurfaceOccurrence* in)
1639{
1640 size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
1641// this data structure is not used yet, so there is no code generated to fill its members
1642 return base;
1643}
1644// -----------------------------------------------------------------------------------------------------------
1645template <> size_t GenericFill<IfcRoundedEdgeFeature>(const DB& db, const LIST& params, IfcRoundedEdgeFeature* in)
1646{
1647 size_t base = GenericFill(db,params,static_cast<IfcEdgeFeature*>(in));
1648// this data structure is not used yet, so there is no code generated to fill its members
1649 return base;
1650}
1651// -----------------------------------------------------------------------------------------------------------
1652template <> size_t GenericFill<IfcElectricDistributionPoint>(const DB& db, const LIST& params, IfcElectricDistributionPoint* in)
1653{
1654 size_t base = GenericFill(db,params,static_cast<IfcFlowController*>(in));
1655// this data structure is not used yet, so there is no code generated to fill its members
1656 return base;
1657}
1658// -----------------------------------------------------------------------------------------------------------
1659template <> size_t GenericFill<IfcCableCarrierSegmentType>(const DB& db, const LIST& params, IfcCableCarrierSegmentType* in)
1660{
1661 size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
1662// this data structure is not used yet, so there is no code generated to fill its members
1663 return base;
1664}
1665// -----------------------------------------------------------------------------------------------------------
1666template <> size_t GenericFill<IfcWallStandardCase>(const DB& db, const LIST& params, IfcWallStandardCase* in)
1667{
1668 size_t base = GenericFill(db,params,static_cast<IfcWall*>(in));
1669// this data structure is not used yet, so there is no code generated to fill its members
1670 return base;
1671}
1672// -----------------------------------------------------------------------------------------------------------
1673template <> size_t GenericFill<IfcCsgSolid>(const DB& db, const LIST& params, IfcCsgSolid* in)
1674{
1675 size_t base = GenericFill(db,params,static_cast<IfcSolidModel*>(in));
1676// this data structure is not used yet, so there is no code generated to fill its members
1677 return base;
1678}
1679// -----------------------------------------------------------------------------------------------------------
1680template <> size_t