1 mike 1.1 /* @migen@ */
2 /*
3 **==============================================================================
4 **
5 ** WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. PLEASE DO NOT EDIT.
6 **
7 **==============================================================================
8 */
9 #ifndef _Outer_h
10 #define _Outer_h
11
12 #include <MI.h>
13 #include "Inner.h"
14
15 /*
16 **==============================================================================
17 **
18 ** Outer [Outer]
19 **
20 ** Keys:
21 ** Key
22 mike 1.1 **
23 **==============================================================================
24 */
25
26 typedef struct _Outer
27 {
28 MI_Instance __instance;
29 /* Outer properties */
30 /*KEY*/ MI_ConstUint32Field Key;
31 MI_ConstBooleanField booleanScalar;
32 MI_ConstUint8Field uint8Scalar;
33 MI_ConstSint8Field sint8Scalar;
34 MI_ConstUint16Field uint16Scalar;
35 MI_ConstSint16Field sint16Scalar;
36 MI_ConstUint32Field uint32Scalar;
37 MI_ConstSint32Field sint32Scalar;
38 MI_ConstUint64Field uint64Scalar;
39 MI_ConstSint64Field sint64Scalar;
40 MI_ConstReal32Field real32Scalar;
41 MI_ConstReal64Field real64Scalar;
42 MI_ConstChar16Field char16Scalar;
43 mike 1.1 MI_ConstDatetimeField datetimeScalar;
44 MI_ConstStringField stringScalar;
45 Inner_ConstRef instanceScalar;
46 MI_ConstBooleanAField booleanArray;
47 MI_ConstUint8AField uint8Array;
48 MI_ConstSint8AField sint8Array;
49 MI_ConstUint16AField uint16Array;
50 MI_ConstSint16AField sint16Array;
51 MI_ConstUint32AField uint32Array;
52 MI_ConstSint32AField sint32Array;
53 MI_ConstUint64AField uint64Array;
54 MI_ConstSint64AField sint64Array;
55 MI_ConstReal32AField real32Array;
56 MI_ConstReal64AField real64Array;
57 MI_ConstChar16AField char16Array;
58 MI_ConstDatetimeAField datetimeArray;
59 MI_ConstStringAField stringArray;
60 Inner_ConstArrayRef instanceArray;
61 }
62 Outer;
63
64 mike 1.1 typedef struct _Outer_Ref
65 {
66 Outer* value;
67 MI_Boolean exists;
68 MI_Uint8 flags;
69 }
70 Outer_Ref;
71
72 typedef struct _Outer_ConstRef
73 {
74 MI_CONST Outer* value;
75 MI_Boolean exists;
76 MI_Uint8 flags;
77 }
78 Outer_ConstRef;
79
80 typedef struct _Outer_Array
81 {
82 struct _Outer** data;
83 MI_Uint32 size;
84 }
85 mike 1.1 Outer_Array;
86
87 typedef struct _Outer_ConstArray
88 {
89 struct _Outer MI_CONST* MI_CONST* data;
90 MI_Uint32 size;
91 }
92 Outer_ConstArray;
93
94 typedef struct _Outer_ArrayRef
95 {
96 Outer_Array value;
97 MI_Boolean exists;
98 MI_Uint8 flags;
99 }
100 Outer_ArrayRef;
101
102 typedef struct _Outer_ConstArrayRef
103 {
104 Outer_ConstArray value;
105 MI_Boolean exists;
106 mike 1.1 MI_Uint8 flags;
107 }
108 Outer_ConstArrayRef;
109
110 MI_EXTERN_C MI_CONST MI_ClassDecl Outer_rtti;
111
112
113 /*
114 **==============================================================================
115 **
116 ** Outer_Class
117 **
118 **==============================================================================
119 */
120
121 #ifdef __cplusplus
122 # include <micxx/micxx.h>
123
124 MI_BEGIN_NAMESPACE
125
126 class Outer_Class : public Instance
127 mike 1.1 {
128 public:
129
130 typedef Outer Self;
131
132 Outer_Class() :
133 Instance(&Outer_rtti)
134 {
135 }
136
137 Outer_Class(
138 const Outer* instanceName,
139 bool keysOnly) :
140 Instance(
141 &Outer_rtti,
142 &instanceName->__instance,
143 keysOnly)
144 {
145 }
146
147 Outer_Class(
148 mike 1.1 const MI_ClassDecl* clDecl,
149 const MI_Instance* instance,
150 bool keysOnly) :
151 Instance(clDecl, instance, keysOnly)
152 {
153 }
154
155 Outer_Class(
156 const MI_ClassDecl* clDecl) :
157 Instance(clDecl)
158 {
159 }
160
161 Outer_Class& operator=(
162 const Outer_Class& x)
163 {
164 CopyRef(x);
165 return *this;
166 }
167
168 Outer_Class(
169 mike 1.1 const Outer_Class& x) :
170 Instance(x)
171 {
172 }
173
174 static const MI_ClassDecl* GetClassDecl()
175 {
176 return &Outer_rtti;
177 }
178
179 //
180 // Outer_Class.Key
181 //
182
183 const Field<Uint32>& Key() const
184 {
185 const size_t n = offsetof(Self, Key);
186 return GetField<Uint32>(n);
187 }
188
189 void Key(const Field<Uint32>& x)
190 mike 1.1 {
191 const size_t n = offsetof(Self, Key);
192 GetField<Uint32>(n) = x;
193 }
194
195 const Uint32& Key_value() const
196 {
197 const size_t n = offsetof(Self, Key);
198 return GetField<Uint32>(n).value;
199 }
200
201 void Key_value(const Uint32& x)
202 {
203 const size_t n = offsetof(Self, Key);
204 GetField<Uint32>(n).Set(x);
205 }
206
207 bool Key_exists() const
208 {
209 const size_t n = offsetof(Self, Key);
210 return GetField<Uint32>(n).exists ? true : false;
211 mike 1.1 }
212
213 void Key_clear()
214 {
215 const size_t n = offsetof(Self, Key);
216 GetField<Uint32>(n).Clear();
217 }
218
219 //
220 // Outer_Class.booleanScalar
221 //
222
223 const Field<Boolean>& booleanScalar() const
224 {
225 const size_t n = offsetof(Self, booleanScalar);
226 return GetField<Boolean>(n);
227 }
228
229 void booleanScalar(const Field<Boolean>& x)
230 {
231 const size_t n = offsetof(Self, booleanScalar);
232 mike 1.1 GetField<Boolean>(n) = x;
233 }
234
235 const Boolean& booleanScalar_value() const
236 {
237 const size_t n = offsetof(Self, booleanScalar);
238 return GetField<Boolean>(n).value;
239 }
240
241 void booleanScalar_value(const Boolean& x)
242 {
243 const size_t n = offsetof(Self, booleanScalar);
244 GetField<Boolean>(n).Set(x);
245 }
246
247 bool booleanScalar_exists() const
248 {
249 const size_t n = offsetof(Self, booleanScalar);
250 return GetField<Boolean>(n).exists ? true : false;
251 }
252
253 mike 1.1 void booleanScalar_clear()
254 {
255 const size_t n = offsetof(Self, booleanScalar);
256 GetField<Boolean>(n).Clear();
257 }
258
259 //
260 // Outer_Class.uint8Scalar
261 //
262
263 const Field<Uint8>& uint8Scalar() const
264 {
265 const size_t n = offsetof(Self, uint8Scalar);
266 return GetField<Uint8>(n);
267 }
268
269 void uint8Scalar(const Field<Uint8>& x)
270 {
271 const size_t n = offsetof(Self, uint8Scalar);
272 GetField<Uint8>(n) = x;
273 }
274 mike 1.1
275 const Uint8& uint8Scalar_value() const
276 {
277 const size_t n = offsetof(Self, uint8Scalar);
278 return GetField<Uint8>(n).value;
279 }
280
281 void uint8Scalar_value(const Uint8& x)
282 {
283 const size_t n = offsetof(Self, uint8Scalar);
284 GetField<Uint8>(n).Set(x);
285 }
286
287 bool uint8Scalar_exists() const
288 {
289 const size_t n = offsetof(Self, uint8Scalar);
290 return GetField<Uint8>(n).exists ? true : false;
291 }
292
293 void uint8Scalar_clear()
294 {
295 mike 1.1 const size_t n = offsetof(Self, uint8Scalar);
296 GetField<Uint8>(n).Clear();
297 }
298
299 //
300 // Outer_Class.sint8Scalar
301 //
302
303 const Field<Sint8>& sint8Scalar() const
304 {
305 const size_t n = offsetof(Self, sint8Scalar);
306 return GetField<Sint8>(n);
307 }
308
309 void sint8Scalar(const Field<Sint8>& x)
310 {
311 const size_t n = offsetof(Self, sint8Scalar);
312 GetField<Sint8>(n) = x;
313 }
314
315 const Sint8& sint8Scalar_value() const
316 mike 1.1 {
317 const size_t n = offsetof(Self, sint8Scalar);
318 return GetField<Sint8>(n).value;
319 }
320
321 void sint8Scalar_value(const Sint8& x)
322 {
323 const size_t n = offsetof(Self, sint8Scalar);
324 GetField<Sint8>(n).Set(x);
325 }
326
327 bool sint8Scalar_exists() const
328 {
329 const size_t n = offsetof(Self, sint8Scalar);
330 return GetField<Sint8>(n).exists ? true : false;
331 }
332
333 void sint8Scalar_clear()
334 {
335 const size_t n = offsetof(Self, sint8Scalar);
336 GetField<Sint8>(n).Clear();
337 mike 1.1 }
338
339 //
340 // Outer_Class.uint16Scalar
341 //
342
343 const Field<Uint16>& uint16Scalar() const
344 {
345 const size_t n = offsetof(Self, uint16Scalar);
346 return GetField<Uint16>(n);
347 }
348
349 void uint16Scalar(const Field<Uint16>& x)
350 {
351 const size_t n = offsetof(Self, uint16Scalar);
352 GetField<Uint16>(n) = x;
353 }
354
355 const Uint16& uint16Scalar_value() const
356 {
357 const size_t n = offsetof(Self, uint16Scalar);
358 mike 1.1 return GetField<Uint16>(n).value;
359 }
360
361 void uint16Scalar_value(const Uint16& x)
362 {
363 const size_t n = offsetof(Self, uint16Scalar);
364 GetField<Uint16>(n).Set(x);
365 }
366
367 bool uint16Scalar_exists() const
368 {
369 const size_t n = offsetof(Self, uint16Scalar);
370 return GetField<Uint16>(n).exists ? true : false;
371 }
372
373 void uint16Scalar_clear()
374 {
375 const size_t n = offsetof(Self, uint16Scalar);
376 GetField<Uint16>(n).Clear();
377 }
378
379 mike 1.1 //
380 // Outer_Class.sint16Scalar
381 //
382
383 const Field<Sint16>& sint16Scalar() const
384 {
385 const size_t n = offsetof(Self, sint16Scalar);
386 return GetField<Sint16>(n);
387 }
388
389 void sint16Scalar(const Field<Sint16>& x)
390 {
391 const size_t n = offsetof(Self, sint16Scalar);
392 GetField<Sint16>(n) = x;
393 }
394
395 const Sint16& sint16Scalar_value() const
396 {
397 const size_t n = offsetof(Self, sint16Scalar);
398 return GetField<Sint16>(n).value;
399 }
400 mike 1.1
401 void sint16Scalar_value(const Sint16& x)
402 {
403 const size_t n = offsetof(Self, sint16Scalar);
404 GetField<Sint16>(n).Set(x);
405 }
406
407 bool sint16Scalar_exists() const
408 {
409 const size_t n = offsetof(Self, sint16Scalar);
410 return GetField<Sint16>(n).exists ? true : false;
411 }
412
413 void sint16Scalar_clear()
414 {
415 const size_t n = offsetof(Self, sint16Scalar);
416 GetField<Sint16>(n).Clear();
417 }
418
419 //
420 // Outer_Class.uint32Scalar
421 mike 1.1 //
422
423 const Field<Uint32>& uint32Scalar() const
424 {
425 const size_t n = offsetof(Self, uint32Scalar);
426 return GetField<Uint32>(n);
427 }
428
429 void uint32Scalar(const Field<Uint32>& x)
430 {
431 const size_t n = offsetof(Self, uint32Scalar);
432 GetField<Uint32>(n) = x;
433 }
434
435 const Uint32& uint32Scalar_value() const
436 {
437 const size_t n = offsetof(Self, uint32Scalar);
438 return GetField<Uint32>(n).value;
439 }
440
441 void uint32Scalar_value(const Uint32& x)
442 mike 1.1 {
443 const size_t n = offsetof(Self, uint32Scalar);
444 GetField<Uint32>(n).Set(x);
445 }
446
447 bool uint32Scalar_exists() const
448 {
449 const size_t n = offsetof(Self, uint32Scalar);
450 return GetField<Uint32>(n).exists ? true : false;
451 }
452
453 void uint32Scalar_clear()
454 {
455 const size_t n = offsetof(Self, uint32Scalar);
456 GetField<Uint32>(n).Clear();
457 }
458
459 //
460 // Outer_Class.sint32Scalar
461 //
462
463 mike 1.1 const Field<Sint32>& sint32Scalar() const
464 {
465 const size_t n = offsetof(Self, sint32Scalar);
466 return GetField<Sint32>(n);
467 }
468
469 void sint32Scalar(const Field<Sint32>& x)
470 {
471 const size_t n = offsetof(Self, sint32Scalar);
472 GetField<Sint32>(n) = x;
473 }
474
475 const Sint32& sint32Scalar_value() const
476 {
477 const size_t n = offsetof(Self, sint32Scalar);
478 return GetField<Sint32>(n).value;
479 }
480
481 void sint32Scalar_value(const Sint32& x)
482 {
483 const size_t n = offsetof(Self, sint32Scalar);
484 mike 1.1 GetField<Sint32>(n).Set(x);
485 }
486
487 bool sint32Scalar_exists() const
488 {
489 const size_t n = offsetof(Self, sint32Scalar);
490 return GetField<Sint32>(n).exists ? true : false;
491 }
492
493 void sint32Scalar_clear()
494 {
495 const size_t n = offsetof(Self, sint32Scalar);
496 GetField<Sint32>(n).Clear();
497 }
498
499 //
500 // Outer_Class.uint64Scalar
501 //
502
503 const Field<Uint64>& uint64Scalar() const
504 {
505 mike 1.1 const size_t n = offsetof(Self, uint64Scalar);
506 return GetField<Uint64>(n);
507 }
508
509 void uint64Scalar(const Field<Uint64>& x)
510 {
511 const size_t n = offsetof(Self, uint64Scalar);
512 GetField<Uint64>(n) = x;
513 }
514
515 const Uint64& uint64Scalar_value() const
516 {
517 const size_t n = offsetof(Self, uint64Scalar);
518 return GetField<Uint64>(n).value;
519 }
520
521 void uint64Scalar_value(const Uint64& x)
522 {
523 const size_t n = offsetof(Self, uint64Scalar);
524 GetField<Uint64>(n).Set(x);
525 }
526 mike 1.1
527 bool uint64Scalar_exists() const
528 {
529 const size_t n = offsetof(Self, uint64Scalar);
530 return GetField<Uint64>(n).exists ? true : false;
531 }
532
533 void uint64Scalar_clear()
534 {
535 const size_t n = offsetof(Self, uint64Scalar);
536 GetField<Uint64>(n).Clear();
537 }
538
539 //
540 // Outer_Class.sint64Scalar
541 //
542
543 const Field<Sint64>& sint64Scalar() const
544 {
545 const size_t n = offsetof(Self, sint64Scalar);
546 return GetField<Sint64>(n);
547 mike 1.1 }
548
549 void sint64Scalar(const Field<Sint64>& x)
550 {
551 const size_t n = offsetof(Self, sint64Scalar);
552 GetField<Sint64>(n) = x;
553 }
554
555 const Sint64& sint64Scalar_value() const
556 {
557 const size_t n = offsetof(Self, sint64Scalar);
558 return GetField<Sint64>(n).value;
559 }
560
561 void sint64Scalar_value(const Sint64& x)
562 {
563 const size_t n = offsetof(Self, sint64Scalar);
564 GetField<Sint64>(n).Set(x);
565 }
566
567 bool sint64Scalar_exists() const
568 mike 1.1 {
569 const size_t n = offsetof(Self, sint64Scalar);
570 return GetField<Sint64>(n).exists ? true : false;
571 }
572
573 void sint64Scalar_clear()
574 {
575 const size_t n = offsetof(Self, sint64Scalar);
576 GetField<Sint64>(n).Clear();
577 }
578
579 //
580 // Outer_Class.real32Scalar
581 //
582
583 const Field<Real32>& real32Scalar() const
584 {
585 const size_t n = offsetof(Self, real32Scalar);
586 return GetField<Real32>(n);
587 }
588
589 mike 1.1 void real32Scalar(const Field<Real32>& x)
590 {
591 const size_t n = offsetof(Self, real32Scalar);
592 GetField<Real32>(n) = x;
593 }
594
595 const Real32& real32Scalar_value() const
596 {
597 const size_t n = offsetof(Self, real32Scalar);
598 return GetField<Real32>(n).value;
599 }
600
601 void real32Scalar_value(const Real32& x)
602 {
603 const size_t n = offsetof(Self, real32Scalar);
604 GetField<Real32>(n).Set(x);
605 }
606
607 bool real32Scalar_exists() const
608 {
609 const size_t n = offsetof(Self, real32Scalar);
610 mike 1.1 return GetField<Real32>(n).exists ? true : false;
611 }
612
613 void real32Scalar_clear()
614 {
615 const size_t n = offsetof(Self, real32Scalar);
616 GetField<Real32>(n).Clear();
617 }
618
619 //
620 // Outer_Class.real64Scalar
621 //
622
623 const Field<Real64>& real64Scalar() const
624 {
625 const size_t n = offsetof(Self, real64Scalar);
626 return GetField<Real64>(n);
627 }
628
629 void real64Scalar(const Field<Real64>& x)
630 {
631 mike 1.1 const size_t n = offsetof(Self, real64Scalar);
632 GetField<Real64>(n) = x;
633 }
634
635 const Real64& real64Scalar_value() const
636 {
637 const size_t n = offsetof(Self, real64Scalar);
638 return GetField<Real64>(n).value;
639 }
640
641 void real64Scalar_value(const Real64& x)
642 {
643 const size_t n = offsetof(Self, real64Scalar);
644 GetField<Real64>(n).Set(x);
645 }
646
647 bool real64Scalar_exists() const
648 {
649 const size_t n = offsetof(Self, real64Scalar);
650 return GetField<Real64>(n).exists ? true : false;
651 }
652 mike 1.1
653 void real64Scalar_clear()
654 {
655 const size_t n = offsetof(Self, real64Scalar);
656 GetField<Real64>(n).Clear();
657 }
658
659 //
660 // Outer_Class.char16Scalar
661 //
662
663 const Field<Char16>& char16Scalar() const
664 {
665 const size_t n = offsetof(Self, char16Scalar);
666 return GetField<Char16>(n);
667 }
668
669 void char16Scalar(const Field<Char16>& x)
670 {
671 const size_t n = offsetof(Self, char16Scalar);
672 GetField<Char16>(n) = x;
673 mike 1.1 }
674
675 const Char16& char16Scalar_value() const
676 {
677 const size_t n = offsetof(Self, char16Scalar);
678 return GetField<Char16>(n).value;
679 }
680
681 void char16Scalar_value(const Char16& x)
682 {
683 const size_t n = offsetof(Self, char16Scalar);
684 GetField<Char16>(n).Set(x);
685 }
686
687 bool char16Scalar_exists() const
688 {
689 const size_t n = offsetof(Self, char16Scalar);
690 return GetField<Char16>(n).exists ? true : false;
691 }
692
693 void char16Scalar_clear()
694 mike 1.1 {
695 const size_t n = offsetof(Self, char16Scalar);
696 GetField<Char16>(n).Clear();
697 }
698
699 //
700 // Outer_Class.datetimeScalar
701 //
702
703 const Field<Datetime>& datetimeScalar() const
704 {
705 const size_t n = offsetof(Self, datetimeScalar);
706 return GetField<Datetime>(n);
707 }
708
709 void datetimeScalar(const Field<Datetime>& x)
710 {
711 const size_t n = offsetof(Self, datetimeScalar);
712 GetField<Datetime>(n) = x;
713 }
714
715 mike 1.1 const Datetime& datetimeScalar_value() const
716 {
717 const size_t n = offsetof(Self, datetimeScalar);
718 return GetField<Datetime>(n).value;
719 }
720
721 void datetimeScalar_value(const Datetime& x)
722 {
723 const size_t n = offsetof(Self, datetimeScalar);
724 GetField<Datetime>(n).Set(x);
725 }
726
727 bool datetimeScalar_exists() const
728 {
729 const size_t n = offsetof(Self, datetimeScalar);
730 return GetField<Datetime>(n).exists ? true : false;
731 }
732
733 void datetimeScalar_clear()
734 {
735 const size_t n = offsetof(Self, datetimeScalar);
736 mike 1.1 GetField<Datetime>(n).Clear();
737 }
738
739 //
740 // Outer_Class.stringScalar
741 //
742
743 const Field<String>& stringScalar() const
744 {
745 const size_t n = offsetof(Self, stringScalar);
746 return GetField<String>(n);
747 }
748
749 void stringScalar(const Field<String>& x)
750 {
751 const size_t n = offsetof(Self, stringScalar);
752 GetField<String>(n) = x;
753 }
754
755 const String& stringScalar_value() const
756 {
757 mike 1.1 const size_t n = offsetof(Self, stringScalar);
758 return GetField<String>(n).value;
759 }
760
761 void stringScalar_value(const String& x)
762 {
763 const size_t n = offsetof(Self, stringScalar);
764 GetField<String>(n).Set(x);
765 }
766
767 bool stringScalar_exists() const
768 {
769 const size_t n = offsetof(Self, stringScalar);
770 return GetField<String>(n).exists ? true : false;
771 }
772
773 void stringScalar_clear()
774 {
775 const size_t n = offsetof(Self, stringScalar);
776 GetField<String>(n).Clear();
777 }
778 mike 1.1
779 //
780 // Outer_Class.instanceScalar
781 //
782
783 const Field<Inner_Class>& instanceScalar() const
784 {
785 const size_t n = offsetof(Self, instanceScalar);
786 return GetField<Inner_Class>(n);
787 }
788
789 void instanceScalar(const Field<Inner_Class>& x)
790 {
791 const size_t n = offsetof(Self, instanceScalar);
792 GetField<Inner_Class>(n) = x;
793 }
794
795 const Inner_Class& instanceScalar_value() const
796 {
797 const size_t n = offsetof(Self, instanceScalar);
798 return GetField<Inner_Class>(n).value;
799 mike 1.1 }
800
801 void instanceScalar_value(const Inner_Class& x)
802 {
803 const size_t n = offsetof(Self, instanceScalar);
804 GetField<Inner_Class>(n).Set(x);
805 }
806
807 bool instanceScalar_exists() const
808 {
809 const size_t n = offsetof(Self, instanceScalar);
810 return GetField<Inner_Class>(n).exists ? true : false;
811 }
812
813 void instanceScalar_clear()
814 {
815 const size_t n = offsetof(Self, instanceScalar);
816 GetField<Inner_Class>(n).Clear();
817 }
818
819 //
820 mike 1.1 // Outer_Class.booleanArray
821 //
822
823 const Field<BooleanA>& booleanArray() const
824 {
825 const size_t n = offsetof(Self, booleanArray);
826 return GetField<BooleanA>(n);
827 }
828
829 void booleanArray(const Field<BooleanA>& x)
830 {
831 const size_t n = offsetof(Self, booleanArray);
832 GetField<BooleanA>(n) = x;
833 }
834
835 const BooleanA& booleanArray_value() const
836 {
837 const size_t n = offsetof(Self, booleanArray);
838 return GetField<BooleanA>(n).value;
839 }
840
841 mike 1.1 void booleanArray_value(const BooleanA& x)
842 {
843 const size_t n = offsetof(Self, booleanArray);
844 GetField<BooleanA>(n).Set(x);
845 }
846
847 bool booleanArray_exists() const
848 {
849 const size_t n = offsetof(Self, booleanArray);
850 return GetField<BooleanA>(n).exists ? true : false;
851 }
852
853 void booleanArray_clear()
854 {
855 const size_t n = offsetof(Self, booleanArray);
856 GetField<BooleanA>(n).Clear();
857 }
858
859 //
860 // Outer_Class.uint8Array
861 //
862 mike 1.1
863 const Field<Uint8A>& uint8Array() const
864 {
865 const size_t n = offsetof(Self, uint8Array);
866 return GetField<Uint8A>(n);
867 }
868
869 void uint8Array(const Field<Uint8A>& x)
870 {
871 const size_t n = offsetof(Self, uint8Array);
872 GetField<Uint8A>(n) = x;
873 }
874
875 const Uint8A& uint8Array_value() const
876 {
877 const size_t n = offsetof(Self, uint8Array);
878 return GetField<Uint8A>(n).value;
879 }
880
881 void uint8Array_value(const Uint8A& x)
882 {
883 mike 1.1 const size_t n = offsetof(Self, uint8Array);
884 GetField<Uint8A>(n).Set(x);
885 }
886
887 bool uint8Array_exists() const
888 {
889 const size_t n = offsetof(Self, uint8Array);
890 return GetField<Uint8A>(n).exists ? true : false;
891 }
892
893 void uint8Array_clear()
894 {
895 const size_t n = offsetof(Self, uint8Array);
896 GetField<Uint8A>(n).Clear();
897 }
898
899 //
900 // Outer_Class.sint8Array
901 //
902
903 const Field<Sint8A>& sint8Array() const
904 mike 1.1 {
905 const size_t n = offsetof(Self, sint8Array);
906 return GetField<Sint8A>(n);
907 }
908
909 void sint8Array(const Field<Sint8A>& x)
910 {
911 const size_t n = offsetof(Self, sint8Array);
912 GetField<Sint8A>(n) = x;
913 }
914
915 const Sint8A& sint8Array_value() const
916 {
917 const size_t n = offsetof(Self, sint8Array);
918 return GetField<Sint8A>(n).value;
919 }
920
921 void sint8Array_value(const Sint8A& x)
922 {
923 const size_t n = offsetof(Self, sint8Array);
924 GetField<Sint8A>(n).Set(x);
925 mike 1.1 }
926
927 bool sint8Array_exists() const
928 {
929 const size_t n = offsetof(Self, sint8Array);
930 return GetField<Sint8A>(n).exists ? true : false;
931 }
932
933 void sint8Array_clear()
934 {
935 const size_t n = offsetof(Self, sint8Array);
936 GetField<Sint8A>(n).Clear();
937 }
938
939 //
940 // Outer_Class.uint16Array
941 //
942
943 const Field<Uint16A>& uint16Array() const
944 {
945 const size_t n = offsetof(Self, uint16Array);
946 mike 1.1 return GetField<Uint16A>(n);
947 }
948
949 void uint16Array(const Field<Uint16A>& x)
950 {
951 const size_t n = offsetof(Self, uint16Array);
952 GetField<Uint16A>(n) = x;
953 }
954
955 const Uint16A& uint16Array_value() const
956 {
957 const size_t n = offsetof(Self, uint16Array);
958 return GetField<Uint16A>(n).value;
959 }
960
961 void uint16Array_value(const Uint16A& x)
962 {
963 const size_t n = offsetof(Self, uint16Array);
964 GetField<Uint16A>(n).Set(x);
965 }
966
967 mike 1.1 bool uint16Array_exists() const
968 {
969 const size_t n = offsetof(Self, uint16Array);
970 return GetField<Uint16A>(n).exists ? true : false;
971 }
972
973 void uint16Array_clear()
974 {
975 const size_t n = offsetof(Self, uint16Array);
976 GetField<Uint16A>(n).Clear();
977 }
978
979 //
980 // Outer_Class.sint16Array
981 //
982
983 const Field<Sint16A>& sint16Array() const
984 {
985 const size_t n = offsetof(Self, sint16Array);
986 return GetField<Sint16A>(n);
987 }
988 mike 1.1
989 void sint16Array(const Field<Sint16A>& x)
990 {
991 const size_t n = offsetof(Self, sint16Array);
992 GetField<Sint16A>(n) = x;
993 }
994
995 const Sint16A& sint16Array_value() const
996 {
997 const size_t n = offsetof(Self, sint16Array);
998 return GetField<Sint16A>(n).value;
999 }
1000
1001 void sint16Array_value(const Sint16A& x)
1002 {
1003 const size_t n = offsetof(Self, sint16Array);
1004 GetField<Sint16A>(n).Set(x);
1005 }
1006
1007 bool sint16Array_exists() const
1008 {
1009 mike 1.1 const size_t n = offsetof(Self, sint16Array);
1010 return GetField<Sint16A>(n).exists ? true : false;
1011 }
1012
1013 void sint16Array_clear()
1014 {
1015 const size_t n = offsetof(Self, sint16Array);
1016 GetField<Sint16A>(n).Clear();
1017 }
1018
1019 //
1020 // Outer_Class.uint32Array
1021 //
1022
1023 const Field<Uint32A>& uint32Array() const
1024 {
1025 const size_t n = offsetof(Self, uint32Array);
1026 return GetField<Uint32A>(n);
1027 }
1028
1029 void uint32Array(const Field<Uint32A>& x)
1030 mike 1.1 {
1031 const size_t n = offsetof(Self, uint32Array);
1032 GetField<Uint32A>(n) = x;
1033 }
1034
1035 const Uint32A& uint32Array_value() const
1036 {
1037 const size_t n = offsetof(Self, uint32Array);
1038 return GetField<Uint32A>(n).value;
1039 }
1040
1041 void uint32Array_value(const Uint32A& x)
1042 {
1043 const size_t n = offsetof(Self, uint32Array);
1044 GetField<Uint32A>(n).Set(x);
1045 }
1046
1047 bool uint32Array_exists() const
1048 {
1049 const size_t n = offsetof(Self, uint32Array);
1050 return GetField<Uint32A>(n).exists ? true : false;
1051 mike 1.1 }
1052
1053 void uint32Array_clear()
1054 {
1055 const size_t n = offsetof(Self, uint32Array);
1056 GetField<Uint32A>(n).Clear();
1057 }
1058
1059 //
1060 // Outer_Class.sint32Array
1061 //
1062
1063 const Field<Sint32A>& sint32Array() const
1064 {
1065 const size_t n = offsetof(Self, sint32Array);
1066 return GetField<Sint32A>(n);
1067 }
1068
1069 void sint32Array(const Field<Sint32A>& x)
1070 {
1071 const size_t n = offsetof(Self, sint32Array);
1072 mike 1.1 GetField<Sint32A>(n) = x;
1073 }
1074
1075 const Sint32A& sint32Array_value() const
1076 {
1077 const size_t n = offsetof(Self, sint32Array);
1078 return GetField<Sint32A>(n).value;
1079 }
1080
1081 void sint32Array_value(const Sint32A& x)
1082 {
1083 const size_t n = offsetof(Self, sint32Array);
1084 GetField<Sint32A>(n).Set(x);
1085 }
1086
1087 bool sint32Array_exists() const
1088 {
1089 const size_t n = offsetof(Self, sint32Array);
1090 return GetField<Sint32A>(n).exists ? true : false;
1091 }
1092
1093 mike 1.1 void sint32Array_clear()
1094 {
1095 const size_t n = offsetof(Self, sint32Array);
1096 GetField<Sint32A>(n).Clear();
1097 }
1098
1099 //
1100 // Outer_Class.uint64Array
1101 //
1102
1103 const Field<Uint64A>& uint64Array() const
1104 {
1105 const size_t n = offsetof(Self, uint64Array);
1106 return GetField<Uint64A>(n);
1107 }
1108
1109 void uint64Array(const Field<Uint64A>& x)
1110 {
1111 const size_t n = offsetof(Self, uint64Array);
1112 GetField<Uint64A>(n) = x;
1113 }
1114 mike 1.1
1115 const Uint64A& uint64Array_value() const
1116 {
1117 const size_t n = offsetof(Self, uint64Array);
1118 return GetField<Uint64A>(n).value;
1119 }
1120
1121 void uint64Array_value(const Uint64A& x)
1122 {
1123 const size_t n = offsetof(Self, uint64Array);
1124 GetField<Uint64A>(n).Set(x);
1125 }
1126
1127 bool uint64Array_exists() const
1128 {
1129 const size_t n = offsetof(Self, uint64Array);
1130 return GetField<Uint64A>(n).exists ? true : false;
1131 }
1132
1133 void uint64Array_clear()
1134 {
1135 mike 1.1 const size_t n = offsetof(Self, uint64Array);
1136 GetField<Uint64A>(n).Clear();
1137 }
1138
1139 //
1140 // Outer_Class.sint64Array
1141 //
1142
1143 const Field<Sint64A>& sint64Array() const
1144 {
1145 const size_t n = offsetof(Self, sint64Array);
1146 return GetField<Sint64A>(n);
1147 }
1148
1149 void sint64Array(const Field<Sint64A>& x)
1150 {
1151 const size_t n = offsetof(Self, sint64Array);
1152 GetField<Sint64A>(n) = x;
1153 }
1154
1155 const Sint64A& sint64Array_value() const
1156 mike 1.1 {
1157 const size_t n = offsetof(Self, sint64Array);
1158 return GetField<Sint64A>(n).value;
1159 }
1160
1161 void sint64Array_value(const Sint64A& x)
1162 {
1163 const size_t n = offsetof(Self, sint64Array);
1164 GetField<Sint64A>(n).Set(x);
1165 }
1166
1167 bool sint64Array_exists() const
1168 {
1169 const size_t n = offsetof(Self, sint64Array);
1170 return GetField<Sint64A>(n).exists ? true : false;
1171 }
1172
1173 void sint64Array_clear()
1174 {
1175 const size_t n = offsetof(Self, sint64Array);
1176 GetField<Sint64A>(n).Clear();
1177 mike 1.1 }
1178
1179 //
1180 // Outer_Class.real32Array
1181 //
1182
1183 const Field<Real32A>& real32Array() const
1184 {
1185 const size_t n = offsetof(Self, real32Array);
1186 return GetField<Real32A>(n);
1187 }
1188
1189 void real32Array(const Field<Real32A>& x)
1190 {
1191 const size_t n = offsetof(Self, real32Array);
1192 GetField<Real32A>(n) = x;
1193 }
1194
1195 const Real32A& real32Array_value() const
1196 {
1197 const size_t n = offsetof(Self, real32Array);
1198 mike 1.1 return GetField<Real32A>(n).value;
1199 }
1200
1201 void real32Array_value(const Real32A& x)
1202 {
1203 const size_t n = offsetof(Self, real32Array);
1204 GetField<Real32A>(n).Set(x);
1205 }
1206
1207 bool real32Array_exists() const
1208 {
1209 const size_t n = offsetof(Self, real32Array);
1210 return GetField<Real32A>(n).exists ? true : false;
1211 }
1212
1213 void real32Array_clear()
1214 {
1215 const size_t n = offsetof(Self, real32Array);
1216 GetField<Real32A>(n).Clear();
1217 }
1218
1219 mike 1.1 //
1220 // Outer_Class.real64Array
1221 //
1222
1223 const Field<Real64A>& real64Array() const
1224 {
1225 const size_t n = offsetof(Self, real64Array);
1226 return GetField<Real64A>(n);
1227 }
1228
1229 void real64Array(const Field<Real64A>& x)
1230 {
1231 const size_t n = offsetof(Self, real64Array);
1232 GetField<Real64A>(n) = x;
1233 }
1234
1235 const Real64A& real64Array_value() const
1236 {
1237 const size_t n = offsetof(Self, real64Array);
1238 return GetField<Real64A>(n).value;
1239 }
1240 mike 1.1
1241 void real64Array_value(const Real64A& x)
1242 {
1243 const size_t n = offsetof(Self, real64Array);
1244 GetField<Real64A>(n).Set(x);
1245 }
1246
1247 bool real64Array_exists() const
1248 {
1249 const size_t n = offsetof(Self, real64Array);
1250 return GetField<Real64A>(n).exists ? true : false;
1251 }
1252
1253 void real64Array_clear()
1254 {
1255 const size_t n = offsetof(Self, real64Array);
1256 GetField<Real64A>(n).Clear();
1257 }
1258
1259 //
1260 // Outer_Class.char16Array
1261 mike 1.1 //
1262
1263 const Field<Char16A>& char16Array() const
1264 {
1265 const size_t n = offsetof(Self, char16Array);
1266 return GetField<Char16A>(n);
1267 }
1268
1269 void char16Array(const Field<Char16A>& x)
1270 {
1271 const size_t n = offsetof(Self, char16Array);
1272 GetField<Char16A>(n) = x;
1273 }
1274
1275 const Char16A& char16Array_value() const
1276 {
1277 const size_t n = offsetof(Self, char16Array);
1278 return GetField<Char16A>(n).value;
1279 }
1280
1281 void char16Array_value(const Char16A& x)
1282 mike 1.1 {
1283 const size_t n = offsetof(Self, char16Array);
1284 GetField<Char16A>(n).Set(x);
1285 }
1286
1287 bool char16Array_exists() const
1288 {
1289 const size_t n = offsetof(Self, char16Array);
1290 return GetField<Char16A>(n).exists ? true : false;
1291 }
1292
1293 void char16Array_clear()
1294 {
1295 const size_t n = offsetof(Self, char16Array);
1296 GetField<Char16A>(n).Clear();
1297 }
1298
1299 //
1300 // Outer_Class.datetimeArray
1301 //
1302
1303 mike 1.1 const Field<DatetimeA>& datetimeArray() const
1304 {
1305 const size_t n = offsetof(Self, datetimeArray);
1306 return GetField<DatetimeA>(n);
1307 }
1308
1309 void datetimeArray(const Field<DatetimeA>& x)
1310 {
1311 const size_t n = offsetof(Self, datetimeArray);
1312 GetField<DatetimeA>(n) = x;
1313 }
1314
1315 const DatetimeA& datetimeArray_value() const
1316 {
1317 const size_t n = offsetof(Self, datetimeArray);
1318 return GetField<DatetimeA>(n).value;
1319 }
1320
1321 void datetimeArray_value(const DatetimeA& x)
1322 {
1323 const size_t n = offsetof(Self, datetimeArray);
1324 mike 1.1 GetField<DatetimeA>(n).Set(x);
1325 }
1326
1327 bool datetimeArray_exists() const
1328 {
1329 const size_t n = offsetof(Self, datetimeArray);
1330 return GetField<DatetimeA>(n).exists ? true : false;
1331 }
1332
1333 void datetimeArray_clear()
1334 {
1335 const size_t n = offsetof(Self, datetimeArray);
1336 GetField<DatetimeA>(n).Clear();
1337 }
1338
1339 //
1340 // Outer_Class.stringArray
1341 //
1342
1343 const Field<StringA>& stringArray() const
1344 {
1345 mike 1.1 const size_t n = offsetof(Self, stringArray);
1346 return GetField<StringA>(n);
1347 }
1348
1349 void stringArray(const Field<StringA>& x)
1350 {
1351 const size_t n = offsetof(Self, stringArray);
1352 GetField<StringA>(n) = x;
1353 }
1354
1355 const StringA& stringArray_value() const
1356 {
1357 const size_t n = offsetof(Self, stringArray);
1358 return GetField<StringA>(n).value;
1359 }
1360
1361 void stringArray_value(const StringA& x)
1362 {
1363 const size_t n = offsetof(Self, stringArray);
1364 GetField<StringA>(n).Set(x);
1365 }
1366 mike 1.1
1367 bool stringArray_exists() const
1368 {
1369 const size_t n = offsetof(Self, stringArray);
1370 return GetField<StringA>(n).exists ? true : false;
1371 }
1372
1373 void stringArray_clear()
1374 {
1375 const size_t n = offsetof(Self, stringArray);
1376 GetField<StringA>(n).Clear();
1377 }
1378
1379 //
1380 // Outer_Class.instanceArray
1381 //
1382
1383 const Field<Inner_ClassA>& instanceArray() const
1384 {
1385 const size_t n = offsetof(Self, instanceArray);
1386 return GetField<Inner_ClassA>(n);
1387 mike 1.1 }
1388
1389 void instanceArray(const Field<Inner_ClassA>& x)
1390 {
1391 const size_t n = offsetof(Self, instanceArray);
1392 GetField<Inner_ClassA>(n) = x;
1393 }
1394
1395 const Inner_ClassA& instanceArray_value() const
1396 {
1397 const size_t n = offsetof(Self, instanceArray);
1398 return GetField<Inner_ClassA>(n).value;
1399 }
1400
1401 void instanceArray_value(const Inner_ClassA& x)
1402 {
1403 const size_t n = offsetof(Self, instanceArray);
1404 GetField<Inner_ClassA>(n).Set(x);
1405 }
1406
1407 bool instanceArray_exists() const
1408 mike 1.1 {
1409 const size_t n = offsetof(Self, instanceArray);
1410 return GetField<Inner_ClassA>(n).exists ? true : false;
1411 }
1412
1413 void instanceArray_clear()
1414 {
1415 const size_t n = offsetof(Self, instanceArray);
1416 GetField<Inner_ClassA>(n).Clear();
1417 }
1418 };
1419
1420 typedef Array<Outer_Class> Outer_ClassA;
1421
1422 MI_END_NAMESPACE
1423
1424 #endif /* __cplusplus */
1425
1426 #endif /* _Outer_h */
|