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 */