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