?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / Test / SystemLib / OSGFCDPtrTestFCNullCheckAccessBase.cpp
blobe67fd484723f14deb6fedc54bbcbc74a7c808495
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2006 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 /*****************************************************************************\
40 *****************************************************************************
41 ** **
42 ** This file is automatically generated. **
43 ** **
44 ** Any changes made to this file WILL be lost when it is **
45 ** regenerated, which can become necessary at any time. **
46 ** **
47 ** Do not change this file, changes should be done in the derived **
48 ** class FCDPtrTestFCNullCheckAccess!
49 ** **
50 *****************************************************************************
51 \*****************************************************************************/
52
53 #include <cstdlib>
54 #include <cstdio>
55
56 #include "OSGConfig.h"
57
58
59
60 #include "OSGFCDTestFC.h" // FieldSFPub_ptr Class
61 #include "OSGFCDSParTestFC.h" // FieldSFPub_spchildptr Class
62
63 #include "OSGFCDPtrTestFCNullCheckAccessBase.h"
64 #include "OSGFCDPtrTestFCNullCheckAccess.h"
65
66 #include <boost/bind.hpp>
67
68 #ifdef WIN32 // turn off 'this' : used in base member initializer list warning
69 #pragma warning(disable:4355)
70 #endif
71
72 OSG_BEGIN_NAMESPACE
73
74 /***************************************************************************\
75 * Description *
76 \***************************************************************************/
77
78 /*! \class OSG::FCDPtrTestFCNullCheckAccess
79
80 */
81
82 /***************************************************************************\
83 * Field Documentation *
84 \***************************************************************************/
85
86 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPub_ptr
87
88 */
89
90 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPub_weakptr
91
92 */
93
94 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPub_mpchildptr
95
96 */
97
98 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPro_ptr
99
100 */
101
102 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPro_weakptr
103
104 */
105
106 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPro_mpchildptr
107
108 */
109
110 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFNo_ptr
111
112 */
113
114 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFNo_weakptr
115
116 */
117
118 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFNo_mpchildptr
119
120 */
121
122 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPub_ptr
123
124 */
125
126 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPub_weakptr
127
128 */
129
130 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPub_mpchildptr
131
132 */
133
134 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPro_ptr
135
136 */
137
138 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPro_weakptr
139
140 */
141
142 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPro_mpchildptr
143
144 */
145
146 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFNo_ptr
147
148 */
149
150 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFNo_weakptr
151
152 */
153
154 /*! \var FCDTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFNo_mpchildptr
155
156 */
157
158 /*! \var FCDSParTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPub_spchildptr
159
160 */
161
162 /*! \var FCDSParTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFPro_spchildptr
163
164 */
165
166 /*! \var FCDSParTestFC * FCDPtrTestFCNullCheckAccessBase::_sfFieldSFNo_spchildptr
167
168 */
169
170 /*! \var FCDSParTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPub_spchildptr
171
172 */
173
174 /*! \var FCDSParTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFPro_spchildptr
175
176 */
177
178 /*! \var FCDSParTestFC * FCDPtrTestFCNullCheckAccessBase::_mfFieldMFNo_spchildptr
179
180 */
181
182
183 /***************************************************************************\
184 * FieldType/FieldTrait Instantiation *
185 \***************************************************************************/
186
187 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
188 PointerType FieldTraits<FCDPtrTestFCNullCheckAccess *, nsOSG>::_type(
189 "FCDPtrTestFCNullCheckAccessPtr",
190 "NodeCorePtr",
191 FCDPtrTestFCNullCheckAccess::getClassType(),
192 nsOSG);
193 #endif
194
195 OSG_FIELDTRAITS_GETTYPE_NS(FCDPtrTestFCNullCheckAccess *, nsOSG)
196
197 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
198 FCDPtrTestFCNullCheckAccess *,
199 nsOSG);
200
201 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
202 FCDPtrTestFCNullCheckAccess *,
203 nsOSG);
204
205 /***************************************************************************\
206 * Field Description *
207 \***************************************************************************/
208
209 void FCDPtrTestFCNullCheckAccessBase::classDescInserter(TypeObject &oType)
210 {
211 FieldDescriptionBase *pDesc = NULL;
212
213
214 pDesc = new SFUnrecFCDTestFCPtr::Description(
215 SFUnrecFCDTestFCPtr::getClassType(),
216 "fieldSFPub_ptr",
217 "",
218 FieldSFPub_ptrFieldId, FieldSFPub_ptrFieldMask,
219 false,
220 (Field::SFDefaultFlags | Field::FNullCheckAccess),
221 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPub_ptr),
222 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPub_ptr));
223
224 oType.addInitialDesc(pDesc);
225
226 pDesc = new SFWeakFCDTestFCPtr::Description(
227 SFWeakFCDTestFCPtr::getClassType(),
228 "fieldSFPub_weakptr",
229 "",
230 FieldSFPub_weakptrFieldId, FieldSFPub_weakptrFieldMask,
231 false,
232 (Field::SFDefaultFlags | Field::FNullCheckAccess),
233 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPub_weakptr),
234 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPub_weakptr));
235
236 oType.addInitialDesc(pDesc);
237
238 pDesc = new SFUnrecChildFCDTestFCPtr::Description(
239 SFUnrecChildFCDTestFCPtr::getClassType(),
240 "fieldSFPub_mpchildptr",
241 "",
242 FieldSFPub_mpchildptrFieldId, FieldSFPub_mpchildptrFieldMask,
243 false,
244 (Field::SFDefaultFlags | Field::FNullCheckAccess),
245 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPub_mpchildptr),
246 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPub_mpchildptr));
247
248 oType.addInitialDesc(pDesc);
249
250 pDesc = new SFUnrecFCDTestFCPtr::Description(
251 SFUnrecFCDTestFCPtr::getClassType(),
252 "fieldSFPro_ptr",
253 "",
254 FieldSFPro_ptrFieldId, FieldSFPro_ptrFieldMask,
255 false,
256 (Field::SFDefaultFlags | Field::FNullCheckAccess),
257 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPro_ptr),
258 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPro_ptr));
259
260 oType.addInitialDesc(pDesc);
261
262 pDesc = new SFWeakFCDTestFCPtr::Description(
263 SFWeakFCDTestFCPtr::getClassType(),
264 "fieldSFPro_weakptr",
265 "",
266 FieldSFPro_weakptrFieldId, FieldSFPro_weakptrFieldMask,
267 false,
268 (Field::SFDefaultFlags | Field::FNullCheckAccess),
269 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPro_weakptr),
270 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPro_weakptr));
271
272 oType.addInitialDesc(pDesc);
273
274 pDesc = new SFUnrecChildFCDTestFCPtr::Description(
275 SFUnrecChildFCDTestFCPtr::getClassType(),
276 "fieldSFPro_mpchildptr",
277 "",
278 FieldSFPro_mpchildptrFieldId, FieldSFPro_mpchildptrFieldMask,
279 false,
280 (Field::SFDefaultFlags | Field::FNullCheckAccess),
281 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPro_mpchildptr),
282 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPro_mpchildptr));
283
284 oType.addInitialDesc(pDesc);
285
286 pDesc = new SFUnrecFCDTestFCPtr::Description(
287 SFUnrecFCDTestFCPtr::getClassType(),
288 "fieldSFNo_ptr",
289 "",
290 FieldSFNo_ptrFieldId, FieldSFNo_ptrFieldMask,
291 false,
292 (Field::SFDefaultFlags | Field::FNullCheckAccess),
293 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
294 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
295
296 oType.addInitialDesc(pDesc);
297
298 pDesc = new SFWeakFCDTestFCPtr::Description(
299 SFWeakFCDTestFCPtr::getClassType(),
300 "fieldSFNo_weakptr",
301 "",
302 FieldSFNo_weakptrFieldId, FieldSFNo_weakptrFieldMask,
303 false,
304 (Field::SFDefaultFlags | Field::FNullCheckAccess),
305 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
306 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
307
308 oType.addInitialDesc(pDesc);
309
310 pDesc = new SFUnrecChildFCDTestFCPtr::Description(
311 SFUnrecChildFCDTestFCPtr::getClassType(),
312 "fieldSFNo_mpchildptr",
313 "",
314 FieldSFNo_mpchildptrFieldId, FieldSFNo_mpchildptrFieldMask,
315 false,
316 (Field::SFDefaultFlags | Field::FNullCheckAccess),
317 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
318 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
319
320 oType.addInitialDesc(pDesc);
321
322 pDesc = new MFUnrecFCDTestFCPtr::Description(
323 MFUnrecFCDTestFCPtr::getClassType(),
324 "fieldMFPub_ptr",
325 "",
326 FieldMFPub_ptrFieldId, FieldMFPub_ptrFieldMask,
327 false,
328 (Field::MFDefaultFlags | Field::FNullCheckAccess),
329 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPub_ptr),
330 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPub_ptr));
331
332 oType.addInitialDesc(pDesc);
333
334 pDesc = new MFWeakFCDTestFCPtr::Description(
335 MFWeakFCDTestFCPtr::getClassType(),
336 "fieldMFPub_weakptr",
337 "",
338 FieldMFPub_weakptrFieldId, FieldMFPub_weakptrFieldMask,
339 false,
340 (Field::MFDefaultFlags | Field::FNullCheckAccess),
341 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPub_weakptr),
342 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPub_weakptr));
343
344 oType.addInitialDesc(pDesc);
345
346 pDesc = new MFUnrecChildFCDTestFCPtr::Description(
347 MFUnrecChildFCDTestFCPtr::getClassType(),
348 "fieldMFPub_mpchildptr",
349 "",
350 FieldMFPub_mpchildptrFieldId, FieldMFPub_mpchildptrFieldMask,
351 false,
352 (Field::MFDefaultFlags | Field::FNullCheckAccess),
353 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPub_mpchildptr),
354 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPub_mpchildptr));
355
356 oType.addInitialDesc(pDesc);
357
358 pDesc = new MFUnrecFCDTestFCPtr::Description(
359 MFUnrecFCDTestFCPtr::getClassType(),
360 "fieldMFPro_ptr",
361 "",
362 FieldMFPro_ptrFieldId, FieldMFPro_ptrFieldMask,
363 false,
364 (Field::MFDefaultFlags | Field::FNullCheckAccess),
365 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPro_ptr),
366 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPro_ptr));
367
368 oType.addInitialDesc(pDesc);
369
370 pDesc = new MFWeakFCDTestFCPtr::Description(
371 MFWeakFCDTestFCPtr::getClassType(),
372 "fieldMFPro_weakptr",
373 "",
374 FieldMFPro_weakptrFieldId, FieldMFPro_weakptrFieldMask,
375 false,
376 (Field::MFDefaultFlags | Field::FNullCheckAccess),
377 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPro_weakptr),
378 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPro_weakptr));
379
380 oType.addInitialDesc(pDesc);
381
382 pDesc = new MFUnrecChildFCDTestFCPtr::Description(
383 MFUnrecChildFCDTestFCPtr::getClassType(),
384 "fieldMFPro_mpchildptr",
385 "",
386 FieldMFPro_mpchildptrFieldId, FieldMFPro_mpchildptrFieldMask,
387 false,
388 (Field::MFDefaultFlags | Field::FNullCheckAccess),
389 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPro_mpchildptr),
390 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPro_mpchildptr));
391
392 oType.addInitialDesc(pDesc);
393
394 pDesc = new MFUnrecFCDTestFCPtr::Description(
395 MFUnrecFCDTestFCPtr::getClassType(),
396 "fieldMFNo_ptr",
397 "",
398 FieldMFNo_ptrFieldId, FieldMFNo_ptrFieldMask,
399 false,
400 (Field::MFDefaultFlags | Field::FNullCheckAccess),
401 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
402 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
403
404 oType.addInitialDesc(pDesc);
405
406 pDesc = new MFWeakFCDTestFCPtr::Description(
407 MFWeakFCDTestFCPtr::getClassType(),
408 "fieldMFNo_weakptr",
409 "",
410 FieldMFNo_weakptrFieldId, FieldMFNo_weakptrFieldMask,
411 false,
412 (Field::MFDefaultFlags | Field::FNullCheckAccess),
413 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
414 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
415
416 oType.addInitialDesc(pDesc);
417
418 pDesc = new MFUnrecChildFCDTestFCPtr::Description(
419 MFUnrecChildFCDTestFCPtr::getClassType(),
420 "fieldMFNo_mpchildptr",
421 "",
422 FieldMFNo_mpchildptrFieldId, FieldMFNo_mpchildptrFieldMask,
423 false,
424 (Field::MFDefaultFlags | Field::FNullCheckAccess),
425 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
426 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
427
428 oType.addInitialDesc(pDesc);
429
430 pDesc = new SFUnrecChildFCDSParTestFCPtr::Description(
431 SFUnrecChildFCDSParTestFCPtr::getClassType(),
432 "fieldSFPub_spchildptr",
433 "",
434 FieldSFPub_spchildptrFieldId, FieldSFPub_spchildptrFieldMask,
435 false,
436 (Field::SFDefaultFlags | Field::FNullCheckAccess),
437 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPub_spchildptr),
438 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPub_spchildptr));
439
440 oType.addInitialDesc(pDesc);
441
442 pDesc = new SFUnrecChildFCDSParTestFCPtr::Description(
443 SFUnrecChildFCDSParTestFCPtr::getClassType(),
444 "fieldSFPro_spchildptr",
445 "",
446 FieldSFPro_spchildptrFieldId, FieldSFPro_spchildptrFieldMask,
447 false,
448 (Field::SFDefaultFlags | Field::FNullCheckAccess),
449 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldSFPro_spchildptr),
450 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldSFPro_spchildptr));
451
452 oType.addInitialDesc(pDesc);
453
454 pDesc = new SFUnrecChildFCDSParTestFCPtr::Description(
455 SFUnrecChildFCDSParTestFCPtr::getClassType(),
456 "fieldSFNo_spchildptr",
457 "",
458 FieldSFNo_spchildptrFieldId, FieldSFNo_spchildptrFieldMask,
459 false,
460 (Field::SFDefaultFlags | Field::FNullCheckAccess),
461 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
462 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
463
464 oType.addInitialDesc(pDesc);
465
466 pDesc = new MFUnrecChildFCDSParTestFCPtr::Description(
467 MFUnrecChildFCDSParTestFCPtr::getClassType(),
468 "fieldMFPub_spchildptr",
469 "",
470 FieldMFPub_spchildptrFieldId, FieldMFPub_spchildptrFieldMask,
471 false,
472 (Field::MFDefaultFlags | Field::FNullCheckAccess),
473 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPub_spchildptr),
474 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPub_spchildptr));
475
476 oType.addInitialDesc(pDesc);
477
478 pDesc = new MFUnrecChildFCDSParTestFCPtr::Description(
479 MFUnrecChildFCDSParTestFCPtr::getClassType(),
480 "fieldMFPro_spchildptr",
481 "",
482 FieldMFPro_spchildptrFieldId, FieldMFPro_spchildptrFieldMask,
483 false,
484 (Field::MFDefaultFlags | Field::FNullCheckAccess),
485 static_cast<FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::editHandleFieldMFPro_spchildptr),
486 static_cast<FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::getHandleFieldMFPro_spchildptr));
487
488 oType.addInitialDesc(pDesc);
489
490 pDesc = new MFUnrecChildFCDSParTestFCPtr::Description(
491 MFUnrecChildFCDSParTestFCPtr::getClassType(),
492 "fieldMFNo_spchildptr",
493 "",
494 FieldMFNo_spchildptrFieldId, FieldMFNo_spchildptrFieldMask,
495 false,
496 (Field::MFDefaultFlags | Field::FNullCheckAccess),
497 static_cast <FieldEditMethodSig>(&FCDPtrTestFCNullCheckAccess::invalidEditField),
498 static_cast <FieldGetMethodSig >(&FCDPtrTestFCNullCheckAccess::invalidGetField));
499
500 oType.addInitialDesc(pDesc);
501 }
502
503
504 FCDPtrTestFCNullCheckAccessBase::TypeObject FCDPtrTestFCNullCheckAccessBase::_type(
505 FCDPtrTestFCNullCheckAccessBase::getClassname(),
506 Inherited::getClassname(),
507 "NULL",
508 nsOSG, //Namespace
509 reinterpret_cast<PrototypeCreateF>(&FCDPtrTestFCNullCheckAccessBase::createEmptyLocal),
510 FCDPtrTestFCNullCheckAccess::initMethod,
511 FCDPtrTestFCNullCheckAccess::exitMethod,
512 reinterpret_cast<InitalInsertDescFunc>(&FCDPtrTestFCNullCheckAccess::classDescInserter),
513 false,
514 0,
515 "<?xml version=\"1.0\" ?>\n"
516 "\n"
517 "<FieldContainer\n"
518 "\tname=\"FCDPtrTestFCNullCheckAccess\"\n"
519 "\tparent=\"NodeCore\"\n"
520 "\tlibrary=\"System\"\n"
521 "\tstructure=\"concrete\"\n"
522 "\tpointerfieldtypes=\"both\"\n"
523 "\tsystemcomponent=\"true\"\n"
524 "\tparentsystemcomponent=\"true\"\n"
525 " isNodeCore=\"true\"\n"
526 ">\n"
527 " <!-- SF, multi parent, public -->\n"
528 " <Field\n"
529 " name = \"fieldSFPub_ptr\"\n"
530 " type = \"FCDTestFC\"\n"
531 " cardinality = \"single\"\n"
532 " visibility = \"external\"\n"
533 " defaultValue = \"0\"\n"
534 " access = \"public\"\n"
535 " category = \"pointer\"\n"
536 " ptrFieldAccess = \"nullCheck\"\n"
537 " >\n"
538 " </Field>\n"
539 "\n"
540 " <Field\n"
541 " name = \"fieldSFPub_weakptr\"\n"
542 " type = \"FCDTestFC\"\n"
543 " cardinality = \"single\"\n"
544 " visibility = \"external\"\n"
545 " defaultValue = \"0\"\n"
546 " access = \"public\"\n"
547 " category = \"weakpointer\"\n"
548 " ptrFieldAccess = \"nullCheck\"\n"
549 " >\n"
550 " </Field>\n"
551 "\n"
552 " <Field\n"
553 " name = \"fieldSFPub_mpchildptr\"\n"
554 " type = \"FCDTestFC\"\n"
555 " cardinality = \"single\"\n"
556 " visibility = \"external\"\n"
557 " defaultValue = \"0\"\n"
558 " access = \"public\"\n"
559 " category = \"childpointer\"\n"
560 " linkParentField=\"Parents\"\n"
561 " ptrFieldAccess = \"nullCheck\"\n"
562 " >\n"
563 " </Field>\n"
564 "\n"
565 "\n"
566 "\n"
567 "\n"
568 "\n"
569 " <!-- SF, multi parent, protected -->\n"
570 " <Field\n"
571 " name = \"fieldSFPro_ptr\"\n"
572 " type = \"FCDTestFC\"\n"
573 " cardinality = \"single\"\n"
574 " visibility = \"external\"\n"
575 " defaultValue = \"0\"\n"
576 " access = \"protected\"\n"
577 " category = \"pointer\"\n"
578 " ptrFieldAccess = \"nullCheck\"\n"
579 " >\n"
580 " </Field>\n"
581 "\n"
582 " <Field\n"
583 " name = \"fieldSFPro_weakptr\"\n"
584 " type = \"FCDTestFC\"\n"
585 " cardinality = \"single\"\n"
586 " visibility = \"external\"\n"
587 " defaultValue = \"0\"\n"
588 " access = \"protected\"\n"
589 " category = \"weakpointer\"\n"
590 " ptrFieldAccess = \"nullCheck\"\n"
591 " >\n"
592 " </Field>\n"
593 "\n"
594 " <Field\n"
595 " name = \"fieldSFPro_mpchildptr\"\n"
596 " type = \"FCDTestFC\"\n"
597 " cardinality = \"single\"\n"
598 " visibility = \"external\"\n"
599 " defaultValue = \"0\"\n"
600 " access = \"protected\"\n"
601 " category = \"childpointer\"\n"
602 " linkParentField=\"Parents\"\n"
603 " ptrFieldAccess = \"nullCheck\"\n"
604 " >\n"
605 " </Field>\n"
606 "\n"
607 "\n"
608 "\n"
609 "\n"
610 " <!-- SF, multi parent, none -->\n"
611 " <Field\n"
612 " name = \"fieldSFNo_ptr\"\n"
613 " type = \"FCDTestFC\"\n"
614 " cardinality = \"single\"\n"
615 " visibility = \"external\"\n"
616 " defaultValue = \"0\"\n"
617 " access = \"none\"\n"
618 " category = \"pointer\"\n"
619 " ptrFieldAccess = \"nullCheck\"\n"
620 " >\n"
621 " </Field>\n"
622 "\n"
623 " <Field\n"
624 " name = \"fieldSFNo_weakptr\"\n"
625 " type = \"FCDTestFC\"\n"
626 " cardinality = \"single\"\n"
627 " visibility = \"external\"\n"
628 " defaultValue = \"0\"\n"
629 " access = \"none\"\n"
630 " category = \"weakpointer\"\n"
631 " ptrFieldAccess = \"nullCheck\"\n"
632 " >\n"
633 " </Field>\n"
634 "\n"
635 " <Field\n"
636 " name = \"fieldSFNo_mpchildptr\"\n"
637 " type = \"FCDTestFC\"\n"
638 " cardinality = \"single\"\n"
639 " visibility = \"external\"\n"
640 " defaultValue = \"0\"\n"
641 " access = \"none\"\n"
642 " category = \"childpointer\"\n"
643 " linkParentField=\"Parents\"\n"
644 " ptrFieldAccess = \"nullCheck\"\n"
645 " >\n"
646 " </Field>\n"
647 "\n"
648 "\n"
649 "\n"
650 "\n"
651 "\n"
652 " <!-- MF, multi parent, public -->\n"
653 " <Field\n"
654 " name = \"fieldMFPub_ptr\"\n"
655 " type = \"FCDTestFC\"\n"
656 " cardinality = \"multi\"\n"
657 " visibility = \"external\"\n"
658 " defaultValue = \"0\"\n"
659 " access = \"public\"\n"
660 " category = \"pointer\"\n"
661 " ptrFieldAccess = \"nullCheck\"\n"
662 " >\n"
663 " </Field>\n"
664 "\n"
665 " <Field\n"
666 " name = \"fieldMFPub_weakptr\"\n"
667 " type = \"FCDTestFC\"\n"
668 " cardinality = \"multi\"\n"
669 " visibility = \"external\"\n"
670 " defaultValue = \"0\"\n"
671 " access = \"public\"\n"
672 " category = \"weakpointer\"\n"
673 " ptrFieldAccess = \"nullCheck\"\n"
674 " >\n"
675 " </Field>\n"
676 "\n"
677 " <Field\n"
678 " name = \"fieldMFPub_mpchildptr\"\n"
679 " type = \"FCDTestFC\"\n"
680 " cardinality = \"multi\"\n"
681 " visibility = \"external\"\n"
682 " defaultValue = \"0\"\n"
683 " access = \"public\"\n"
684 " category = \"childpointer\"\n"
685 " linkParentField=\"Parents\"\n"
686 " ptrFieldAccess = \"nullCheck\"\n"
687 " >\n"
688 " </Field>\n"
689 "\n"
690 "\n"
691 "\n"
692 "\n"
693 " <!-- MF, multi parent, protected -->\n"
694 "\n"
695 " <Field\n"
696 " name = \"fieldMFPro_ptr\"\n"
697 " type = \"FCDTestFC\"\n"
698 " cardinality = \"multi\"\n"
699 " visibility = \"external\"\n"
700 " defaultValue = \"0\"\n"
701 " access = \"protected\"\n"
702 " category = \"pointer\"\n"
703 " ptrFieldAccess = \"nullCheck\"\n"
704 " >\n"
705 " </Field>\n"
706 "\n"
707 " <Field\n"
708 " name = \"fieldMFPro_weakptr\"\n"
709 " type = \"FCDTestFC\"\n"
710 " cardinality = \"multi\"\n"
711 " visibility = \"external\"\n"
712 " defaultValue = \"0\"\n"
713 " access = \"protected\"\n"
714 " category = \"weakpointer\"\n"
715 " ptrFieldAccess = \"nullCheck\"\n"
716 " >\n"
717 " </Field>\n"
718 "\n"
719 " <Field\n"
720 " name = \"fieldMFPro_mpchildptr\"\n"
721 " type = \"FCDTestFC\"\n"
722 " cardinality = \"multi\"\n"
723 " visibility = \"external\"\n"
724 " defaultValue = \"0\"\n"
725 " access = \"protected\"\n"
726 " category = \"childpointer\"\n"
727 " linkParentField=\"Parents\"\n"
728 " ptrFieldAccess = \"nullCheck\"\n"
729 " >\n"
730 " </Field>\n"
731 "\n"
732 "\n"
733 "\n"
734 "\n"
735 " <!-- MF, multi parent, none -->\n"
736 " <Field\n"
737 " name = \"fieldMFNo_ptr\"\n"
738 " type = \"FCDTestFC\"\n"
739 " cardinality = \"multi\"\n"
740 " visibility = \"external\"\n"
741 " defaultValue = \"0\"\n"
742 " access = \"none\"\n"
743 " category = \"pointer\"\n"
744 " ptrFieldAccess = \"nullCheck\"\n"
745 " >\n"
746 " </Field>\n"
747 "\n"
748 " <Field\n"
749 " name = \"fieldMFNo_weakptr\"\n"
750 " type = \"FCDTestFC\"\n"
751 " cardinality = \"multi\"\n"
752 " visibility = \"external\"\n"
753 " defaultValue = \"0\"\n"
754 " access = \"none\"\n"
755 " category = \"weakpointer\"\n"
756 " ptrFieldAccess = \"nullCheck\"\n"
757 " >\n"
758 " </Field>\n"
759 "\n"
760 " <Field\n"
761 " name = \"fieldMFNo_mpchildptr\"\n"
762 " type = \"FCDTestFC\"\n"
763 " cardinality = \"multi\"\n"
764 " visibility = \"external\"\n"
765 " defaultValue = \"0\"\n"
766 " access = \"none\"\n"
767 " category = \"childpointer\"\n"
768 " linkParentField=\"Parents\"\n"
769 " ptrFieldAccess = \"nullCheck\"\n"
770 " >\n"
771 " </Field>\n"
772 "\n"
773 "\n"
774 "\n"
775 "\n"
776 " <!-- SF, single parent, public -->\n"
777 "\n"
778 " <Field\n"
779 " name = \"fieldSFPub_spchildptr\"\n"
780 " type = \"FCDSParTestFC\"\n"
781 " cardinality = \"single\"\n"
782 " visibility = \"external\"\n"
783 " defaultValue = \"0\"\n"
784 " access = \"public\"\n"
785 " category = \"childpointer\"\n"
786 " linkParentField=\"Parent\"\n"
787 " ptrFieldAccess = \"nullCheck\"\n"
788 " >\n"
789 " </Field>\n"
790 "\n"
791 " <!-- SF, single parent, protected -->\n"
792 "\n"
793 " <Field\n"
794 " name = \"fieldSFPro_spchildptr\"\n"
795 " type = \"FCDSParTestFC\"\n"
796 " cardinality = \"single\"\n"
797 " visibility = \"external\"\n"
798 " defaultValue = \"0\"\n"
799 " access = \"protected\"\n"
800 " category = \"childpointer\"\n"
801 " linkParentField=\"Parent\"\n"
802 " ptrFieldAccess = \"nullCheck\"\n"
803 " >\n"
804 " </Field>\n"
805 "\n"
806 "\n"
807 " <!-- SF, single parent, none -->\n"
808 "\n"
809 " <Field\n"
810 " name = \"fieldSFNo_spchildptr\"\n"
811 " type = \"FCDSParTestFC\"\n"
812 " cardinality = \"single\"\n"
813 " visibility = \"external\"\n"
814 " defaultValue = \"0\"\n"
815 " access = \"none\"\n"
816 " category = \"childpointer\"\n"
817 " linkParentField=\"Parent\"\n"
818 " ptrFieldAccess = \"nullCheck\"\n"
819 " >\n"
820 " </Field>\n"
821 "\n"
822 "\n"
823 " <!-- MF, single parent, public -->\n"
824 "\n"
825 " <Field\n"
826 " name = \"fieldMFPub_spchildptr\"\n"
827 " type = \"FCDSParTestFC\"\n"
828 " cardinality = \"multi\"\n"
829 " visibility = \"external\"\n"
830 " defaultValue = \"0\"\n"
831 " access = \"public\"\n"
832 " category = \"childpointer\"\n"
833 " linkParentField=\"Parent\"\n"
834 " ptrFieldAccess = \"nullCheck\"\n"
835 " >\n"
836 " </Field>\n"
837 "\n"
838 " <!-- MF, single parent, protected -->\n"
839 "\n"
840 " <Field\n"
841 " name = \"fieldMFPro_spchildptr\"\n"
842 " type = \"FCDSParTestFC\"\n"
843 " cardinality = \"multi\"\n"
844 " visibility = \"external\"\n"
845 " defaultValue = \"0\"\n"
846 " access = \"protected\"\n"
847 " category = \"childpointer\"\n"
848 " linkParentField=\"Parent\"\n"
849 " ptrFieldAccess = \"nullCheck\"\n"
850 " >\n"
851 " </Field>\n"
852 "\n"
853 "\n"
854 " <!-- MF, multi parent, none -->\n"
855 "\n"
856 " <Field\n"
857 " name = \"fieldMFNo_spchildptr\"\n"
858 " type = \"FCDSParTestFC\"\n"
859 " cardinality = \"multi\"\n"
860 " visibility = \"external\"\n"
861 " defaultValue = \"0\"\n"
862 " access = \"none\"\n"
863 " category = \"childpointer\"\n"
864 " linkParentField=\"Parent\"\n"
865 " ptrFieldAccess = \"nullCheck\"\n"
866 " >\n"
867 " </Field>\n"
868 "\n"
869 "</FieldContainer>\n",
870 ""
871 );
872
873 /*------------------------------ get -----------------------------------*/
874
875 FieldContainerType &FCDPtrTestFCNullCheckAccessBase::getType(void)
876 {
877 return _type;
878 }
879
880 const FieldContainerType &FCDPtrTestFCNullCheckAccessBase::getType(void) const
881 {
882 return _type;
883 }
884
885 UInt32 FCDPtrTestFCNullCheckAccessBase::getContainerSize(void) const
886 {
887 return sizeof(FCDPtrTestFCNullCheckAccess);
888 }
889
890 /*------------------------- decorator get ------------------------------*/
891
892
893 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPub_ptr field.
894 const SFUnrecFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPub_ptr(void) const
895 {
896 return &_sfFieldSFPub_ptr;
897 }
898
899 SFUnrecFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPub_ptr (void)
900 {
901 editSField(FieldSFPub_ptrFieldMask);
902
903 return &_sfFieldSFPub_ptr;
904 }
905
906 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPub_weakptr field.
907 const SFWeakFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPub_weakptr(void) const
908 {
909 return &_sfFieldSFPub_weakptr;
910 }
911
912 SFWeakFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPub_weakptr(void)
913 {
914 editSField(FieldSFPub_weakptrFieldMask);
915
916 return &_sfFieldSFPub_weakptr;
917 }
918
919 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPub_mpchildptr field.
920 const SFUnrecChildFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPub_mpchildptr(void) const
921 {
922 return &_sfFieldSFPub_mpchildptr;
923 }
924
925 SFUnrecChildFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPub_mpchildptr(void)
926 {
927 editSField(FieldSFPub_mpchildptrFieldMask);
928
929 return &_sfFieldSFPub_mpchildptr;
930 }
931
932 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPro_ptr field.
933 const SFUnrecFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPro_ptr(void) const
934 {
935 return &_sfFieldSFPro_ptr;
936 }
937
938 SFUnrecFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPro_ptr (void)
939 {
940 editSField(FieldSFPro_ptrFieldMask);
941
942 return &_sfFieldSFPro_ptr;
943 }
944
945 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPro_weakptr field.
946 const SFWeakFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPro_weakptr(void) const
947 {
948 return &_sfFieldSFPro_weakptr;
949 }
950
951 SFWeakFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPro_weakptr(void)
952 {
953 editSField(FieldSFPro_weakptrFieldMask);
954
955 return &_sfFieldSFPro_weakptr;
956 }
957
958 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPro_mpchildptr field.
959 const SFUnrecChildFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPro_mpchildptr(void) const
960 {
961 return &_sfFieldSFPro_mpchildptr;
962 }
963
964 SFUnrecChildFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPro_mpchildptr(void)
965 {
966 editSField(FieldSFPro_mpchildptrFieldMask);
967
968 return &_sfFieldSFPro_mpchildptr;
969 }
970
971
972
973
974 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPub_ptr field.
975 const MFUnrecFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPub_ptr(void) const
976 {
977 return &_mfFieldMFPub_ptr;
978 }
979
980 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPub_weakptr field.
981 const MFWeakFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPub_weakptr(void) const
982 {
983 return &_mfFieldMFPub_weakptr;
984 }
985
986 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPub_mpchildptr field.
987 const MFUnrecChildFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPub_mpchildptr(void) const
988 {
989 return &_mfFieldMFPub_mpchildptr;
990 }
991
992 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPro_ptr field.
993 const MFUnrecFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPro_ptr(void) const
994 {
995 return &_mfFieldMFPro_ptr;
996 }
997
998 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPro_weakptr field.
999 const MFWeakFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPro_weakptr(void) const
1000 {
1001 return &_mfFieldMFPro_weakptr;
1002 }
1003
1004 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPro_mpchildptr field.
1005 const MFUnrecChildFCDTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPro_mpchildptr(void) const
1006 {
1007 return &_mfFieldMFPro_mpchildptr;
1008 }
1009
1010
1011
1012
1013 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPub_spchildptr field.
1014 const SFUnrecChildFCDSParTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPub_spchildptr(void) const
1015 {
1016 return &_sfFieldSFPub_spchildptr;
1017 }
1018
1019 SFUnrecChildFCDSParTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPub_spchildptr(void)
1020 {
1021 editSField(FieldSFPub_spchildptrFieldMask);
1022
1023 return &_sfFieldSFPub_spchildptr;
1024 }
1025
1026 //! Get the FCDPtrTestFCNullCheckAccess::_sfFieldSFPro_spchildptr field.
1027 const SFUnrecChildFCDSParTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getSFFieldSFPro_spchildptr(void) const
1028 {
1029 return &_sfFieldSFPro_spchildptr;
1030 }
1031
1032 SFUnrecChildFCDSParTestFCPtr *FCDPtrTestFCNullCheckAccessBase::editSFFieldSFPro_spchildptr(void)
1033 {
1034 editSField(FieldSFPro_spchildptrFieldMask);
1035
1036 return &_sfFieldSFPro_spchildptr;
1037 }
1038
1039
1040 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPub_spchildptr field.
1041 const MFUnrecChildFCDSParTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPub_spchildptr(void) const
1042 {
1043 return &_mfFieldMFPub_spchildptr;
1044 }
1045
1046 //! Get the FCDPtrTestFCNullCheckAccess::_mfFieldMFPro_spchildptr field.
1047 const MFUnrecChildFCDSParTestFCPtr *FCDPtrTestFCNullCheckAccessBase::getMFFieldMFPro_spchildptr(void) const
1048 {
1049 return &_mfFieldMFPro_spchildptr;
1050 }
1051
1052
1053
1054
1055 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPub_ptr(FCDTestFC * const value)
1056 {
1057 if(value == NULL)
1058 return;
1059
1060 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1061
1062 _mfFieldMFPub_ptr.push_back(value);
1063 }
1064
1065 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPub_ptr(const MFUnrecFCDTestFCPtr &value)
1066 {
1067 MFUnrecFCDTestFCPtr::const_iterator elemIt =
1068 value.begin();
1069 MFUnrecFCDTestFCPtr::const_iterator elemEnd =
1070 value.end ();
1071
1072 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_ptr();
1073
1074 while(elemIt != elemEnd)
1075 {
1076 this->pushToFieldMFPub_ptr(*elemIt);
1077
1078 ++elemIt;
1079 }
1080 }
1081
1082 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPub_ptr(UInt32 uiIndex,
1083 FCDTestFC * const value )
1084 {
1085 if(value == NULL)
1086 return;
1087
1088 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1089
1090 MFUnrecFCDTestFCPtr::iterator fieldIt = _mfFieldMFPub_ptr.begin_nc();
1091
1092 fieldIt += uiIndex;
1093
1094 _mfFieldMFPub_ptr.insert(fieldIt, value);
1095 }
1096
1097 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPub_ptr(UInt32 uiIndex,
1098 FCDTestFC * const value )
1099 {
1100 if(value == NULL)
1101 return;
1102
1103 if(uiIndex >= _mfFieldMFPub_ptr.size())
1104 return;
1105
1106 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1107
1108 _mfFieldMFPub_ptr.replace(uiIndex, value);
1109 }
1110
1111 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPub_ptr(FCDTestFC * const pOldElem,
1112 FCDTestFC * const pNewElem)
1113 {
1114 if(pNewElem == NULL)
1115 return;
1116
1117 Int32 elemIdx = _mfFieldMFPub_ptr.findIndex(pOldElem);
1118
1119 if(elemIdx != -1)
1120 {
1121 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1122
1123 _mfFieldMFPub_ptr.replace(elemIdx, pNewElem);
1124 }
1125 }
1126
1127 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPub_ptr(UInt32 uiIndex)
1128 {
1129 if(uiIndex < _mfFieldMFPub_ptr.size())
1130 {
1131 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1132
1133 _mfFieldMFPub_ptr.erase(uiIndex);
1134 }
1135 }
1136
1137 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPub_ptr(FCDTestFC * const value)
1138 {
1139 Int32 iElemIdx = _mfFieldMFPub_ptr.findIndex(value);
1140
1141 if(iElemIdx != -1)
1142 {
1143 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1144
1145 _mfFieldMFPub_ptr.erase(iElemIdx);
1146 }
1147 }
1148 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPub_ptr(void)
1149 {
1150 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
1151
1152
1153 _mfFieldMFPub_ptr.clear();
1154 }
1155
1156 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPub_weakptr(FCDTestFC * const value)
1157 {
1158 if(value == NULL)
1159 return;
1160
1161 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1162
1163 _mfFieldMFPub_weakptr.push_back(value);
1164 }
1165
1166 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPub_weakptr(const MFWeakFCDTestFCPtr &value)
1167 {
1168 MFWeakFCDTestFCPtr::const_iterator elemIt =
1169 value.begin();
1170 MFWeakFCDTestFCPtr::const_iterator elemEnd =
1171 value.end ();
1172
1173 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_weakptr();
1174
1175 while(elemIt != elemEnd)
1176 {
1177 this->pushToFieldMFPub_weakptr(*elemIt);
1178
1179 ++elemIt;
1180 }
1181 }
1182
1183 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPub_weakptr(UInt32 uiIndex,
1184 FCDTestFC * const value )
1185 {
1186 if(value == NULL)
1187 return;
1188
1189 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1190
1191 MFWeakFCDTestFCPtr::iterator fieldIt = _mfFieldMFPub_weakptr.begin_nc();
1192
1193 fieldIt += uiIndex;
1194
1195 _mfFieldMFPub_weakptr.insert(fieldIt, value);
1196 }
1197
1198 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPub_weakptr(UInt32 uiIndex,
1199 FCDTestFC * const value )
1200 {
1201 if(value == NULL)
1202 return;
1203
1204 if(uiIndex >= _mfFieldMFPub_weakptr.size())
1205 return;
1206
1207 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1208
1209 _mfFieldMFPub_weakptr.replace(uiIndex, value);
1210 }
1211
1212 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPub_weakptr(FCDTestFC * const pOldElem,
1213 FCDTestFC * const pNewElem)
1214 {
1215 if(pNewElem == NULL)
1216 return;
1217
1218 Int32 elemIdx = _mfFieldMFPub_weakptr.findIndex(pOldElem);
1219
1220 if(elemIdx != -1)
1221 {
1222 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1223
1224 _mfFieldMFPub_weakptr.replace(elemIdx, pNewElem);
1225 }
1226 }
1227
1228 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPub_weakptr(UInt32 uiIndex)
1229 {
1230 if(uiIndex < _mfFieldMFPub_weakptr.size())
1231 {
1232 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1233
1234 _mfFieldMFPub_weakptr.erase(uiIndex);
1235 }
1236 }
1237
1238 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPub_weakptr(FCDTestFC * const value)
1239 {
1240 Int32 iElemIdx = _mfFieldMFPub_weakptr.findIndex(value);
1241
1242 if(iElemIdx != -1)
1243 {
1244 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1245
1246 _mfFieldMFPub_weakptr.erase(iElemIdx);
1247 }
1248 }
1249 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPub_weakptr(void)
1250 {
1251 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
1252
1253
1254 _mfFieldMFPub_weakptr.clear();
1255 }
1256
1257 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPub_mpchildptr(FCDTestFC * const value)
1258 {
1259 if(value == NULL)
1260 return;
1261
1262 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1263
1264 _mfFieldMFPub_mpchildptr.push_back(value);
1265 }
1266
1267 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPub_mpchildptr(const MFUnrecChildFCDTestFCPtr &value)
1268 {
1269 MFUnrecChildFCDTestFCPtr::const_iterator elemIt =
1270 value.begin();
1271 MFUnrecChildFCDTestFCPtr::const_iterator elemEnd =
1272 value.end ();
1273
1274 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_mpchildptr();
1275
1276 while(elemIt != elemEnd)
1277 {
1278 this->pushToFieldMFPub_mpchildptr(*elemIt);
1279
1280 ++elemIt;
1281 }
1282 }
1283
1284 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPub_mpchildptr(UInt32 uiIndex,
1285 FCDTestFC * const value )
1286 {
1287 if(value == NULL)
1288 return;
1289
1290 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1291
1292 MFUnrecChildFCDTestFCPtr::iterator fieldIt = _mfFieldMFPub_mpchildptr.begin_nc();
1293
1294 fieldIt += uiIndex;
1295
1296 _mfFieldMFPub_mpchildptr.insert(fieldIt, value);
1297 }
1298
1299 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPub_mpchildptr(UInt32 uiIndex,
1300 FCDTestFC * const value )
1301 {
1302 if(value == NULL)
1303 return;
1304
1305 if(uiIndex >= _mfFieldMFPub_mpchildptr.size())
1306 return;
1307
1308 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1309
1310 _mfFieldMFPub_mpchildptr.replace(uiIndex, value);
1311 }
1312
1313 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPub_mpchildptr(FCDTestFC * const pOldElem,
1314 FCDTestFC * const pNewElem)
1315 {
1316 if(pNewElem == NULL)
1317 return;
1318
1319 Int32 elemIdx = _mfFieldMFPub_mpchildptr.findIndex(pOldElem);
1320
1321 if(elemIdx != -1)
1322 {
1323 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1324
1325 _mfFieldMFPub_mpchildptr.replace(elemIdx, pNewElem);
1326 }
1327 }
1328
1329 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPub_mpchildptr(UInt32 uiIndex)
1330 {
1331 if(uiIndex < _mfFieldMFPub_mpchildptr.size())
1332 {
1333 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1334
1335 _mfFieldMFPub_mpchildptr.erase(uiIndex);
1336 }
1337 }
1338
1339 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPub_mpchildptr(FCDTestFC * const value)
1340 {
1341 Int32 iElemIdx = _mfFieldMFPub_mpchildptr.findIndex(value);
1342
1343 if(iElemIdx != -1)
1344 {
1345 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1346
1347 _mfFieldMFPub_mpchildptr.erase(iElemIdx);
1348 }
1349 }
1350 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPub_mpchildptr(void)
1351 {
1352 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
1353
1354
1355 _mfFieldMFPub_mpchildptr.clear();
1356 }
1357
1358 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPro_ptr(FCDTestFC * const value)
1359 {
1360 if(value == NULL)
1361 return;
1362
1363 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1364
1365 _mfFieldMFPro_ptr.push_back(value);
1366 }
1367
1368 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPro_ptr(const MFUnrecFCDTestFCPtr &value)
1369 {
1370 MFUnrecFCDTestFCPtr::const_iterator elemIt =
1371 value.begin();
1372 MFUnrecFCDTestFCPtr::const_iterator elemEnd =
1373 value.end ();
1374
1375 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_ptr();
1376
1377 while(elemIt != elemEnd)
1378 {
1379 this->pushToFieldMFPro_ptr(*elemIt);
1380
1381 ++elemIt;
1382 }
1383 }
1384
1385 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPro_ptr(UInt32 uiIndex,
1386 FCDTestFC * const value )
1387 {
1388 if(value == NULL)
1389 return;
1390
1391 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1392
1393 MFUnrecFCDTestFCPtr::iterator fieldIt = _mfFieldMFPro_ptr.begin_nc();
1394
1395 fieldIt += uiIndex;
1396
1397 _mfFieldMFPro_ptr.insert(fieldIt, value);
1398 }
1399
1400 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPro_ptr(UInt32 uiIndex,
1401 FCDTestFC * const value )
1402 {
1403 if(value == NULL)
1404 return;
1405
1406 if(uiIndex >= _mfFieldMFPro_ptr.size())
1407 return;
1408
1409 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1410
1411 _mfFieldMFPro_ptr.replace(uiIndex, value);
1412 }
1413
1414 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPro_ptr(FCDTestFC * const pOldElem,
1415 FCDTestFC * const pNewElem)
1416 {
1417 if(pNewElem == NULL)
1418 return;
1419
1420 Int32 elemIdx = _mfFieldMFPro_ptr.findIndex(pOldElem);
1421
1422 if(elemIdx != -1)
1423 {
1424 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1425
1426 _mfFieldMFPro_ptr.replace(elemIdx, pNewElem);
1427 }
1428 }
1429
1430 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPro_ptr(UInt32 uiIndex)
1431 {
1432 if(uiIndex < _mfFieldMFPro_ptr.size())
1433 {
1434 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1435
1436 _mfFieldMFPro_ptr.erase(uiIndex);
1437 }
1438 }
1439
1440 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPro_ptr(FCDTestFC * const value)
1441 {
1442 Int32 iElemIdx = _mfFieldMFPro_ptr.findIndex(value);
1443
1444 if(iElemIdx != -1)
1445 {
1446 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1447
1448 _mfFieldMFPro_ptr.erase(iElemIdx);
1449 }
1450 }
1451 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPro_ptr(void)
1452 {
1453 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
1454
1455
1456 _mfFieldMFPro_ptr.clear();
1457 }
1458
1459 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPro_weakptr(FCDTestFC * const value)
1460 {
1461 if(value == NULL)
1462 return;
1463
1464 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1465
1466 _mfFieldMFPro_weakptr.push_back(value);
1467 }
1468
1469 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPro_weakptr(const MFWeakFCDTestFCPtr &value)
1470 {
1471 MFWeakFCDTestFCPtr::const_iterator elemIt =
1472 value.begin();
1473 MFWeakFCDTestFCPtr::const_iterator elemEnd =
1474 value.end ();
1475
1476 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_weakptr();
1477
1478 while(elemIt != elemEnd)
1479 {
1480 this->pushToFieldMFPro_weakptr(*elemIt);
1481
1482 ++elemIt;
1483 }
1484 }
1485
1486 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPro_weakptr(UInt32 uiIndex,
1487 FCDTestFC * const value )
1488 {
1489 if(value == NULL)
1490 return;
1491
1492 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1493
1494 MFWeakFCDTestFCPtr::iterator fieldIt = _mfFieldMFPro_weakptr.begin_nc();
1495
1496 fieldIt += uiIndex;
1497
1498 _mfFieldMFPro_weakptr.insert(fieldIt, value);
1499 }
1500
1501 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPro_weakptr(UInt32 uiIndex,
1502 FCDTestFC * const value )
1503 {
1504 if(value == NULL)
1505 return;
1506
1507 if(uiIndex >= _mfFieldMFPro_weakptr.size())
1508 return;
1509
1510 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1511
1512 _mfFieldMFPro_weakptr.replace(uiIndex, value);
1513 }
1514
1515 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPro_weakptr(FCDTestFC * const pOldElem,
1516 FCDTestFC * const pNewElem)
1517 {
1518 if(pNewElem == NULL)
1519 return;
1520
1521 Int32 elemIdx = _mfFieldMFPro_weakptr.findIndex(pOldElem);
1522
1523 if(elemIdx != -1)
1524 {
1525 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1526
1527 _mfFieldMFPro_weakptr.replace(elemIdx, pNewElem);
1528 }
1529 }
1530
1531 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPro_weakptr(UInt32 uiIndex)
1532 {
1533 if(uiIndex < _mfFieldMFPro_weakptr.size())
1534 {
1535 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1536
1537 _mfFieldMFPro_weakptr.erase(uiIndex);
1538 }
1539 }
1540
1541 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPro_weakptr(FCDTestFC * const value)
1542 {
1543 Int32 iElemIdx = _mfFieldMFPro_weakptr.findIndex(value);
1544
1545 if(iElemIdx != -1)
1546 {
1547 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1548
1549 _mfFieldMFPro_weakptr.erase(iElemIdx);
1550 }
1551 }
1552 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPro_weakptr(void)
1553 {
1554 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
1555
1556
1557 _mfFieldMFPro_weakptr.clear();
1558 }
1559
1560 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPro_mpchildptr(FCDTestFC * const value)
1561 {
1562 if(value == NULL)
1563 return;
1564
1565 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1566
1567 _mfFieldMFPro_mpchildptr.push_back(value);
1568 }
1569
1570 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPro_mpchildptr(const MFUnrecChildFCDTestFCPtr &value)
1571 {
1572 MFUnrecChildFCDTestFCPtr::const_iterator elemIt =
1573 value.begin();
1574 MFUnrecChildFCDTestFCPtr::const_iterator elemEnd =
1575 value.end ();
1576
1577 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_mpchildptr();
1578
1579 while(elemIt != elemEnd)
1580 {
1581 this->pushToFieldMFPro_mpchildptr(*elemIt);
1582
1583 ++elemIt;
1584 }
1585 }
1586
1587 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPro_mpchildptr(UInt32 uiIndex,
1588 FCDTestFC * const value )
1589 {
1590 if(value == NULL)
1591 return;
1592
1593 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1594
1595 MFUnrecChildFCDTestFCPtr::iterator fieldIt = _mfFieldMFPro_mpchildptr.begin_nc();
1596
1597 fieldIt += uiIndex;
1598
1599 _mfFieldMFPro_mpchildptr.insert(fieldIt, value);
1600 }
1601
1602 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPro_mpchildptr(UInt32 uiIndex,
1603 FCDTestFC * const value )
1604 {
1605 if(value == NULL)
1606 return;
1607
1608 if(uiIndex >= _mfFieldMFPro_mpchildptr.size())
1609 return;
1610
1611 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1612
1613 _mfFieldMFPro_mpchildptr.replace(uiIndex, value);
1614 }
1615
1616 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPro_mpchildptr(FCDTestFC * const pOldElem,
1617 FCDTestFC * const pNewElem)
1618 {
1619 if(pNewElem == NULL)
1620 return;
1621
1622 Int32 elemIdx = _mfFieldMFPro_mpchildptr.findIndex(pOldElem);
1623
1624 if(elemIdx != -1)
1625 {
1626 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1627
1628 _mfFieldMFPro_mpchildptr.replace(elemIdx, pNewElem);
1629 }
1630 }
1631
1632 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPro_mpchildptr(UInt32 uiIndex)
1633 {
1634 if(uiIndex < _mfFieldMFPro_mpchildptr.size())
1635 {
1636 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1637
1638 _mfFieldMFPro_mpchildptr.erase(uiIndex);
1639 }
1640 }
1641
1642 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPro_mpchildptr(FCDTestFC * const value)
1643 {
1644 Int32 iElemIdx = _mfFieldMFPro_mpchildptr.findIndex(value);
1645
1646 if(iElemIdx != -1)
1647 {
1648 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1649
1650 _mfFieldMFPro_mpchildptr.erase(iElemIdx);
1651 }
1652 }
1653 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPro_mpchildptr(void)
1654 {
1655 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
1656
1657
1658 _mfFieldMFPro_mpchildptr.clear();
1659 }
1660
1661 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPub_spchildptr(FCDSParTestFC * const value)
1662 {
1663 if(value == NULL)
1664 return;
1665
1666 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1667
1668 _mfFieldMFPub_spchildptr.push_back(value);
1669 }
1670
1671 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPub_spchildptr(const MFUnrecChildFCDSParTestFCPtr &value)
1672 {
1673 MFUnrecChildFCDSParTestFCPtr::const_iterator elemIt =
1674 value.begin();
1675 MFUnrecChildFCDSParTestFCPtr::const_iterator elemEnd =
1676 value.end ();
1677
1678 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_spchildptr();
1679
1680 while(elemIt != elemEnd)
1681 {
1682 this->pushToFieldMFPub_spchildptr(*elemIt);
1683
1684 ++elemIt;
1685 }
1686 }
1687
1688 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPub_spchildptr(UInt32 uiIndex,
1689 FCDSParTestFC * const value )
1690 {
1691 if(value == NULL)
1692 return;
1693
1694 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1695
1696 MFUnrecChildFCDSParTestFCPtr::iterator fieldIt = _mfFieldMFPub_spchildptr.begin_nc();
1697
1698 fieldIt += uiIndex;
1699
1700 _mfFieldMFPub_spchildptr.insert(fieldIt, value);
1701 }
1702
1703 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPub_spchildptr(UInt32 uiIndex,
1704 FCDSParTestFC * const value )
1705 {
1706 if(value == NULL)
1707 return;
1708
1709 if(uiIndex >= _mfFieldMFPub_spchildptr.size())
1710 return;
1711
1712 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1713
1714 _mfFieldMFPub_spchildptr.replace(uiIndex, value);
1715 }
1716
1717 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPub_spchildptr(FCDSParTestFC * const pOldElem,
1718 FCDSParTestFC * const pNewElem)
1719 {
1720 if(pNewElem == NULL)
1721 return;
1722
1723 Int32 elemIdx = _mfFieldMFPub_spchildptr.findIndex(pOldElem);
1724
1725 if(elemIdx != -1)
1726 {
1727 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1728
1729 _mfFieldMFPub_spchildptr.replace(elemIdx, pNewElem);
1730 }
1731 }
1732
1733 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPub_spchildptr(UInt32 uiIndex)
1734 {
1735 if(uiIndex < _mfFieldMFPub_spchildptr.size())
1736 {
1737 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1738
1739 _mfFieldMFPub_spchildptr.erase(uiIndex);
1740 }
1741 }
1742
1743 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPub_spchildptr(FCDSParTestFC * const value)
1744 {
1745 Int32 iElemIdx = _mfFieldMFPub_spchildptr.findIndex(value);
1746
1747 if(iElemIdx != -1)
1748 {
1749 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1750
1751 _mfFieldMFPub_spchildptr.erase(iElemIdx);
1752 }
1753 }
1754 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPub_spchildptr(void)
1755 {
1756 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
1757
1758
1759 _mfFieldMFPub_spchildptr.clear();
1760 }
1761
1762 void FCDPtrTestFCNullCheckAccessBase::pushToFieldMFPro_spchildptr(FCDSParTestFC * const value)
1763 {
1764 if(value == NULL)
1765 return;
1766
1767 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1768
1769 _mfFieldMFPro_spchildptr.push_back(value);
1770 }
1771
1772 void FCDPtrTestFCNullCheckAccessBase::assignFieldMFPro_spchildptr(const MFUnrecChildFCDSParTestFCPtr &value)
1773 {
1774 MFUnrecChildFCDSParTestFCPtr::const_iterator elemIt =
1775 value.begin();
1776 MFUnrecChildFCDSParTestFCPtr::const_iterator elemEnd =
1777 value.end ();
1778
1779 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_spchildptr();
1780
1781 while(elemIt != elemEnd)
1782 {
1783 this->pushToFieldMFPro_spchildptr(*elemIt);
1784
1785 ++elemIt;
1786 }
1787 }
1788
1789 void FCDPtrTestFCNullCheckAccessBase::insertIntoFieldMFPro_spchildptr(UInt32 uiIndex,
1790 FCDSParTestFC * const value )
1791 {
1792 if(value == NULL)
1793 return;
1794
1795 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1796
1797 MFUnrecChildFCDSParTestFCPtr::iterator fieldIt = _mfFieldMFPro_spchildptr.begin_nc();
1798
1799 fieldIt += uiIndex;
1800
1801 _mfFieldMFPro_spchildptr.insert(fieldIt, value);
1802 }
1803
1804 void FCDPtrTestFCNullCheckAccessBase::replaceInFieldMFPro_spchildptr(UInt32 uiIndex,
1805 FCDSParTestFC * const value )
1806 {
1807 if(value == NULL)
1808 return;
1809
1810 if(uiIndex >= _mfFieldMFPro_spchildptr.size())
1811 return;
1812
1813 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1814
1815 _mfFieldMFPro_spchildptr.replace(uiIndex, value);
1816 }
1817
1818 void FCDPtrTestFCNullCheckAccessBase::replaceObjInFieldMFPro_spchildptr(FCDSParTestFC * const pOldElem,
1819 FCDSParTestFC * const pNewElem)
1820 {
1821 if(pNewElem == NULL)
1822 return;
1823
1824 Int32 elemIdx = _mfFieldMFPro_spchildptr.findIndex(pOldElem);
1825
1826 if(elemIdx != -1)
1827 {
1828 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1829
1830 _mfFieldMFPro_spchildptr.replace(elemIdx, pNewElem);
1831 }
1832 }
1833
1834 void FCDPtrTestFCNullCheckAccessBase::removeFromFieldMFPro_spchildptr(UInt32 uiIndex)
1835 {
1836 if(uiIndex < _mfFieldMFPro_spchildptr.size())
1837 {
1838 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1839
1840 _mfFieldMFPro_spchildptr.erase(uiIndex);
1841 }
1842 }
1843
1844 void FCDPtrTestFCNullCheckAccessBase::removeObjFromFieldMFPro_spchildptr(FCDSParTestFC * const value)
1845 {
1846 Int32 iElemIdx = _mfFieldMFPro_spchildptr.findIndex(value);
1847
1848 if(iElemIdx != -1)
1849 {
1850 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1851
1852 _mfFieldMFPro_spchildptr.erase(iElemIdx);
1853 }
1854 }
1855 void FCDPtrTestFCNullCheckAccessBase::clearFieldMFPro_spchildptr(void)
1856 {
1857 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
1858
1859
1860 _mfFieldMFPro_spchildptr.clear();
1861 }
1862
1863
1864
1865 /*------------------------------ access -----------------------------------*/
1866
1867 SizeT FCDPtrTestFCNullCheckAccessBase::getBinSize(ConstFieldMaskArg whichField)
1868 {
1869 SizeT returnValue = Inherited::getBinSize(whichField);
1870
1871 if(FieldBits::NoField != (FieldSFPub_ptrFieldMask & whichField))
1872 {
1873 returnValue += _sfFieldSFPub_ptr.getBinSize();
1874 }
1875 if(FieldBits::NoField != (FieldSFPub_weakptrFieldMask & whichField))
1876 {
1877 returnValue += _sfFieldSFPub_weakptr.getBinSize();
1878 }
1879 if(FieldBits::NoField != (FieldSFPub_mpchildptrFieldMask & whichField))
1880 {
1881 returnValue += _sfFieldSFPub_mpchildptr.getBinSize();
1882 }
1883 if(FieldBits::NoField != (FieldSFPro_ptrFieldMask & whichField))
1884 {
1885 returnValue += _sfFieldSFPro_ptr.getBinSize();
1886 }
1887 if(FieldBits::NoField != (FieldSFPro_weakptrFieldMask & whichField))
1888 {
1889 returnValue += _sfFieldSFPro_weakptr.getBinSize();
1890 }
1891 if(FieldBits::NoField != (FieldSFPro_mpchildptrFieldMask & whichField))
1892 {
1893 returnValue += _sfFieldSFPro_mpchildptr.getBinSize();
1894 }
1895 if(FieldBits::NoField != (FieldSFNo_ptrFieldMask & whichField))
1896 {
1897 returnValue += _sfFieldSFNo_ptr.getBinSize();
1898 }
1899 if(FieldBits::NoField != (FieldSFNo_weakptrFieldMask & whichField))
1900 {
1901 returnValue += _sfFieldSFNo_weakptr.getBinSize();
1902 }
1903 if(FieldBits::NoField != (FieldSFNo_mpchildptrFieldMask & whichField))
1904 {
1905 returnValue += _sfFieldSFNo_mpchildptr.getBinSize();
1906 }
1907 if(FieldBits::NoField != (FieldMFPub_ptrFieldMask & whichField))
1908 {
1909 returnValue += _mfFieldMFPub_ptr.getBinSize();
1910 }
1911 if(FieldBits::NoField != (FieldMFPub_weakptrFieldMask & whichField))
1912 {
1913 returnValue += _mfFieldMFPub_weakptr.getBinSize();
1914 }
1915 if(FieldBits::NoField != (FieldMFPub_mpchildptrFieldMask & whichField))
1916 {
1917 returnValue += _mfFieldMFPub_mpchildptr.getBinSize();
1918 }
1919 if(FieldBits::NoField != (FieldMFPro_ptrFieldMask & whichField))
1920 {
1921 returnValue += _mfFieldMFPro_ptr.getBinSize();
1922 }
1923 if(FieldBits::NoField != (FieldMFPro_weakptrFieldMask & whichField))
1924 {
1925 returnValue += _mfFieldMFPro_weakptr.getBinSize();
1926 }
1927 if(FieldBits::NoField != (FieldMFPro_mpchildptrFieldMask & whichField))
1928 {
1929 returnValue += _mfFieldMFPro_mpchildptr.getBinSize();
1930 }
1931 if(FieldBits::NoField != (FieldMFNo_ptrFieldMask & whichField))
1932 {
1933 returnValue += _mfFieldMFNo_ptr.getBinSize();
1934 }
1935 if(FieldBits::NoField != (FieldMFNo_weakptrFieldMask & whichField))
1936 {
1937 returnValue += _mfFieldMFNo_weakptr.getBinSize();
1938 }
1939 if(FieldBits::NoField != (FieldMFNo_mpchildptrFieldMask & whichField))
1940 {
1941 returnValue += _mfFieldMFNo_mpchildptr.getBinSize();
1942 }
1943 if(FieldBits::NoField != (FieldSFPub_spchildptrFieldMask & whichField))
1944 {
1945 returnValue += _sfFieldSFPub_spchildptr.getBinSize();
1946 }
1947 if(FieldBits::NoField != (FieldSFPro_spchildptrFieldMask & whichField))
1948 {
1949 returnValue += _sfFieldSFPro_spchildptr.getBinSize();
1950 }
1951 if(FieldBits::NoField != (FieldSFNo_spchildptrFieldMask & whichField))
1952 {
1953 returnValue += _sfFieldSFNo_spchildptr.getBinSize();
1954 }
1955 if(FieldBits::NoField != (FieldMFPub_spchildptrFieldMask & whichField))
1956 {
1957 returnValue += _mfFieldMFPub_spchildptr.getBinSize();
1958 }
1959 if(FieldBits::NoField != (FieldMFPro_spchildptrFieldMask & whichField))
1960 {
1961 returnValue += _mfFieldMFPro_spchildptr.getBinSize();
1962 }
1963 if(FieldBits::NoField != (FieldMFNo_spchildptrFieldMask & whichField))
1964 {
1965 returnValue += _mfFieldMFNo_spchildptr.getBinSize();
1966 }
1967
1968 return returnValue;
1969 }
1970
1971 void FCDPtrTestFCNullCheckAccessBase::copyToBin(BinaryDataHandler &pMem,
1972 ConstFieldMaskArg whichField)
1973 {
1974 Inherited::copyToBin(pMem, whichField);
1975
1976 if(FieldBits::NoField != (FieldSFPub_ptrFieldMask & whichField))
1977 {
1978 _sfFieldSFPub_ptr.copyToBin(pMem);
1979 }
1980 if(FieldBits::NoField != (FieldSFPub_weakptrFieldMask & whichField))
1981 {
1982 _sfFieldSFPub_weakptr.copyToBin(pMem);
1983 }
1984 if(FieldBits::NoField != (FieldSFPub_mpchildptrFieldMask & whichField))
1985 {
1986 _sfFieldSFPub_mpchildptr.copyToBin(pMem);
1987 }
1988 if(FieldBits::NoField != (FieldSFPro_ptrFieldMask & whichField))
1989 {
1990 _sfFieldSFPro_ptr.copyToBin(pMem);
1991 }
1992 if(FieldBits::NoField != (FieldSFPro_weakptrFieldMask & whichField))
1993 {
1994 _sfFieldSFPro_weakptr.copyToBin(pMem);
1995 }
1996 if(FieldBits::NoField != (FieldSFPro_mpchildptrFieldMask & whichField))
1997 {
1998 _sfFieldSFPro_mpchildptr.copyToBin(pMem);
1999 }
2000 if(FieldBits::NoField != (FieldSFNo_ptrFieldMask & whichField))
2001 {
2002 _sfFieldSFNo_ptr.copyToBin(pMem);
2003 }
2004 if(FieldBits::NoField != (FieldSFNo_weakptrFieldMask & whichField))
2005 {
2006 _sfFieldSFNo_weakptr.copyToBin(pMem);
2007 }
2008 if(FieldBits::NoField != (FieldSFNo_mpchildptrFieldMask & whichField))
2009 {
2010 _sfFieldSFNo_mpchildptr.copyToBin(pMem);
2011 }
2012 if(FieldBits::NoField != (FieldMFPub_ptrFieldMask & whichField))
2013 {
2014 _mfFieldMFPub_ptr.copyToBin(pMem);
2015 }
2016 if(FieldBits::NoField != (FieldMFPub_weakptrFieldMask & whichField))
2017 {
2018 _mfFieldMFPub_weakptr.copyToBin(pMem);
2019 }
2020 if(FieldBits::NoField != (FieldMFPub_mpchildptrFieldMask & whichField))
2021 {
2022 _mfFieldMFPub_mpchildptr.copyToBin(pMem);
2023 }
2024 if(FieldBits::NoField != (FieldMFPro_ptrFieldMask & whichField))
2025 {
2026 _mfFieldMFPro_ptr.copyToBin(pMem);
2027 }
2028 if(FieldBits::NoField != (FieldMFPro_weakptrFieldMask & whichField))
2029 {
2030 _mfFieldMFPro_weakptr.copyToBin(pMem);
2031 }
2032 if(FieldBits::NoField != (FieldMFPro_mpchildptrFieldMask & whichField))
2033 {
2034 _mfFieldMFPro_mpchildptr.copyToBin(pMem);
2035 }
2036 if(FieldBits::NoField != (FieldMFNo_ptrFieldMask & whichField))
2037 {
2038 _mfFieldMFNo_ptr.copyToBin(pMem);
2039 }
2040 if(FieldBits::NoField != (FieldMFNo_weakptrFieldMask & whichField))
2041 {
2042 _mfFieldMFNo_weakptr.copyToBin(pMem);
2043 }
2044 if(FieldBits::NoField != (FieldMFNo_mpchildptrFieldMask & whichField))
2045 {
2046 _mfFieldMFNo_mpchildptr.copyToBin(pMem);
2047 }
2048 if(FieldBits::NoField != (FieldSFPub_spchildptrFieldMask & whichField))
2049 {
2050 _sfFieldSFPub_spchildptr.copyToBin(pMem);
2051 }
2052 if(FieldBits::NoField != (FieldSFPro_spchildptrFieldMask & whichField))
2053 {
2054 _sfFieldSFPro_spchildptr.copyToBin(pMem);
2055 }
2056 if(FieldBits::NoField != (FieldSFNo_spchildptrFieldMask & whichField))
2057 {
2058 _sfFieldSFNo_spchildptr.copyToBin(pMem);
2059 }
2060 if(FieldBits::NoField != (FieldMFPub_spchildptrFieldMask & whichField))
2061 {
2062 _mfFieldMFPub_spchildptr.copyToBin(pMem);
2063 }
2064 if(FieldBits::NoField != (FieldMFPro_spchildptrFieldMask & whichField))
2065 {
2066 _mfFieldMFPro_spchildptr.copyToBin(pMem);
2067 }
2068 if(FieldBits::NoField != (FieldMFNo_spchildptrFieldMask & whichField))
2069 {
2070 _mfFieldMFNo_spchildptr.copyToBin(pMem);
2071 }
2072 }
2073
2074 void FCDPtrTestFCNullCheckAccessBase::copyFromBin(BinaryDataHandler &pMem,
2075 ConstFieldMaskArg whichField)
2076 {
2077 Inherited::copyFromBin(pMem, whichField);
2078
2079 if(FieldBits::NoField != (FieldSFPub_ptrFieldMask & whichField))
2080 {
2081 editSField(FieldSFPub_ptrFieldMask);
2082 _sfFieldSFPub_ptr.copyFromBin(pMem);
2083 }
2084 if(FieldBits::NoField != (FieldSFPub_weakptrFieldMask & whichField))
2085 {
2086 editSField(FieldSFPub_weakptrFieldMask);
2087 _sfFieldSFPub_weakptr.copyFromBin(pMem);
2088 }
2089 if(FieldBits::NoField != (FieldSFPub_mpchildptrFieldMask & whichField))
2090 {
2091 editSField(FieldSFPub_mpchildptrFieldMask);
2092 _sfFieldSFPub_mpchildptr.copyFromBin(pMem);
2093 }
2094 if(FieldBits::NoField != (FieldSFPro_ptrFieldMask & whichField))
2095 {
2096 editSField(FieldSFPro_ptrFieldMask);
2097 _sfFieldSFPro_ptr.copyFromBin(pMem);
2098 }
2099 if(FieldBits::NoField != (FieldSFPro_weakptrFieldMask & whichField))
2100 {
2101 editSField(FieldSFPro_weakptrFieldMask);
2102 _sfFieldSFPro_weakptr.copyFromBin(pMem);
2103 }
2104 if(FieldBits::NoField != (FieldSFPro_mpchildptrFieldMask & whichField))
2105 {
2106 editSField(FieldSFPro_mpchildptrFieldMask);
2107 _sfFieldSFPro_mpchildptr.copyFromBin(pMem);
2108 }
2109 if(FieldBits::NoField != (FieldSFNo_ptrFieldMask & whichField))
2110 {
2111 editSField(FieldSFNo_ptrFieldMask);
2112 _sfFieldSFNo_ptr.copyFromBin(pMem);
2113 }
2114 if(FieldBits::NoField != (FieldSFNo_weakptrFieldMask & whichField))
2115 {
2116 editSField(FieldSFNo_weakptrFieldMask);
2117 _sfFieldSFNo_weakptr.copyFromBin(pMem);
2118 }
2119 if(FieldBits::NoField != (FieldSFNo_mpchildptrFieldMask & whichField))
2120 {
2121 editSField(FieldSFNo_mpchildptrFieldMask);
2122 _sfFieldSFNo_mpchildptr.copyFromBin(pMem);
2123 }
2124 if(FieldBits::NoField != (FieldMFPub_ptrFieldMask & whichField))
2125 {
2126 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
2127 _mfFieldMFPub_ptr.copyFromBin(pMem);
2128 }
2129 if(FieldBits::NoField != (FieldMFPub_weakptrFieldMask & whichField))
2130 {
2131 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
2132 _mfFieldMFPub_weakptr.copyFromBin(pMem);
2133 }
2134 if(FieldBits::NoField != (FieldMFPub_mpchildptrFieldMask & whichField))
2135 {
2136 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
2137 _mfFieldMFPub_mpchildptr.copyFromBin(pMem);
2138 }
2139 if(FieldBits::NoField != (FieldMFPro_ptrFieldMask & whichField))
2140 {
2141 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
2142 _mfFieldMFPro_ptr.copyFromBin(pMem);
2143 }
2144 if(FieldBits::NoField != (FieldMFPro_weakptrFieldMask & whichField))
2145 {
2146 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
2147 _mfFieldMFPro_weakptr.copyFromBin(pMem);
2148 }
2149 if(FieldBits::NoField != (FieldMFPro_mpchildptrFieldMask & whichField))
2150 {
2151 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
2152 _mfFieldMFPro_mpchildptr.copyFromBin(pMem);
2153 }
2154 if(FieldBits::NoField != (FieldMFNo_ptrFieldMask & whichField))
2155 {
2156 editMField(FieldMFNo_ptrFieldMask, _mfFieldMFNo_ptr);
2157 _mfFieldMFNo_ptr.copyFromBin(pMem);
2158 }
2159 if(FieldBits::NoField != (FieldMFNo_weakptrFieldMask & whichField))
2160 {
2161 editMField(FieldMFNo_weakptrFieldMask, _mfFieldMFNo_weakptr);
2162 _mfFieldMFNo_weakptr.copyFromBin(pMem);
2163 }
2164 if(FieldBits::NoField != (FieldMFNo_mpchildptrFieldMask & whichField))
2165 {
2166 editMField(FieldMFNo_mpchildptrFieldMask, _mfFieldMFNo_mpchildptr);
2167 _mfFieldMFNo_mpchildptr.copyFromBin(pMem);
2168 }
2169 if(FieldBits::NoField != (FieldSFPub_spchildptrFieldMask & whichField))
2170 {
2171 editSField(FieldSFPub_spchildptrFieldMask);
2172 _sfFieldSFPub_spchildptr.copyFromBin(pMem);
2173 }
2174 if(FieldBits::NoField != (FieldSFPro_spchildptrFieldMask & whichField))
2175 {
2176 editSField(FieldSFPro_spchildptrFieldMask);
2177 _sfFieldSFPro_spchildptr.copyFromBin(pMem);
2178 }
2179 if(FieldBits::NoField != (FieldSFNo_spchildptrFieldMask & whichField))
2180 {
2181 editSField(FieldSFNo_spchildptrFieldMask);
2182 _sfFieldSFNo_spchildptr.copyFromBin(pMem);
2183 }
2184 if(FieldBits::NoField != (FieldMFPub_spchildptrFieldMask & whichField))
2185 {
2186 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
2187 _mfFieldMFPub_spchildptr.copyFromBin(pMem);
2188 }
2189 if(FieldBits::NoField != (FieldMFPro_spchildptrFieldMask & whichField))
2190 {
2191 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
2192 _mfFieldMFPro_spchildptr.copyFromBin(pMem);
2193 }
2194 if(FieldBits::NoField != (FieldMFNo_spchildptrFieldMask & whichField))
2195 {
2196 editMField(FieldMFNo_spchildptrFieldMask, _mfFieldMFNo_spchildptr);
2197 _mfFieldMFNo_spchildptr.copyFromBin(pMem);
2198 }
2199 }
2200
2201 //! create a new instance of the class
2202 FCDPtrTestFCNullCheckAccessTransitPtr FCDPtrTestFCNullCheckAccessBase::createLocal(BitVector bFlags)
2203 {
2204 FCDPtrTestFCNullCheckAccessTransitPtr fc;
2205
2206 if(getClassType().getPrototype() != NULL)
2207 {
2208 FieldContainerTransitPtr tmpPtr =
2209 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
2210
2211 fc = dynamic_pointer_cast<FCDPtrTestFCNullCheckAccess>(tmpPtr);
2212 }
2213
2214 return fc;
2215 }
2216
2217 //! create a new instance of the class, copy the container flags
2218 FCDPtrTestFCNullCheckAccessTransitPtr FCDPtrTestFCNullCheckAccessBase::createDependent(BitVector bFlags)
2219 {
2220 FCDPtrTestFCNullCheckAccessTransitPtr fc;
2221
2222 if(getClassType().getPrototype() != NULL)
2223 {
2224 FieldContainerTransitPtr tmpPtr =
2225 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
2226
2227 fc = dynamic_pointer_cast<FCDPtrTestFCNullCheckAccess>(tmpPtr);
2228 }
2229
2230 return fc;
2231 }
2232
2233 //! create a new instance of the class
2234 FCDPtrTestFCNullCheckAccessTransitPtr FCDPtrTestFCNullCheckAccessBase::create(void)
2235 {
2236 FCDPtrTestFCNullCheckAccessTransitPtr fc;
2237
2238 if(getClassType().getPrototype() != NULL)
2239 {
2240 FieldContainerTransitPtr tmpPtr =
2241 getClassType().getPrototype()-> shallowCopy();
2242
2243 fc = dynamic_pointer_cast<FCDPtrTestFCNullCheckAccess>(tmpPtr);
2244 }
2245
2246 return fc;
2247 }
2248
2249 FCDPtrTestFCNullCheckAccess *FCDPtrTestFCNullCheckAccessBase::createEmptyLocal(BitVector bFlags)
2250 {
2251 FCDPtrTestFCNullCheckAccess *returnValue;
2252
2253 newPtr<FCDPtrTestFCNullCheckAccess>(returnValue, bFlags);
2254
2255 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
2256
2257 return returnValue;
2258 }
2259
2260 //! create an empty new instance of the class, do not copy the prototype
2261 FCDPtrTestFCNullCheckAccess *FCDPtrTestFCNullCheckAccessBase::createEmpty(void)
2262 {
2263 FCDPtrTestFCNullCheckAccess *returnValue;
2264
2265 newPtr<FCDPtrTestFCNullCheckAccess>(returnValue, Thread::getCurrentLocalFlags());
2266
2267 returnValue->_pFieldFlags->_bNamespaceMask &=
2268 ~Thread::getCurrentLocalFlags();
2269
2270 return returnValue;
2271 }
2272
2273
2274 FieldContainerTransitPtr FCDPtrTestFCNullCheckAccessBase::shallowCopyLocal(
2275 BitVector bFlags) const
2276 {
2277 FCDPtrTestFCNullCheckAccess *tmpPtr;
2278
2279 newPtr(tmpPtr, dynamic_cast<const FCDPtrTestFCNullCheckAccess *>(this), bFlags);
2280
2281 FieldContainerTransitPtr returnValue(tmpPtr);
2282
2283 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
2284
2285 return returnValue;
2286 }
2287
2288 FieldContainerTransitPtr FCDPtrTestFCNullCheckAccessBase::shallowCopyDependent(
2289 BitVector bFlags) const
2290 {
2291 FCDPtrTestFCNullCheckAccess *tmpPtr;
2292
2293 newPtr(tmpPtr, dynamic_cast<const FCDPtrTestFCNullCheckAccess *>(this), ~bFlags);
2294
2295 FieldContainerTransitPtr returnValue(tmpPtr);
2296
2297 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
2298
2299 return returnValue;
2300 }
2301
2302 FieldContainerTransitPtr FCDPtrTestFCNullCheckAccessBase::shallowCopy(void) const
2303 {
2304 FCDPtrTestFCNullCheckAccess *tmpPtr;
2305
2306 newPtr(tmpPtr,
2307 dynamic_cast<const FCDPtrTestFCNullCheckAccess *>(this),
2308 Thread::getCurrentLocalFlags());
2309
2310 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
2311
2312 FieldContainerTransitPtr returnValue(tmpPtr);
2313
2314 return returnValue;
2315 }
2316
2317
2318
2319
2320 /*------------------------- constructors ----------------------------------*/
2321
2322 FCDPtrTestFCNullCheckAccessBase::FCDPtrTestFCNullCheckAccessBase(void) :
2323 Inherited(),
2324 _sfFieldSFPub_ptr (0),
2325 _sfFieldSFPub_weakptr (0),
2326 _sfFieldSFPub_mpchildptr (this,
2327 FieldSFPub_mpchildptrFieldId,
2328 FCDTestFC::ParentsFieldId),
2329 _sfFieldSFPro_ptr (0),
2330 _sfFieldSFPro_weakptr (0),
2331 _sfFieldSFPro_mpchildptr (this,
2332 FieldSFPro_mpchildptrFieldId,
2333 FCDTestFC::ParentsFieldId),
2334 _sfFieldSFNo_ptr (0),
2335 _sfFieldSFNo_weakptr (0),
2336 _sfFieldSFNo_mpchildptr (this,
2337 FieldSFNo_mpchildptrFieldId,
2338 FCDTestFC::ParentsFieldId),
2339 _mfFieldMFPub_ptr (),
2340 _mfFieldMFPub_weakptr (),
2341 _mfFieldMFPub_mpchildptr (this,
2342 FieldMFPub_mpchildptrFieldId,
2343 FCDTestFC::ParentsFieldId),
2344 _mfFieldMFPro_ptr (),
2345 _mfFieldMFPro_weakptr (),
2346 _mfFieldMFPro_mpchildptr (this,
2347 FieldMFPro_mpchildptrFieldId,
2348 FCDTestFC::ParentsFieldId),
2349 _mfFieldMFNo_ptr (),
2350 _mfFieldMFNo_weakptr (),
2351 _mfFieldMFNo_mpchildptr (this,
2352 FieldMFNo_mpchildptrFieldId,
2353 FCDTestFC::ParentsFieldId),
2354 _sfFieldSFPub_spchildptr (this,
2355 FieldSFPub_spchildptrFieldId,
2356 FCDSParTestFC::ParentFieldId),
2357 _sfFieldSFPro_spchildptr (this,
2358 FieldSFPro_spchildptrFieldId,
2359 FCDSParTestFC::ParentFieldId),
2360 _sfFieldSFNo_spchildptr (this,
2361 FieldSFNo_spchildptrFieldId,
2362 FCDSParTestFC::ParentFieldId),
2363 _mfFieldMFPub_spchildptr (this,
2364 FieldMFPub_spchildptrFieldId,
2365 FCDSParTestFC::ParentFieldId),
2366 _mfFieldMFPro_spchildptr (this,
2367 FieldMFPro_spchildptrFieldId,
2368 FCDSParTestFC::ParentFieldId),
2369 _mfFieldMFNo_spchildptr (this,
2370 FieldMFNo_spchildptrFieldId,
2371 FCDSParTestFC::ParentFieldId)
2372 {
2373 }
2374
2375 FCDPtrTestFCNullCheckAccessBase::FCDPtrTestFCNullCheckAccessBase(const FCDPtrTestFCNullCheckAccessBase &source) :
2376 Inherited(source),
2377 _sfFieldSFPub_ptr (NULL),
2378 _sfFieldSFPub_weakptr (NULL),
2379 _sfFieldSFPub_mpchildptr (this,
2380 FieldSFPub_mpchildptrFieldId,
2381 FCDTestFC::ParentsFieldId),
2382 _sfFieldSFPro_ptr (NULL),
2383 _sfFieldSFPro_weakptr (NULL),
2384 _sfFieldSFPro_mpchildptr (this,
2385 FieldSFPro_mpchildptrFieldId,
2386 FCDTestFC::ParentsFieldId),
2387 _sfFieldSFNo_ptr (NULL),
2388 _sfFieldSFNo_weakptr (NULL),
2389 _sfFieldSFNo_mpchildptr (this,
2390 FieldSFNo_mpchildptrFieldId,
2391 FCDTestFC::ParentsFieldId),
2392 _mfFieldMFPub_ptr (),
2393 _mfFieldMFPub_weakptr (),
2394 _mfFieldMFPub_mpchildptr (this,
2395 FieldMFPub_mpchildptrFieldId,
2396 FCDTestFC::ParentsFieldId),
2397 _mfFieldMFPro_ptr (),
2398 _mfFieldMFPro_weakptr (),
2399 _mfFieldMFPro_mpchildptr (this,
2400 FieldMFPro_mpchildptrFieldId,
2401 FCDTestFC::ParentsFieldId),
2402 _mfFieldMFNo_ptr (),
2403 _mfFieldMFNo_weakptr (),
2404 _mfFieldMFNo_mpchildptr (this,
2405 FieldMFNo_mpchildptrFieldId,
2406 FCDTestFC::ParentsFieldId),
2407 _sfFieldSFPub_spchildptr (this,
2408 FieldSFPub_spchildptrFieldId,
2409 FCDSParTestFC::ParentFieldId),
2410 _sfFieldSFPro_spchildptr (this,
2411 FieldSFPro_spchildptrFieldId,
2412 FCDSParTestFC::ParentFieldId),
2413 _sfFieldSFNo_spchildptr (this,
2414 FieldSFNo_spchildptrFieldId,
2415 FCDSParTestFC::ParentFieldId),
2416 _mfFieldMFPub_spchildptr (this,
2417 FieldMFPub_spchildptrFieldId,
2418 FCDSParTestFC::ParentFieldId),
2419 _mfFieldMFPro_spchildptr (this,
2420 FieldMFPro_spchildptrFieldId,
2421 FCDSParTestFC::ParentFieldId),
2422 _mfFieldMFNo_spchildptr (this,
2423 FieldMFNo_spchildptrFieldId,
2424 FCDSParTestFC::ParentFieldId)
2425 {
2426 }
2427
2428
2429 /*-------------------------- destructors ----------------------------------*/
2430
2431 FCDPtrTestFCNullCheckAccessBase::~FCDPtrTestFCNullCheckAccessBase(void)
2432 {
2433 }
2434
2435 /*-------------------------------------------------------------------------*/
2436 /* Child linking */
2437
2438 bool FCDPtrTestFCNullCheckAccessBase::unlinkChild(
2439 FieldContainer * const pChild,
2440 UInt16 const childFieldId)
2441 {
2442 if(childFieldId == FieldSFPub_mpchildptrFieldId)
2443 {
2444 FCDTestFC * pTypedChild =
2445 dynamic_cast<FCDTestFC *>(pChild);
2446
2447 if(pTypedChild != NULL)
2448 {
2449 if(_sfFieldSFPub_mpchildptr.getValue() == pTypedChild)
2450 {
2451 editSField(FieldSFPub_mpchildptrFieldMask);
2452
2453 _sfFieldSFPub_mpchildptr.setValue(NULL);
2454
2455 return true;
2456 }
2457
2458 SWARNING << "Parent ([" << this
2459 << "] id [" << this->getId()
2460 << "] type [" << this->getType().getCName()
2461 << "] childFieldId [" << childFieldId
2462 << "]) - Child ([" << pChild
2463 << "] id [" << pChild->getId()
2464 << "] type [" << pChild->getType().getCName()
2465 << "]): link inconsistent!"
2466 << std::endl;
2467
2468 return false;
2469 }
2470
2471 return false;
2472 }
2473
2474 if(childFieldId == FieldSFPro_mpchildptrFieldId)
2475 {
2476 FCDTestFC * pTypedChild =
2477 dynamic_cast<FCDTestFC *>(pChild);
2478
2479 if(pTypedChild != NULL)
2480 {
2481 if(_sfFieldSFPro_mpchildptr.getValue() == pTypedChild)
2482 {
2483 editSField(FieldSFPro_mpchildptrFieldMask);
2484
2485 _sfFieldSFPro_mpchildptr.setValue(NULL);
2486
2487 return true;
2488 }
2489
2490 SWARNING << "Parent ([" << this
2491 << "] id [" << this->getId()
2492 << "] type [" << this->getType().getCName()
2493 << "] childFieldId [" << childFieldId
2494 << "]) - Child ([" << pChild
2495 << "] id [" << pChild->getId()
2496 << "] type [" << pChild->getType().getCName()
2497 << "]): link inconsistent!"
2498 << std::endl;
2499
2500 return false;
2501 }
2502
2503 return false;
2504 }
2505
2506 if(childFieldId == FieldSFNo_mpchildptrFieldId)
2507 {
2508 FCDTestFC * pTypedChild =
2509 dynamic_cast<FCDTestFC *>(pChild);
2510
2511 if(pTypedChild != NULL)
2512 {
2513 if(_sfFieldSFNo_mpchildptr.getValue() == pTypedChild)
2514 {
2515 editSField(FieldSFNo_mpchildptrFieldMask);
2516
2517 _sfFieldSFNo_mpchildptr.setValue(NULL);
2518
2519 return true;
2520 }
2521
2522 SWARNING << "Parent ([" << this
2523 << "] id [" << this->getId()
2524 << "] type [" << this->getType().getCName()
2525 << "] childFieldId [" << childFieldId
2526 << "]) - Child ([" << pChild
2527 << "] id [" << pChild->getId()
2528 << "] type [" << pChild->getType().getCName()
2529 << "]): link inconsistent!"
2530 << std::endl;
2531
2532 return false;
2533 }
2534
2535 return false;
2536 }
2537
2538 if(childFieldId == FieldMFPub_mpchildptrFieldId)
2539 {
2540 FCDTestFC * pTypedChild =
2541 dynamic_cast<FCDTestFC *>(pChild);
2542
2543 if(pTypedChild != NULL)
2544 {
2545 Int32 iChildIdx = _mfFieldMFPub_mpchildptr.findIndex(pTypedChild);
2546
2547 if(iChildIdx != -1)
2548 {
2549 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
2550
2551 _mfFieldMFPub_mpchildptr.erase(iChildIdx);
2552
2553 return true;
2554 }
2555
2556 SWARNING << "Parent ([" << this
2557 << "] id [" << this->getId()
2558 << "] type [" << this->getType().getCName()
2559 << "] childFieldId [" << childFieldId
2560 << "]) - Child ([" << pChild
2561 << "] id [" << pChild->getId()
2562 << "] type [" << pChild->getType().getCName()
2563 << "]): link inconsistent!"
2564 << std::endl;
2565
2566 return false;
2567 }
2568
2569 return false;
2570 }
2571
2572 if(childFieldId == FieldMFPro_mpchildptrFieldId)
2573 {
2574 FCDTestFC * pTypedChild =
2575 dynamic_cast<FCDTestFC *>(pChild);
2576
2577 if(pTypedChild != NULL)
2578 {
2579 Int32 iChildIdx = _mfFieldMFPro_mpchildptr.findIndex(pTypedChild);
2580
2581 if(iChildIdx != -1)
2582 {
2583 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
2584
2585 _mfFieldMFPro_mpchildptr.erase(iChildIdx);
2586
2587 return true;
2588 }
2589
2590 SWARNING << "Parent ([" << this
2591 << "] id [" << this->getId()
2592 << "] type [" << this->getType().getCName()
2593 << "] childFieldId [" << childFieldId
2594 << "]) - Child ([" << pChild
2595 << "] id [" << pChild->getId()
2596 << "] type [" << pChild->getType().getCName()
2597 << "]): link inconsistent!"
2598 << std::endl;
2599
2600 return false;
2601 }
2602
2603 return false;
2604 }
2605
2606 if(childFieldId == FieldMFNo_mpchildptrFieldId)
2607 {
2608 FCDTestFC * pTypedChild =
2609 dynamic_cast<FCDTestFC *>(pChild);
2610
2611 if(pTypedChild != NULL)
2612 {
2613 Int32 iChildIdx = _mfFieldMFNo_mpchildptr.findIndex(pTypedChild);
2614
2615 if(iChildIdx != -1)
2616 {
2617 editMField(FieldMFNo_mpchildptrFieldMask, _mfFieldMFNo_mpchildptr);
2618
2619 _mfFieldMFNo_mpchildptr.erase(iChildIdx);
2620
2621 return true;
2622 }
2623
2624 SWARNING << "Parent ([" << this
2625 << "] id [" << this->getId()
2626 << "] type [" << this->getType().getCName()
2627 << "] childFieldId [" << childFieldId
2628 << "]) - Child ([" << pChild
2629 << "] id [" << pChild->getId()
2630 << "] type [" << pChild->getType().getCName()
2631 << "]): link inconsistent!"
2632 << std::endl;
2633
2634 return false;
2635 }
2636
2637 return false;
2638 }
2639
2640 if(childFieldId == FieldSFPub_spchildptrFieldId)
2641 {
2642 FCDSParTestFC * pTypedChild =
2643 dynamic_cast<FCDSParTestFC *>(pChild);
2644
2645 if(pTypedChild != NULL)
2646 {
2647 if(_sfFieldSFPub_spchildptr.getValue() == pTypedChild)
2648 {
2649 editSField(FieldSFPub_spchildptrFieldMask);
2650
2651 _sfFieldSFPub_spchildptr.setValue(NULL);
2652
2653 return true;
2654 }
2655
2656 SWARNING << "Parent ([" << this
2657 << "] id [" << this->getId()
2658 << "] type [" << this->getType().getCName()
2659 << "] childFieldId [" << childFieldId
2660 << "]) - Child ([" << pChild
2661 << "] id [" << pChild->getId()
2662 << "] type [" << pChild->getType().getCName()
2663 << "]): link inconsistent!"
2664 << std::endl;
2665
2666 return false;
2667 }
2668
2669 return false;
2670 }
2671
2672 if(childFieldId == FieldSFPro_spchildptrFieldId)
2673 {
2674 FCDSParTestFC * pTypedChild =
2675 dynamic_cast<FCDSParTestFC *>(pChild);
2676
2677 if(pTypedChild != NULL)
2678 {
2679 if(_sfFieldSFPro_spchildptr.getValue() == pTypedChild)
2680 {
2681 editSField(FieldSFPro_spchildptrFieldMask);
2682
2683 _sfFieldSFPro_spchildptr.setValue(NULL);
2684
2685 return true;
2686 }
2687
2688 SWARNING << "Parent ([" << this
2689 << "] id [" << this->getId()
2690 << "] type [" << this->getType().getCName()
2691 << "] childFieldId [" << childFieldId
2692 << "]) - Child ([" << pChild
2693 << "] id [" << pChild->getId()
2694 << "] type [" << pChild->getType().getCName()
2695 << "]): link inconsistent!"
2696 << std::endl;
2697
2698 return false;
2699 }
2700
2701 return false;
2702 }
2703
2704 if(childFieldId == FieldSFNo_spchildptrFieldId)
2705 {
2706 FCDSParTestFC * pTypedChild =
2707 dynamic_cast<FCDSParTestFC *>(pChild);
2708
2709 if(pTypedChild != NULL)
2710 {
2711 if(_sfFieldSFNo_spchildptr.getValue() == pTypedChild)
2712 {
2713 editSField(FieldSFNo_spchildptrFieldMask);
2714
2715 _sfFieldSFNo_spchildptr.setValue(NULL);
2716
2717 return true;
2718 }
2719
2720 SWARNING << "Parent ([" << this
2721 << "] id [" << this->getId()
2722 << "] type [" << this->getType().getCName()
2723 << "] childFieldId [" << childFieldId
2724 << "]) - Child ([" << pChild
2725 << "] id [" << pChild->getId()
2726 << "] type [" << pChild->getType().getCName()
2727 << "]): link inconsistent!"
2728 << std::endl;
2729
2730 return false;
2731 }
2732
2733 return false;
2734 }
2735
2736 if(childFieldId == FieldMFPub_spchildptrFieldId)
2737 {
2738 FCDSParTestFC * pTypedChild =
2739 dynamic_cast<FCDSParTestFC *>(pChild);
2740
2741 if(pTypedChild != NULL)
2742 {
2743 Int32 iChildIdx = _mfFieldMFPub_spchildptr.findIndex(pTypedChild);
2744
2745 if(iChildIdx != -1)
2746 {
2747 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
2748
2749 _mfFieldMFPub_spchildptr.erase(iChildIdx);
2750
2751 return true;
2752 }
2753
2754 SWARNING << "Parent ([" << this
2755 << "] id [" << this->getId()
2756 << "] type [" << this->getType().getCName()
2757 << "] childFieldId [" << childFieldId
2758 << "]) - Child ([" << pChild
2759 << "] id [" << pChild->getId()
2760 << "] type [" << pChild->getType().getCName()
2761 << "]): link inconsistent!"
2762 << std::endl;
2763
2764 return false;
2765 }
2766
2767 return false;
2768 }
2769
2770 if(childFieldId == FieldMFPro_spchildptrFieldId)
2771 {
2772 FCDSParTestFC * pTypedChild =
2773 dynamic_cast<FCDSParTestFC *>(pChild);
2774
2775 if(pTypedChild != NULL)
2776 {
2777 Int32 iChildIdx = _mfFieldMFPro_spchildptr.findIndex(pTypedChild);
2778
2779 if(iChildIdx != -1)
2780 {
2781 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
2782
2783 _mfFieldMFPro_spchildptr.erase(iChildIdx);
2784
2785 return true;
2786 }
2787
2788 SWARNING << "Parent ([" << this
2789 << "] id [" << this->getId()
2790 << "] type [" << this->getType().getCName()
2791 << "] childFieldId [" << childFieldId
2792 << "]) - Child ([" << pChild
2793 << "] id [" << pChild->getId()
2794 << "] type [" << pChild->getType().getCName()
2795 << "]): link inconsistent!"
2796 << std::endl;
2797
2798 return false;
2799 }
2800
2801 return false;
2802 }
2803
2804 if(childFieldId == FieldMFNo_spchildptrFieldId)
2805 {
2806 FCDSParTestFC * pTypedChild =
2807 dynamic_cast<FCDSParTestFC *>(pChild);
2808
2809 if(pTypedChild != NULL)
2810 {
2811 Int32 iChildIdx = _mfFieldMFNo_spchildptr.findIndex(pTypedChild);
2812
2813 if(iChildIdx != -1)
2814 {
2815 editMField(FieldMFNo_spchildptrFieldMask, _mfFieldMFNo_spchildptr);
2816
2817 _mfFieldMFNo_spchildptr.erase(iChildIdx);
2818
2819 return true;
2820 }
2821
2822 SWARNING << "Parent ([" << this
2823 << "] id [" << this->getId()
2824 << "] type [" << this->getType().getCName()
2825 << "] childFieldId [" << childFieldId
2826 << "]) - Child ([" << pChild
2827 << "] id [" << pChild->getId()
2828 << "] type [" << pChild->getType().getCName()
2829 << "]): link inconsistent!"
2830 << std::endl;
2831
2832 return false;
2833 }
2834
2835 return false;
2836 }
2837
2838
2839 return Inherited::unlinkChild(pChild, childFieldId);
2840 }
2841
2842 void FCDPtrTestFCNullCheckAccessBase::onCreate(const FCDPtrTestFCNullCheckAccess *source)
2843 {
2844 Inherited::onCreate(source);
2845
2846 if(source != NULL)
2847 {
2848 FCDPtrTestFCNullCheckAccess *pThis = static_cast<FCDPtrTestFCNullCheckAccess *>(this);
2849
2850 pThis->setFieldSFPub_ptr(source->getFieldSFPub_ptr());
2851
2852 pThis->setFieldSFPub_weakptr(source->getFieldSFPub_weakptr());
2853
2854 pThis->setFieldSFPub_mpchildptr(source->getFieldSFPub_mpchildptr());
2855
2856 pThis->setFieldSFPro_ptr(source->getFieldSFPro_ptr());
2857
2858 pThis->setFieldSFPro_weakptr(source->getFieldSFPro_weakptr());
2859
2860 pThis->setFieldSFPro_mpchildptr(source->getFieldSFPro_mpchildptr());
2861
2862 MFUnrecFCDTestFCPtr::const_iterator FieldMFPub_ptrIt =
2863 source->_mfFieldMFPub_ptr.begin();
2864 MFUnrecFCDTestFCPtr::const_iterator FieldMFPub_ptrEnd =
2865 source->_mfFieldMFPub_ptr.end ();
2866
2867 while(FieldMFPub_ptrIt != FieldMFPub_ptrEnd)
2868 {
2869 pThis->pushToFieldMFPub_ptr(*FieldMFPub_ptrIt);
2870
2871 ++FieldMFPub_ptrIt;
2872 }
2873
2874 MFWeakFCDTestFCPtr::const_iterator FieldMFPub_weakptrIt =
2875 source->_mfFieldMFPub_weakptr.begin();
2876 MFWeakFCDTestFCPtr::const_iterator FieldMFPub_weakptrEnd =
2877 source->_mfFieldMFPub_weakptr.end ();
2878
2879 while(FieldMFPub_weakptrIt != FieldMFPub_weakptrEnd)
2880 {
2881 pThis->pushToFieldMFPub_weakptr(*FieldMFPub_weakptrIt);
2882
2883 ++FieldMFPub_weakptrIt;
2884 }
2885
2886 MFUnrecChildFCDTestFCPtr::const_iterator FieldMFPub_mpchildptrIt =
2887 source->_mfFieldMFPub_mpchildptr.begin();
2888 MFUnrecChildFCDTestFCPtr::const_iterator FieldMFPub_mpchildptrEnd =
2889 source->_mfFieldMFPub_mpchildptr.end ();
2890
2891 while(FieldMFPub_mpchildptrIt != FieldMFPub_mpchildptrEnd)
2892 {
2893 pThis->pushToFieldMFPub_mpchildptr(*FieldMFPub_mpchildptrIt);
2894
2895 ++FieldMFPub_mpchildptrIt;
2896 }
2897
2898 MFUnrecFCDTestFCPtr::const_iterator FieldMFPro_ptrIt =
2899 source->_mfFieldMFPro_ptr.begin();
2900 MFUnrecFCDTestFCPtr::const_iterator FieldMFPro_ptrEnd =
2901 source->_mfFieldMFPro_ptr.end ();
2902
2903 while(FieldMFPro_ptrIt != FieldMFPro_ptrEnd)
2904 {
2905 pThis->pushToFieldMFPro_ptr(*FieldMFPro_ptrIt);
2906
2907 ++FieldMFPro_ptrIt;
2908 }
2909
2910 MFWeakFCDTestFCPtr::const_iterator FieldMFPro_weakptrIt =
2911 source->_mfFieldMFPro_weakptr.begin();
2912 MFWeakFCDTestFCPtr::const_iterator FieldMFPro_weakptrEnd =
2913 source->_mfFieldMFPro_weakptr.end ();
2914
2915 while(FieldMFPro_weakptrIt != FieldMFPro_weakptrEnd)
2916 {
2917 pThis->pushToFieldMFPro_weakptr(*FieldMFPro_weakptrIt);
2918
2919 ++FieldMFPro_weakptrIt;
2920 }
2921
2922 MFUnrecChildFCDTestFCPtr::const_iterator FieldMFPro_mpchildptrIt =
2923 source->_mfFieldMFPro_mpchildptr.begin();
2924 MFUnrecChildFCDTestFCPtr::const_iterator FieldMFPro_mpchildptrEnd =
2925 source->_mfFieldMFPro_mpchildptr.end ();
2926
2927 while(FieldMFPro_mpchildptrIt != FieldMFPro_mpchildptrEnd)
2928 {
2929 pThis->pushToFieldMFPro_mpchildptr(*FieldMFPro_mpchildptrIt);
2930
2931 ++FieldMFPro_mpchildptrIt;
2932 }
2933
2934 pThis->setFieldSFPub_spchildptr(source->getFieldSFPub_spchildptr());
2935
2936 pThis->setFieldSFPro_spchildptr(source->getFieldSFPro_spchildptr());
2937
2938 MFUnrecChildFCDSParTestFCPtr::const_iterator FieldMFPub_spchildptrIt =
2939 source->_mfFieldMFPub_spchildptr.begin();
2940 MFUnrecChildFCDSParTestFCPtr::const_iterator FieldMFPub_spchildptrEnd =
2941 source->_mfFieldMFPub_spchildptr.end ();
2942
2943 while(FieldMFPub_spchildptrIt != FieldMFPub_spchildptrEnd)
2944 {
2945 pThis->pushToFieldMFPub_spchildptr(*FieldMFPub_spchildptrIt);
2946
2947 ++FieldMFPub_spchildptrIt;
2948 }
2949
2950 MFUnrecChildFCDSParTestFCPtr::const_iterator FieldMFPro_spchildptrIt =
2951 source->_mfFieldMFPro_spchildptr.begin();
2952 MFUnrecChildFCDSParTestFCPtr::const_iterator FieldMFPro_spchildptrEnd =
2953 source->_mfFieldMFPro_spchildptr.end ();
2954
2955 while(FieldMFPro_spchildptrIt != FieldMFPro_spchildptrEnd)
2956 {
2957 pThis->pushToFieldMFPro_spchildptr(*FieldMFPro_spchildptrIt);
2958
2959 ++FieldMFPro_spchildptrIt;
2960 }
2961 }
2962 }
2963
2964 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPub_ptr (void) const
2965 {
2966 SFUnrecFCDTestFCPtr::GetHandlePtr returnValue(
2967 new SFUnrecFCDTestFCPtr::GetHandle(
2968 &_sfFieldSFPub_ptr,
2969 this->getType().getFieldDesc(FieldSFPub_ptrFieldId),
2970 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
2971
2972 return returnValue;
2973 }
2974
2975 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPub_ptr (void)
2976 {
2977 SFUnrecFCDTestFCPtr::EditHandlePtr returnValue(
2978 new SFUnrecFCDTestFCPtr::EditHandle(
2979 &_sfFieldSFPub_ptr,
2980 this->getType().getFieldDesc(FieldSFPub_ptrFieldId),
2981 this));
2982
2983 returnValue->setSetMethod(
2984 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPub_ptr,
2985 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
2986
2987 editSField(FieldSFPub_ptrFieldMask);
2988
2989 return returnValue;
2990 }
2991
2992 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPub_weakptr (void) const
2993 {
2994 SFWeakFCDTestFCPtr::GetHandlePtr returnValue(
2995 new SFWeakFCDTestFCPtr::GetHandle(
2996 &_sfFieldSFPub_weakptr,
2997 this->getType().getFieldDesc(FieldSFPub_weakptrFieldId),
2998 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
2999
3000 return returnValue;
3001 }
3002
3003 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPub_weakptr(void)
3004 {
3005 SFWeakFCDTestFCPtr::EditHandlePtr returnValue(
3006 new SFWeakFCDTestFCPtr::EditHandle(
3007 &_sfFieldSFPub_weakptr,
3008 this->getType().getFieldDesc(FieldSFPub_weakptrFieldId),
3009 this));
3010
3011 returnValue->setSetMethod(
3012 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPub_weakptr,
3013 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3014
3015 editSField(FieldSFPub_weakptrFieldMask);
3016
3017 return returnValue;
3018 }
3019
3020 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPub_mpchildptr (void) const
3021 {
3022 SFUnrecChildFCDTestFCPtr::GetHandlePtr returnValue(
3023 new SFUnrecChildFCDTestFCPtr::GetHandle(
3024 &_sfFieldSFPub_mpchildptr,
3025 this->getType().getFieldDesc(FieldSFPub_mpchildptrFieldId),
3026 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3027
3028 return returnValue;
3029 }
3030
3031 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPub_mpchildptr(void)
3032 {
3033 SFUnrecChildFCDTestFCPtr::EditHandlePtr returnValue(
3034 new SFUnrecChildFCDTestFCPtr::EditHandle(
3035 &_sfFieldSFPub_mpchildptr,
3036 this->getType().getFieldDesc(FieldSFPub_mpchildptrFieldId),
3037 this));
3038
3039 returnValue->setSetMethod(
3040 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPub_mpchildptr,
3041 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3042
3043 editSField(FieldSFPub_mpchildptrFieldMask);
3044
3045 return returnValue;
3046 }
3047
3048 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPro_ptr (void) const
3049 {
3050 SFUnrecFCDTestFCPtr::GetHandlePtr returnValue(
3051 new SFUnrecFCDTestFCPtr::GetHandle(
3052 &_sfFieldSFPro_ptr,
3053 this->getType().getFieldDesc(FieldSFPro_ptrFieldId),
3054 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3055
3056 return returnValue;
3057 }
3058
3059 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPro_ptr (void)
3060 {
3061 SFUnrecFCDTestFCPtr::EditHandlePtr returnValue(
3062 new SFUnrecFCDTestFCPtr::EditHandle(
3063 &_sfFieldSFPro_ptr,
3064 this->getType().getFieldDesc(FieldSFPro_ptrFieldId),
3065 this));
3066
3067 returnValue->setSetMethod(
3068 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPro_ptr,
3069 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3070
3071 editSField(FieldSFPro_ptrFieldMask);
3072
3073 return returnValue;
3074 }
3075
3076 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPro_weakptr (void) const
3077 {
3078 SFWeakFCDTestFCPtr::GetHandlePtr returnValue(
3079 new SFWeakFCDTestFCPtr::GetHandle(
3080 &_sfFieldSFPro_weakptr,
3081 this->getType().getFieldDesc(FieldSFPro_weakptrFieldId),
3082 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3083
3084 return returnValue;
3085 }
3086
3087 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPro_weakptr(void)
3088 {
3089 SFWeakFCDTestFCPtr::EditHandlePtr returnValue(
3090 new SFWeakFCDTestFCPtr::EditHandle(
3091 &_sfFieldSFPro_weakptr,
3092 this->getType().getFieldDesc(FieldSFPro_weakptrFieldId),
3093 this));
3094
3095 returnValue->setSetMethod(
3096 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPro_weakptr,
3097 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3098
3099 editSField(FieldSFPro_weakptrFieldMask);
3100
3101 return returnValue;
3102 }
3103
3104 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPro_mpchildptr (void) const
3105 {
3106 SFUnrecChildFCDTestFCPtr::GetHandlePtr returnValue(
3107 new SFUnrecChildFCDTestFCPtr::GetHandle(
3108 &_sfFieldSFPro_mpchildptr,
3109 this->getType().getFieldDesc(FieldSFPro_mpchildptrFieldId),
3110 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3111
3112 return returnValue;
3113 }
3114
3115 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPro_mpchildptr(void)
3116 {
3117 SFUnrecChildFCDTestFCPtr::EditHandlePtr returnValue(
3118 new SFUnrecChildFCDTestFCPtr::EditHandle(
3119 &_sfFieldSFPro_mpchildptr,
3120 this->getType().getFieldDesc(FieldSFPro_mpchildptrFieldId),
3121 this));
3122
3123 returnValue->setSetMethod(
3124 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPro_mpchildptr,
3125 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3126
3127 editSField(FieldSFPro_mpchildptrFieldMask);
3128
3129 return returnValue;
3130 }
3131
3132 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFNo_ptr (void) const
3133 {
3134 SFUnrecFCDTestFCPtr::GetHandlePtr returnValue;
3135
3136 return returnValue;
3137 }
3138
3139 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFNo_ptr (void)
3140 {
3141 EditFieldHandlePtr returnValue;
3142
3143 return returnValue;
3144 }
3145
3146 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFNo_weakptr (void) const
3147 {
3148 SFWeakFCDTestFCPtr::GetHandlePtr returnValue;
3149
3150 return returnValue;
3151 }
3152
3153 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFNo_weakptr(void)
3154 {
3155 EditFieldHandlePtr returnValue;
3156
3157 return returnValue;
3158 }
3159
3160 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFNo_mpchildptr (void) const
3161 {
3162 SFUnrecChildFCDTestFCPtr::GetHandlePtr returnValue;
3163
3164 return returnValue;
3165 }
3166
3167 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFNo_mpchildptr(void)
3168 {
3169 EditFieldHandlePtr returnValue;
3170
3171 return returnValue;
3172 }
3173
3174 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPub_ptr (void) const
3175 {
3176 MFUnrecFCDTestFCPtr::GetHandlePtr returnValue(
3177 new MFUnrecFCDTestFCPtr::GetHandle(
3178 &_mfFieldMFPub_ptr,
3179 this->getType().getFieldDesc(FieldMFPub_ptrFieldId),
3180 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3181
3182 return returnValue;
3183 }
3184
3185 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPub_ptr (void)
3186 {
3187 MFUnrecFCDTestFCPtr::EditHandlePtr returnValue(
3188 new MFUnrecFCDTestFCPtr::EditHandle(
3189 &_mfFieldMFPub_ptr,
3190 this->getType().getFieldDesc(FieldMFPub_ptrFieldId),
3191 this));
3192
3193 returnValue->setAddMethod(
3194 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPub_ptr,
3195 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3196 returnValue->setInsertMethod(
3197 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPub_ptr,
3198 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3199 returnValue->setReplaceMethod(
3200 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPub_ptr,
3201 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3202 returnValue->setReplaceObjMethod(
3203 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPub_ptr,
3204 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3205 returnValue->setRemoveMethod(
3206 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPub_ptr,
3207 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3208 returnValue->setRemoveObjMethod(
3209 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPub_ptr,
3210 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3211 returnValue->setClearMethod(
3212 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPub_ptr,
3213 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3214
3215 editMField(FieldMFPub_ptrFieldMask, _mfFieldMFPub_ptr);
3216
3217 return returnValue;
3218 }
3219
3220 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPub_weakptr (void) const
3221 {
3222 MFWeakFCDTestFCPtr::GetHandlePtr returnValue(
3223 new MFWeakFCDTestFCPtr::GetHandle(
3224 &_mfFieldMFPub_weakptr,
3225 this->getType().getFieldDesc(FieldMFPub_weakptrFieldId),
3226 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3227
3228 return returnValue;
3229 }
3230
3231 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPub_weakptr(void)
3232 {
3233 MFWeakFCDTestFCPtr::EditHandlePtr returnValue(
3234 new MFWeakFCDTestFCPtr::EditHandle(
3235 &_mfFieldMFPub_weakptr,
3236 this->getType().getFieldDesc(FieldMFPub_weakptrFieldId),
3237 this));
3238
3239 returnValue->setAddMethod(
3240 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPub_weakptr,
3241 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3242 returnValue->setInsertMethod(
3243 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPub_weakptr,
3244 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3245 returnValue->setReplaceMethod(
3246 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPub_weakptr,
3247 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3248 returnValue->setReplaceObjMethod(
3249 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPub_weakptr,
3250 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3251 returnValue->setRemoveMethod(
3252 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPub_weakptr,
3253 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3254 returnValue->setRemoveObjMethod(
3255 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPub_weakptr,
3256 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3257 returnValue->setClearMethod(
3258 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPub_weakptr,
3259 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3260
3261 editMField(FieldMFPub_weakptrFieldMask, _mfFieldMFPub_weakptr);
3262
3263 return returnValue;
3264 }
3265
3266 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPub_mpchildptr (void) const
3267 {
3268 MFUnrecChildFCDTestFCPtr::GetHandlePtr returnValue(
3269 new MFUnrecChildFCDTestFCPtr::GetHandle(
3270 &_mfFieldMFPub_mpchildptr,
3271 this->getType().getFieldDesc(FieldMFPub_mpchildptrFieldId),
3272 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3273
3274 return returnValue;
3275 }
3276
3277 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPub_mpchildptr(void)
3278 {
3279 MFUnrecChildFCDTestFCPtr::EditHandlePtr returnValue(
3280 new MFUnrecChildFCDTestFCPtr::EditHandle(
3281 &_mfFieldMFPub_mpchildptr,
3282 this->getType().getFieldDesc(FieldMFPub_mpchildptrFieldId),
3283 this));
3284
3285 returnValue->setAddMethod(
3286 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPub_mpchildptr,
3287 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3288 returnValue->setInsertMethod(
3289 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPub_mpchildptr,
3290 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3291 returnValue->setReplaceMethod(
3292 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPub_mpchildptr,
3293 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3294 returnValue->setReplaceObjMethod(
3295 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPub_mpchildptr,
3296 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3297 returnValue->setRemoveMethod(
3298 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPub_mpchildptr,
3299 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3300 returnValue->setRemoveObjMethod(
3301 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPub_mpchildptr,
3302 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3303 returnValue->setClearMethod(
3304 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPub_mpchildptr,
3305 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3306
3307 editMField(FieldMFPub_mpchildptrFieldMask, _mfFieldMFPub_mpchildptr);
3308
3309 return returnValue;
3310 }
3311
3312 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPro_ptr (void) const
3313 {
3314 MFUnrecFCDTestFCPtr::GetHandlePtr returnValue(
3315 new MFUnrecFCDTestFCPtr::GetHandle(
3316 &_mfFieldMFPro_ptr,
3317 this->getType().getFieldDesc(FieldMFPro_ptrFieldId),
3318 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3319
3320 return returnValue;
3321 }
3322
3323 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPro_ptr (void)
3324 {
3325 MFUnrecFCDTestFCPtr::EditHandlePtr returnValue(
3326 new MFUnrecFCDTestFCPtr::EditHandle(
3327 &_mfFieldMFPro_ptr,
3328 this->getType().getFieldDesc(FieldMFPro_ptrFieldId),
3329 this));
3330
3331 returnValue->setAddMethod(
3332 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPro_ptr,
3333 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3334 returnValue->setInsertMethod(
3335 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPro_ptr,
3336 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3337 returnValue->setReplaceMethod(
3338 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPro_ptr,
3339 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3340 returnValue->setReplaceObjMethod(
3341 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPro_ptr,
3342 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3343 returnValue->setRemoveMethod(
3344 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPro_ptr,
3345 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3346 returnValue->setRemoveObjMethod(
3347 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPro_ptr,
3348 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3349 returnValue->setClearMethod(
3350 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPro_ptr,
3351 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3352
3353 editMField(FieldMFPro_ptrFieldMask, _mfFieldMFPro_ptr);
3354
3355 return returnValue;
3356 }
3357
3358 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPro_weakptr (void) const
3359 {
3360 MFWeakFCDTestFCPtr::GetHandlePtr returnValue(
3361 new MFWeakFCDTestFCPtr::GetHandle(
3362 &_mfFieldMFPro_weakptr,
3363 this->getType().getFieldDesc(FieldMFPro_weakptrFieldId),
3364 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3365
3366 return returnValue;
3367 }
3368
3369 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPro_weakptr(void)
3370 {
3371 MFWeakFCDTestFCPtr::EditHandlePtr returnValue(
3372 new MFWeakFCDTestFCPtr::EditHandle(
3373 &_mfFieldMFPro_weakptr,
3374 this->getType().getFieldDesc(FieldMFPro_weakptrFieldId),
3375 this));
3376
3377 returnValue->setAddMethod(
3378 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPro_weakptr,
3379 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3380 returnValue->setInsertMethod(
3381 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPro_weakptr,
3382 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3383 returnValue->setReplaceMethod(
3384 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPro_weakptr,
3385 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3386 returnValue->setReplaceObjMethod(
3387 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPro_weakptr,
3388 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3389 returnValue->setRemoveMethod(
3390 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPro_weakptr,
3391 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3392 returnValue->setRemoveObjMethod(
3393 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPro_weakptr,
3394 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3395 returnValue->setClearMethod(
3396 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPro_weakptr,
3397 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3398
3399 editMField(FieldMFPro_weakptrFieldMask, _mfFieldMFPro_weakptr);
3400
3401 return returnValue;
3402 }
3403
3404 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPro_mpchildptr (void) const
3405 {
3406 MFUnrecChildFCDTestFCPtr::GetHandlePtr returnValue(
3407 new MFUnrecChildFCDTestFCPtr::GetHandle(
3408 &_mfFieldMFPro_mpchildptr,
3409 this->getType().getFieldDesc(FieldMFPro_mpchildptrFieldId),
3410 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3411
3412 return returnValue;
3413 }
3414
3415 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPro_mpchildptr(void)
3416 {
3417 MFUnrecChildFCDTestFCPtr::EditHandlePtr returnValue(
3418 new MFUnrecChildFCDTestFCPtr::EditHandle(
3419 &_mfFieldMFPro_mpchildptr,
3420 this->getType().getFieldDesc(FieldMFPro_mpchildptrFieldId),
3421 this));
3422
3423 returnValue->setAddMethod(
3424 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPro_mpchildptr,
3425 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3426 returnValue->setInsertMethod(
3427 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPro_mpchildptr,
3428 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3429 returnValue->setReplaceMethod(
3430 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPro_mpchildptr,
3431 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3432 returnValue->setReplaceObjMethod(
3433 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPro_mpchildptr,
3434 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3435 returnValue->setRemoveMethod(
3436 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPro_mpchildptr,
3437 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3438 returnValue->setRemoveObjMethod(
3439 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPro_mpchildptr,
3440 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3441 returnValue->setClearMethod(
3442 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPro_mpchildptr,
3443 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3444
3445 editMField(FieldMFPro_mpchildptrFieldMask, _mfFieldMFPro_mpchildptr);
3446
3447 return returnValue;
3448 }
3449
3450 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFNo_ptr (void) const
3451 {
3452 MFUnrecFCDTestFCPtr::GetHandlePtr returnValue;
3453
3454 return returnValue;
3455 }
3456
3457 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFNo_ptr (void)
3458 {
3459 EditFieldHandlePtr returnValue;
3460
3461 return returnValue;
3462 }
3463
3464 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFNo_weakptr (void) const
3465 {
3466 MFWeakFCDTestFCPtr::GetHandlePtr returnValue;
3467
3468 return returnValue;
3469 }
3470
3471 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFNo_weakptr(void)
3472 {
3473 EditFieldHandlePtr returnValue;
3474
3475 return returnValue;
3476 }
3477
3478 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFNo_mpchildptr (void) const
3479 {
3480 MFUnrecChildFCDTestFCPtr::GetHandlePtr returnValue;
3481
3482 return returnValue;
3483 }
3484
3485 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFNo_mpchildptr(void)
3486 {
3487 EditFieldHandlePtr returnValue;
3488
3489 return returnValue;
3490 }
3491
3492 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPub_spchildptr (void) const
3493 {
3494 SFUnrecChildFCDSParTestFCPtr::GetHandlePtr returnValue(
3495 new SFUnrecChildFCDSParTestFCPtr::GetHandle(
3496 &_sfFieldSFPub_spchildptr,
3497 this->getType().getFieldDesc(FieldSFPub_spchildptrFieldId),
3498 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3499
3500 return returnValue;
3501 }
3502
3503 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPub_spchildptr(void)
3504 {
3505 SFUnrecChildFCDSParTestFCPtr::EditHandlePtr returnValue(
3506 new SFUnrecChildFCDSParTestFCPtr::EditHandle(
3507 &_sfFieldSFPub_spchildptr,
3508 this->getType().getFieldDesc(FieldSFPub_spchildptrFieldId),
3509 this));
3510
3511 returnValue->setSetMethod(
3512 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPub_spchildptr,
3513 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3514
3515 editSField(FieldSFPub_spchildptrFieldMask);
3516
3517 return returnValue;
3518 }
3519
3520 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFPro_spchildptr (void) const
3521 {
3522 SFUnrecChildFCDSParTestFCPtr::GetHandlePtr returnValue(
3523 new SFUnrecChildFCDSParTestFCPtr::GetHandle(
3524 &_sfFieldSFPro_spchildptr,
3525 this->getType().getFieldDesc(FieldSFPro_spchildptrFieldId),
3526 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3527
3528 return returnValue;
3529 }
3530
3531 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFPro_spchildptr(void)
3532 {
3533 SFUnrecChildFCDSParTestFCPtr::EditHandlePtr returnValue(
3534 new SFUnrecChildFCDSParTestFCPtr::EditHandle(
3535 &_sfFieldSFPro_spchildptr,
3536 this->getType().getFieldDesc(FieldSFPro_spchildptrFieldId),
3537 this));
3538
3539 returnValue->setSetMethod(
3540 boost::bind(&FCDPtrTestFCNullCheckAccess::setFieldSFPro_spchildptr,
3541 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3542
3543 editSField(FieldSFPro_spchildptrFieldMask);
3544
3545 return returnValue;
3546 }
3547
3548 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldSFNo_spchildptr (void) const
3549 {
3550 SFUnrecChildFCDSParTestFCPtr::GetHandlePtr returnValue;
3551
3552 return returnValue;
3553 }
3554
3555 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldSFNo_spchildptr(void)
3556 {
3557 EditFieldHandlePtr returnValue;
3558
3559 return returnValue;
3560 }
3561
3562 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPub_spchildptr (void) const
3563 {
3564 MFUnrecChildFCDSParTestFCPtr::GetHandlePtr returnValue(
3565 new MFUnrecChildFCDSParTestFCPtr::GetHandle(
3566 &_mfFieldMFPub_spchildptr,
3567 this->getType().getFieldDesc(FieldMFPub_spchildptrFieldId),
3568 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3569
3570 return returnValue;
3571 }
3572
3573 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPub_spchildptr(void)
3574 {
3575 MFUnrecChildFCDSParTestFCPtr::EditHandlePtr returnValue(
3576 new MFUnrecChildFCDSParTestFCPtr::EditHandle(
3577 &_mfFieldMFPub_spchildptr,
3578 this->getType().getFieldDesc(FieldMFPub_spchildptrFieldId),
3579 this));
3580
3581 returnValue->setAddMethod(
3582 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPub_spchildptr,
3583 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3584 returnValue->setInsertMethod(
3585 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPub_spchildptr,
3586 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3587 returnValue->setReplaceMethod(
3588 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPub_spchildptr,
3589 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3590 returnValue->setReplaceObjMethod(
3591 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPub_spchildptr,
3592 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3593 returnValue->setRemoveMethod(
3594 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPub_spchildptr,
3595 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3596 returnValue->setRemoveObjMethod(
3597 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPub_spchildptr,
3598 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3599 returnValue->setClearMethod(
3600 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPub_spchildptr,
3601 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3602
3603 editMField(FieldMFPub_spchildptrFieldMask, _mfFieldMFPub_spchildptr);
3604
3605 return returnValue;
3606 }
3607
3608 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFPro_spchildptr (void) const
3609 {
3610 MFUnrecChildFCDSParTestFCPtr::GetHandlePtr returnValue(
3611 new MFUnrecChildFCDSParTestFCPtr::GetHandle(
3612 &_mfFieldMFPro_spchildptr,
3613 this->getType().getFieldDesc(FieldMFPro_spchildptrFieldId),
3614 const_cast<FCDPtrTestFCNullCheckAccessBase *>(this)));
3615
3616 return returnValue;
3617 }
3618
3619 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFPro_spchildptr(void)
3620 {
3621 MFUnrecChildFCDSParTestFCPtr::EditHandlePtr returnValue(
3622 new MFUnrecChildFCDSParTestFCPtr::EditHandle(
3623 &_mfFieldMFPro_spchildptr,
3624 this->getType().getFieldDesc(FieldMFPro_spchildptrFieldId),
3625 this));
3626
3627 returnValue->setAddMethod(
3628 boost::bind(&FCDPtrTestFCNullCheckAccess::pushToFieldMFPro_spchildptr,
3629 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3630 returnValue->setInsertMethod(
3631 boost::bind(&FCDPtrTestFCNullCheckAccess::insertIntoFieldMFPro_spchildptr,
3632 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3633 returnValue->setReplaceMethod(
3634 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceInFieldMFPro_spchildptr,
3635 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3636 returnValue->setReplaceObjMethod(
3637 boost::bind(&FCDPtrTestFCNullCheckAccess::replaceObjInFieldMFPro_spchildptr,
3638 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1, _2));
3639 returnValue->setRemoveMethod(
3640 boost::bind(&FCDPtrTestFCNullCheckAccess::removeFromFieldMFPro_spchildptr,
3641 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3642 returnValue->setRemoveObjMethod(
3643 boost::bind(&FCDPtrTestFCNullCheckAccess::removeObjFromFieldMFPro_spchildptr,
3644 static_cast<FCDPtrTestFCNullCheckAccess *>(this), _1));
3645 returnValue->setClearMethod(
3646 boost::bind(&FCDPtrTestFCNullCheckAccess::clearFieldMFPro_spchildptr,
3647 static_cast<FCDPtrTestFCNullCheckAccess *>(this)));
3648
3649 editMField(FieldMFPro_spchildptrFieldMask, _mfFieldMFPro_spchildptr);
3650
3651 return returnValue;
3652 }
3653
3654 GetFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::getHandleFieldMFNo_spchildptr (void) const
3655 {
3656 MFUnrecChildFCDSParTestFCPtr::GetHandlePtr returnValue;
3657
3658 return returnValue;
3659 }
3660
3661 EditFieldHandlePtr FCDPtrTestFCNullCheckAccessBase::editHandleFieldMFNo_spchildptr(void)
3662 {
3663 EditFieldHandlePtr returnValue;
3664
3665 return returnValue;
3666 }
3667
3668
3669 #ifdef OSG_MT_CPTR_ASPECT
3670 void FCDPtrTestFCNullCheckAccessBase::execSyncV( FieldContainer &oFrom,
3671 ConstFieldMaskArg whichField,
3672 AspectOffsetStore &oOffsets,
3673 ConstFieldMaskArg syncMode,
3674 const UInt32 uiSyncInfo)
3675 {
3676 FCDPtrTestFCNullCheckAccess *pThis = static_cast<FCDPtrTestFCNullCheckAccess *>(this);
3677
3678 pThis->execSync(static_cast<FCDPtrTestFCNullCheckAccess *>(&oFrom),
3679 whichField,
3680 oOffsets,
3681 syncMode,
3682 uiSyncInfo);
3683 }
3684 #endif
3685
3686
3687 #ifdef OSG_MT_CPTR_ASPECT
3688 FieldContainer *FCDPtrTestFCNullCheckAccessBase::createAspectCopy(
3689 const FieldContainer *pRefAspect) const
3690 {
3691 FCDPtrTestFCNullCheckAccess *returnValue;
3692
3693 newAspectCopy(returnValue,
3694 dynamic_cast<const FCDPtrTestFCNullCheckAccess *>(pRefAspect),
3695 dynamic_cast<const FCDPtrTestFCNullCheckAccess *>(this));
3696
3697 return returnValue;
3698 }
3699 #endif
3700
3701 void FCDPtrTestFCNullCheckAccessBase::resolveLinks(void)
3702 {
3703 Inherited::resolveLinks();
3704
3705 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPub_ptr(NULL);
3706
3707 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPub_weakptr(NULL);
3708
3709 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPub_mpchildptr(NULL);
3710
3711 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPro_ptr(NULL);
3712
3713 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPro_weakptr(NULL);
3714
3715 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPro_mpchildptr(NULL);
3716
3717 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_ptr();
3718
3719 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_weakptr();
3720
3721 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_mpchildptr();
3722
3723 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_ptr();
3724
3725 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_weakptr();
3726
3727 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_mpchildptr();
3728
3729 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPub_spchildptr(NULL);
3730
3731 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->setFieldSFPro_spchildptr(NULL);
3732
3733 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPub_spchildptr();
3734
3735 static_cast<FCDPtrTestFCNullCheckAccess *>(this)->clearFieldMFPro_spchildptr();
3736
3737
3738 }
3739
3740
3741 OSG_END_NAMESPACE