1 /*
2 Open Asset Import Library (ASSIMP)
3 ----------------------------------------------------------------------
4
5 Copyright (c) 2006-2010, ASSIMP Development Team
6 All rights reserved.
7
8 Redistribution and use of this software in source and binary forms,
9 with or without modification, are permitted provided that the
10 following 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
26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36 OF 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
46 namespace Assimp {
47 using namespace IFC;
48
49 namespace STEP {
50
GenericFill(const DB & db,const LIST & params,IfcSurfaceStyle * in)51 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotationSurface * in)67 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowController * in)74 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBuildingStorey * in)81 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWorkControl * in)88 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWorkSchedule * in)95 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDuctSegmentType * in)102 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFace * in)109 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralSurfaceMember * in)121 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralSurfaceMemberVarying * in)128 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFaceSurface * in)135 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCostSchedule * in)142 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPlanarExtent * in)149 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPlanarBox * in)156 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcColourSpecification * in)163 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcVector * in)176 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBeam * in)192 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcColourRgb * in)199 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralPlanarAction * in)220 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralPlanarActionVarying * in)227 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSite * in)234 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDiscreteAccessoryType * in)270 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcVibrationIsolatorType * in)277 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcEvaporativeCoolerType * in)284 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDistributionChamberElementType * in)291 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFeatureElementAddition * in)298 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuredDimensionCallout * in)305 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCoolingTowerType * in)312 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCenterLineProfileDef * in)319 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWindowStyle * in)326 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcLightSourceGoniometric * in)333 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTransformerType * in)340 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcMemberType * in)347 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSurfaceOfLinearExtrusion * in)354 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcMotorConnectionType * in)361 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowTreatmentDeviceType * in)368 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDuctSilencerType * in)375 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFurnishingElementType * in)382 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSystemFurnitureElementType * in)389 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWasteTerminalType * in)396 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBSplineCurve * in)403 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBezierCurve * in)439 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcActuatorType * in)446 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDistributionControlElement * in)453 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotation * in)460 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcShellBasedSurfaceModel * in)466 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcActionRequest * in)477 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcExtrudedAreaSolid * in)484 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSystem * in)500 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFillAreaStyleHatching * in)507 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRelVoidsElement * in)514 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSurfaceCurveSweptAreaSolid * in)530 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCartesianTransformationOperator3DnonUniform * in)537 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCurtainWallType * in)555 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcEquipmentStandard * in)562 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowStorageDeviceType * in)569 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDiameterDimension * in)576 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSwitchingDeviceType * in)583 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWindow * in)590 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowTreatmentDevice * in)597 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcChillerType * in)604 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRectangleHollowProfileDef * in)611 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBoxedHalfSpace * in)618 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAxis2Placement2D * in)625 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSpaceProgram * in)637 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPoint * in)644 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCartesianPoint * in)650 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBoundedSurface * in)661 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcLoop * in)668 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPolyLoop * in)674 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTerminatorSymbol * in)685 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDimensionCurveTerminator * in)692 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTrapeziumProfileDef * in)699 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRepresentationContext * in)706 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcGeometricRepresentationContext * in)726 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCurveBoundedPlane * in)758 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSIUnit * in)765 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralReaction * in)782 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralPointReaction * in)789 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAxis1Placement * in)796 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcElectricApplianceType * in)808 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSensorType * in)815 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFurnishingElement * in)822 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcProtectiveDeviceType * in)829 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcZShapeProfileDef * in)836 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcScheduleTimeControl * in)843 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRepresentationMap * in)850 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcClosedShell * in)866 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBuildingElementPart * in)872 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBlock * in)879 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcLightFixtureType * in)886 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcOpeningElement * in)893 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcLightSourceSpot * in)899 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTendonAnchor * in)906 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcElectricFlowStorageDeviceType * in)913 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSphere * in)920 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDamperType * in)927 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcProjectOrderRecord * in)934 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDistributionChamberElement * in)941 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcMechanicalFastener * in)948 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRectangularTrimmedSurface * in)955 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcZone * in)962 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFanType * in)969 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcGeometricSet * in)976 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFillAreaStyleTiles * in)983 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCableSegmentType * in)990 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRelOverridesProperties * in)997 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcMeasureWithUnit * in)1004 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSlabType * in)1020 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcServiceLife * in)1027 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFurnitureType * in)1034 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCostItem * in)1041 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcReinforcingMesh * in)1048 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFacetedBrepWithVoids * in)1055 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcGasTerminalType * in)1062 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPile * in)1069 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFillAreaStyleTileSymbolWithStyle * in)1076 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcConstructionMaterialResource * in)1083 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotationCurveOccurrence * in)1090 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDimensionCurve * in)1097 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcGeometricCurveSet * in)1104 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRelAggregates * in)1111 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFaceBasedSurfaceModel * in)1117 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcEnergyConversionDevice * in)1128 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRampFlight * in)1135 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcVertexLoop * in)1142 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPlate * in)1149 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcUShapeProfileDef * in)1156 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFaceBound * in)1163 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFaceOuterBound * in)1181 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcOneDirectionRepeatFactor * in)1187 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBoilerType * in)1194 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcConstructionEquipmentResource * in)1201 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcComplexProperty * in)1208 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFooting * in)1224 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcConstructionProductResource * in)1231 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDerivedProfileDef * in)1238 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPropertyTableValue * in)1245 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowMeterType * in)1252 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDoorStyle * in)1259 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcUnitAssignment * in)1266 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowTerminal * in)1277 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCraneRailFShapeProfileDef * in)1284 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFlowSegment * in)1291 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcElementQuantity * in)1298 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCurtainWall * in)1315 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDiscreteAccessory * in)1322 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcGrid * in)1329 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSanitaryTerminalType * in)1336 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSubedge * in)1343 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcFilterType * in)1350 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTendon * in)1357 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralLoadGroup * in)1364 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPresentationStyleAssignment * in)1371 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralCurveMember * in)1382 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcLightSourceAmbient * in)1389 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCondition * in)1396 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPort * in)1403 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSpace * in)1410 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcHeatExchangerType * in)1427 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTankType * in)1434 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcInventory * in)1441 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTransportElementType * in)1448 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAirToAirHeatRecoveryType * in)1455 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStairFlight * in)1462 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcElectricalElement * in)1469 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSurfaceStyleWithTextures * in)1476 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBoundingBox * in)1487 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWallType * in)1513 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcMove * in)1520 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCircle * in)1527 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcOffsetCurve2D * in)1538 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPointOnCurve * in)1545 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralResultGroup * in)1552 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSectionedSpine * in)1559 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSlab * in)1566 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcVertex * in)1573 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcVertexPoint * in)1580 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralLinearAction * in)1587 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralLinearActionVarying * in)1594 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBuildingElementProxyType * in)1601 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcProjectionElement * in)1608 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcConversionBasedUnit * in)1615 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcGeometricRepresentationSubContext * in)1631 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotationSurfaceOccurrence * in)1638 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRoundedEdgeFeature * in)1645 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcElectricDistributionPoint * in)1652 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCableCarrierSegmentType * in)1659 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWallStandardCase * in)1666 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcCsgSolid * in)1673 template <> 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 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcBeamType * in)1680 template <> size_t GenericFill<IfcBeamType>(const DB& db, const LIST& params, IfcBeamType* in)
1681 {
1682 size_t base = GenericFill(db,params,static_cast<IfcBuildingElementType*>(in));
1683 // this data structure is not used yet, so there is no code generated to fill its members
1684 return base;
1685 }
1686 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotationFillArea * in)1687 template <> size_t GenericFill<IfcAnnotationFillArea>(const DB& db, const LIST& params, IfcAnnotationFillArea* in)
1688 {
1689 size_t base = GenericFill(db,params,static_cast<IfcGeometricRepresentationItem*>(in));
1690 // this data structure is not used yet, so there is no code generated to fill its members
1691 return base;
1692 }
1693 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralCurveMemberVarying * in)1694 template <> size_t GenericFill<IfcStructuralCurveMemberVarying>(const DB& db, const LIST& params, IfcStructuralCurveMemberVarying* in)
1695 {
1696 size_t base = GenericFill(db,params,static_cast<IfcStructuralCurveMember*>(in));
1697 // this data structure is not used yet, so there is no code generated to fill its members
1698 return base;
1699 }
1700 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPointOnSurface * in)1701 template <> size_t GenericFill<IfcPointOnSurface>(const DB& db, const LIST& params, IfcPointOnSurface* in)
1702 {
1703 size_t base = GenericFill(db,params,static_cast<IfcPoint*>(in));
1704 // this data structure is not used yet, so there is no code generated to fill its members
1705 return base;
1706 }
1707 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcOrderAction * in)1708 template <> size_t GenericFill<IfcOrderAction>(const DB& db, const LIST& params, IfcOrderAction* in)
1709 {
1710 size_t base = GenericFill(db,params,static_cast<IfcTask*>(in));
1711 // this data structure is not used yet, so there is no code generated to fill its members
1712 return base;
1713 }
1714 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcEdgeLoop * in)1715 template <> size_t GenericFill<IfcEdgeLoop>(const DB& db, const LIST& params, IfcEdgeLoop* in)
1716 {
1717 size_t base = GenericFill(db,params,static_cast<IfcLoop*>(in));
1718 // this data structure is not used yet, so there is no code generated to fill its members
1719 return base;
1720 }
1721 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotationFillAreaOccurrence * in)1722 template <> size_t GenericFill<IfcAnnotationFillAreaOccurrence>(const DB& db, const LIST& params, IfcAnnotationFillAreaOccurrence* in)
1723 {
1724 size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
1725 // this data structure is not used yet, so there is no code generated to fill its members
1726 return base;
1727 }
1728 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcWorkPlan * in)1729 template <> size_t GenericFill<IfcWorkPlan>(const DB& db, const LIST& params, IfcWorkPlan* in)
1730 {
1731 size_t base = GenericFill(db,params,static_cast<IfcWorkControl*>(in));
1732 // this data structure is not used yet, so there is no code generated to fill its members
1733 return base;
1734 }
1735 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcEllipse * in)1736 template <> size_t GenericFill<IfcEllipse>(const DB& db, const LIST& params, IfcEllipse* in)
1737 {
1738 size_t base = GenericFill(db,params,static_cast<IfcConic*>(in));
1739 if (params.GetSize() < 3) { throw STEP::TypeError("expected 3 arguments to IfcEllipse"); } do { // convert the 'SemiAxis1' argument
1740 std::shared_ptr<const DataType> arg = params[base++];
1741 try { GenericConvert( in->SemiAxis1, arg, db ); break; }
1742 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
1743 } while(0);
1744 do { // convert the 'SemiAxis2' argument
1745 std::shared_ptr<const DataType> arg = params[base++];
1746 try { GenericConvert( in->SemiAxis2, arg, db ); break; }
1747 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcEllipse to be a `IfcPositiveLengthMeasure`")); }
1748 } while(0);
1749 return base;
1750 }
1751 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcProductDefinitionShape * in)1752 template <> size_t GenericFill<IfcProductDefinitionShape>(const DB& db, const LIST& params, IfcProductDefinitionShape* in)
1753 {
1754 size_t base = GenericFill(db,params,static_cast<IfcProductRepresentation*>(in));
1755 // this data structure is not used yet, so there is no code generated to fill its members
1756 return base;
1757 }
1758 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcProjectionCurve * in)1759 template <> size_t GenericFill<IfcProjectionCurve>(const DB& db, const LIST& params, IfcProjectionCurve* in)
1760 {
1761 size_t base = GenericFill(db,params,static_cast<IfcAnnotationCurveOccurrence*>(in));
1762 // this data structure is not used yet, so there is no code generated to fill its members
1763 return base;
1764 }
1765 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcElectricalCircuit * in)1766 template <> size_t GenericFill<IfcElectricalCircuit>(const DB& db, const LIST& params, IfcElectricalCircuit* in)
1767 {
1768 size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
1769 // this data structure is not used yet, so there is no code generated to fill its members
1770 return base;
1771 }
1772 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcRationalBezierCurve * in)1773 template <> size_t GenericFill<IfcRationalBezierCurve>(const DB& db, const LIST& params, IfcRationalBezierCurve* in)
1774 {
1775 size_t base = GenericFill(db,params,static_cast<IfcBezierCurve*>(in));
1776 // this data structure is not used yet, so there is no code generated to fill its members
1777 return base;
1778 }
1779 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralPointAction * in)1780 template <> size_t GenericFill<IfcStructuralPointAction>(const DB& db, const LIST& params, IfcStructuralPointAction* in)
1781 {
1782 size_t base = GenericFill(db,params,static_cast<IfcStructuralAction*>(in));
1783 // this data structure is not used yet, so there is no code generated to fill its members
1784 return base;
1785 }
1786 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPipeSegmentType * in)1787 template <> size_t GenericFill<IfcPipeSegmentType>(const DB& db, const LIST& params, IfcPipeSegmentType* in)
1788 {
1789 size_t base = GenericFill(db,params,static_cast<IfcFlowSegmentType*>(in));
1790 // this data structure is not used yet, so there is no code generated to fill its members
1791 return base;
1792 }
1793 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTwoDirectionRepeatFactor * in)1794 template <> size_t GenericFill<IfcTwoDirectionRepeatFactor>(const DB& db, const LIST& params, IfcTwoDirectionRepeatFactor* in)
1795 {
1796 size_t base = GenericFill(db,params,static_cast<IfcOneDirectionRepeatFactor*>(in));
1797 // this data structure is not used yet, so there is no code generated to fill its members
1798 return base;
1799 }
1800 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcShapeRepresentation * in)1801 template <> size_t GenericFill<IfcShapeRepresentation>(const DB& db, const LIST& params, IfcShapeRepresentation* in)
1802 {
1803 size_t base = GenericFill(db,params,static_cast<IfcShapeModel*>(in));
1804 // this data structure is not used yet, so there is no code generated to fill its members
1805 return base;
1806 }
1807 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPropertySet * in)1808 template <> size_t GenericFill<IfcPropertySet>(const DB& db, const LIST& params, IfcPropertySet* in)
1809 {
1810 size_t base = GenericFill(db,params,static_cast<IfcPropertySetDefinition*>(in));
1811 if (params.GetSize() < 5) { throw STEP::TypeError("expected 5 arguments to IfcPropertySet"); } do { // convert the 'HasProperties' argument
1812 std::shared_ptr<const DataType> arg = params[base++];
1813 try { GenericConvert( in->HasProperties, arg, db ); break; }
1814 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcPropertySet to be a `SET [1:?] OF IfcProperty`")); }
1815 } while(0);
1816 return base;
1817 }
1818 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcSurfaceStyleRendering * in)1819 template <> size_t GenericFill<IfcSurfaceStyleRendering>(const DB& db, const LIST& params, IfcSurfaceStyleRendering* in)
1820 {
1821 size_t base = GenericFill(db,params,static_cast<IfcSurfaceStyleShading*>(in));
1822 if (params.GetSize() < 9) { throw STEP::TypeError("expected 9 arguments to IfcSurfaceStyleRendering"); } do { // convert the 'Transparency' argument
1823 std::shared_ptr<const DataType> arg = params[base++];
1824 if (dynamic_cast<const UNSET*>(&*arg)) break;
1825 try { GenericConvert( in->Transparency, arg, db ); break; }
1826 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 1 to IfcSurfaceStyleRendering to be a `IfcNormalisedRatioMeasure`")); }
1827 } while(0);
1828 do { // convert the 'DiffuseColour' argument
1829 std::shared_ptr<const DataType> arg = params[base++];
1830 if (dynamic_cast<const UNSET*>(&*arg)) break;
1831 try { GenericConvert( in->DiffuseColour, arg, db ); break; }
1832 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 2 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
1833 } while(0);
1834 do { // convert the 'TransmissionColour' argument
1835 std::shared_ptr<const DataType> arg = params[base++];
1836 if (dynamic_cast<const UNSET*>(&*arg)) break;
1837 try { GenericConvert( in->TransmissionColour, arg, db ); break; }
1838 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 3 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
1839 } while(0);
1840 do { // convert the 'DiffuseTransmissionColour' argument
1841 std::shared_ptr<const DataType> arg = params[base++];
1842 if (dynamic_cast<const UNSET*>(&*arg)) break;
1843 try { GenericConvert( in->DiffuseTransmissionColour, arg, db ); break; }
1844 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 4 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
1845 } while(0);
1846 do { // convert the 'ReflectionColour' argument
1847 std::shared_ptr<const DataType> arg = params[base++];
1848 if (dynamic_cast<const UNSET*>(&*arg)) break;
1849 try { GenericConvert( in->ReflectionColour, arg, db ); break; }
1850 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 5 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
1851 } while(0);
1852 do { // convert the 'SpecularColour' argument
1853 std::shared_ptr<const DataType> arg = params[base++];
1854 if (dynamic_cast<const UNSET*>(&*arg)) break;
1855 try { GenericConvert( in->SpecularColour, arg, db ); break; }
1856 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 6 to IfcSurfaceStyleRendering to be a `IfcColourOrFactor`")); }
1857 } while(0);
1858 do { // convert the 'SpecularHighlight' argument
1859 std::shared_ptr<const DataType> arg = params[base++];
1860 if (dynamic_cast<const UNSET*>(&*arg)) break;
1861 try { GenericConvert( in->SpecularHighlight, arg, db ); break; }
1862 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 7 to IfcSurfaceStyleRendering to be a `IfcSpecularHighlightSelect`")); }
1863 } while(0);
1864 do { // convert the 'ReflectanceMethod' argument
1865 std::shared_ptr<const DataType> arg = params[base++];
1866 try { GenericConvert( in->ReflectanceMethod, arg, db ); break; }
1867 catch (const TypeError& t) { throw TypeError(t.what() + std::string(" - expected argument 8 to IfcSurfaceStyleRendering to be a `IfcReflectanceMethodEnum`")); }
1868 } while(0);
1869 return base;
1870 }
1871 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcDistributionPort * in)1872 template <> size_t GenericFill<IfcDistributionPort>(const DB& db, const LIST& params, IfcDistributionPort* in)
1873 {
1874 size_t base = GenericFill(db,params,static_cast<IfcPort*>(in));
1875 // this data structure is not used yet, so there is no code generated to fill its members
1876 return base;
1877 }
1878 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcPipeFittingType * in)1879 template <> size_t GenericFill<IfcPipeFittingType>(const DB& db, const LIST& params, IfcPipeFittingType* in)
1880 {
1881 size_t base = GenericFill(db,params,static_cast<IfcFlowFittingType*>(in));
1882 // this data structure is not used yet, so there is no code generated to fill its members
1883 return base;
1884 }
1885 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcTransportElement * in)1886 template <> size_t GenericFill<IfcTransportElement>(const DB& db, const LIST& params, IfcTransportElement* in)
1887 {
1888 size_t base = GenericFill(db,params,static_cast<IfcElement*>(in));
1889 // this data structure is not used yet, so there is no code generated to fill its members
1890 return base;
1891 }
1892 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcAnnotationTextOccurrence * in)1893 template <> size_t GenericFill<IfcAnnotationTextOccurrence>(const DB& db, const LIST& params, IfcAnnotationTextOccurrence* in)
1894 {
1895 size_t base = GenericFill(db,params,static_cast<IfcAnnotationOccurrence*>(in));
1896 // this data structure is not used yet, so there is no code generated to fill its members
1897 return base;
1898 }
1899 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcStructuralAnalysisModel * in)1900 template <> size_t GenericFill<IfcStructuralAnalysisModel>(const DB& db, const LIST& params, IfcStructuralAnalysisModel* in)
1901 {
1902 size_t base = GenericFill(db,params,static_cast<IfcSystem*>(in));
1903 // this data structure is not used yet, so there is no code generated to fill its members
1904 return base;
1905 }
1906 // -----------------------------------------------------------------------------------------------------------
GenericFill(const DB & db,const LIST & params,IfcConditionCriterion * in)1907 template <> size_t GenericFill<IfcConditionCriterion>(const DB& db, const LIST& params, IfcConditionCriterion* in)
1908 {
1909 size_t base = GenericFill(db,params,static_cast<IfcControl*>(in));
1910 // this data structure is not used yet, so there is no code generated to fill its members
1911 return base;
1912 }
1913
1914 } // ! STEP
1915 } // ! Assimp
1916
1917 #endif
1918