iOS/Pods/FirebaseMessaging/Firebase/Messaging/Protos/GtalkExtensions.pbobjc.m

   1 /*
   2  * Copyright 2017 Google
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // Generated by the protocol buffer compiler.  DO NOT EDIT!
  18 // source: buzz/mobile/proto/gtalk_extensions.proto
  19
  20 // This CPP symbol can be defined to use imports that match up to the framework
  21 // imports needed when using CocoaPods.
  22 #if !defined(GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS)
  23  #define GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 0
  24 #endif
  25
  26 #if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS
  27  #import <Protobuf/GPBProtocolBuffers_RuntimeSupport.h>
  28 #else
  29  #import "GPBProtocolBuffers_RuntimeSupport.h"
  30 #endif
  31
  32  #import "GtalkExtensions.pbobjc.h"
  33 // @@protoc_insertion_point(imports)
  34
  35 #pragma clang diagnostic push
  36 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
  37
  38 #pragma mark - GtalkGtalkExtensionsRoot
  39
  40 @implementation GtalkGtalkExtensionsRoot
  41
  42 // No extensions in the file and no imports, so no need to generate
  43 // +extensionRegistry.
  44
  45 @end
  46
  47 #pragma mark - GtalkGtalkExtensionsRoot_FileDescriptor
  48
  49 static GPBFileDescriptor *GtalkGtalkExtensionsRoot_FileDescriptor(void) {
  50   // This is called by +initialize so there is no need to worry
  51   // about thread safety of the singleton.
  52   static GPBFileDescriptor *descriptor = NULL;
  53   if (!descriptor) {
  54     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
  55     descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"mobilegtalk"
  56                                                  objcPrefix:@"Gtalk"
  57                                                      syntax:GPBFileSyntaxProto2];
  58   }
  59   return descriptor;
  60 }
  61
  62 #pragma mark - GtalkRosterQuery
  63
  64 @implementation GtalkRosterQuery
  65
  66 @dynamic hasEtag, etag;
  67 @dynamic hasNotModified, notModified;
  68 @dynamic itemArray, itemArray_Count;
  69 @dynamic hasAvatarWidth, avatarWidth;
  70 @dynamic hasAvatarHeight, avatarHeight;
  71
  72 typedef struct GtalkRosterQuery__storage_ {
  73   uint32_t _has_storage_[1];
  74   int32_t avatarWidth;
  75   int32_t avatarHeight;
  76   NSString *etag;
  77   NSMutableArray *itemArray;
  78 } GtalkRosterQuery__storage_;
  79
  80 // This method is threadsafe because it is initially called
  81 // in +initialize for each subclass.
  82 + (GPBDescriptor *)descriptor {
  83   static GPBDescriptor *descriptor = nil;
  84   if (!descriptor) {
  85     static GPBMessageFieldDescription fields[] = {
  86       {
  87         .name = "etag",
  88         .dataTypeSpecific.className = NULL,
  89         .number = GtalkRosterQuery_FieldNumber_Etag,
  90         .hasIndex = 0,
  91         .offset = (uint32_t)offsetof(GtalkRosterQuery__storage_, etag),
  92         .flags = GPBFieldOptional,
  93         .dataType = GPBDataTypeString,
  94       },
  95       {
  96         .name = "notModified",
  97         .dataTypeSpecific.className = NULL,
  98         .number = GtalkRosterQuery_FieldNumber_NotModified,
  99         .hasIndex = 1,
 100         .offset = 2,  // Stored in _has_storage_ to save space.
 101         .flags = GPBFieldOptional,
 102         .dataType = GPBDataTypeBool,
 103       },
 104       {
 105         .name = "itemArray",
 106         .dataTypeSpecific.className = GPBStringifySymbol(GtalkRosterItem),
 107         .number = GtalkRosterQuery_FieldNumber_ItemArray,
 108         .hasIndex = GPBNoHasBit,
 109         .offset = (uint32_t)offsetof(GtalkRosterQuery__storage_, itemArray),
 110         .flags = GPBFieldRepeated,
 111         .dataType = GPBDataTypeMessage,
 112       },
 113       {
 114         .name = "avatarWidth",
 115         .dataTypeSpecific.className = NULL,
 116         .number = GtalkRosterQuery_FieldNumber_AvatarWidth,
 117         .hasIndex = 3,
 118         .offset = (uint32_t)offsetof(GtalkRosterQuery__storage_, avatarWidth),
 119         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
 120         .dataType = GPBDataTypeInt32,
 121       },
 122       {
 123         .name = "avatarHeight",
 124         .dataTypeSpecific.className = NULL,
 125         .number = GtalkRosterQuery_FieldNumber_AvatarHeight,
 126         .hasIndex = 4,
 127         .offset = (uint32_t)offsetof(GtalkRosterQuery__storage_, avatarHeight),
 128         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
 129         .dataType = GPBDataTypeInt32,
 130       },
 131     };
 132     GPBDescriptor *localDescriptor =
 133         [GPBDescriptor allocDescriptorForClass:[GtalkRosterQuery class]
 134                                      rootClass:[GtalkGtalkExtensionsRoot class]
 135                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 136                                         fields:fields
 137                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 138                                    storageSize:sizeof(GtalkRosterQuery__storage_)
 139                                          flags:GPBDescriptorInitializationFlag_None];
 140 #if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
 141     static const char *extraTextFormatInfo =
 142         "\002\004\013\000\005\014\000";
 143     [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
 144 #endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
 145     NSAssert(descriptor == nil, @"Startup recursed!");
 146     descriptor = localDescriptor;
 147   }
 148   return descriptor;
 149 }
 150
 151 @end
 152
 153 #pragma mark - GtalkRosterItem
 154
 155 @implementation GtalkRosterItem
 156
 157 @dynamic hasJid, jid;
 158 @dynamic hasName, name;
 159 @dynamic hasSubscription, subscription;
 160 @dynamic hasAsk, ask;
 161 @dynamic groupArray, groupArray_Count;
 162 @dynamic hasQuickContact, quickContact;
 163 @dynamic hasDisplay, display;
 164 @dynamic hasRejected, rejected;
 165
 166 typedef struct GtalkRosterItem__storage_ {
 167   uint32_t _has_storage_[1];
 168   GtalkRosterItem_SubscriptionType subscription;
 169   GtalkRosterItem_AskType ask;
 170   GtalkRosterItem_DisplayType display;
 171   NSString *jid;
 172   NSString *name;
 173   NSMutableArray *groupArray;
 174 } GtalkRosterItem__storage_;
 175
 176 // This method is threadsafe because it is initially called
 177 // in +initialize for each subclass.
 178 + (GPBDescriptor *)descriptor {
 179   static GPBDescriptor *descriptor = nil;
 180   if (!descriptor) {
 181     static GPBMessageFieldDescription fields[] = {
 182       {
 183         .name = "jid",
 184         .dataTypeSpecific.className = NULL,
 185         .number = GtalkRosterItem_FieldNumber_Jid,
 186         .hasIndex = 0,
 187         .offset = (uint32_t)offsetof(GtalkRosterItem__storage_, jid),
 188         .flags = GPBFieldRequired,
 189         .dataType = GPBDataTypeString,
 190       },
 191       {
 192         .name = "name",
 193         .dataTypeSpecific.className = NULL,
 194         .number = GtalkRosterItem_FieldNumber_Name,
 195         .hasIndex = 1,
 196         .offset = (uint32_t)offsetof(GtalkRosterItem__storage_, name),
 197         .flags = GPBFieldOptional,
 198         .dataType = GPBDataTypeString,
 199       },
 200       {
 201         .name = "subscription",
 202         .dataTypeSpecific.enumDescFunc = GtalkRosterItem_SubscriptionType_EnumDescriptor,
 203         .number = GtalkRosterItem_FieldNumber_Subscription,
 204         .hasIndex = 2,
 205         .offset = (uint32_t)offsetof(GtalkRosterItem__storage_, subscription),
 206         .flags = (GPBFieldFlags)(GPBFieldRequired | GPBFieldHasEnumDescriptor),
 207         .dataType = GPBDataTypeEnum,
 208       },
 209       {
 210         .name = "ask",
 211         .dataTypeSpecific.enumDescFunc = GtalkRosterItem_AskType_EnumDescriptor,
 212         .number = GtalkRosterItem_FieldNumber_Ask,
 213         .hasIndex = 3,
 214         .offset = (uint32_t)offsetof(GtalkRosterItem__storage_, ask),
 215         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
 216         .dataType = GPBDataTypeEnum,
 217       },
 218       {
 219         .name = "groupArray",
 220         .dataTypeSpecific.className = NULL,
 221         .number = GtalkRosterItem_FieldNumber_GroupArray,
 222         .hasIndex = GPBNoHasBit,
 223         .offset = (uint32_t)offsetof(GtalkRosterItem__storage_, groupArray),
 224         .flags = GPBFieldRepeated,
 225         .dataType = GPBDataTypeString,
 226       },
 227       {
 228         .name = "quickContact",
 229         .dataTypeSpecific.className = NULL,
 230         .number = GtalkRosterItem_FieldNumber_QuickContact,
 231         .hasIndex = 4,
 232         .offset = 5,  // Stored in _has_storage_ to save space.
 233         .flags = GPBFieldOptional,
 234         .dataType = GPBDataTypeBool,
 235       },
 236       {
 237         .name = "display",
 238         .dataTypeSpecific.enumDescFunc = GtalkRosterItem_DisplayType_EnumDescriptor,
 239         .number = GtalkRosterItem_FieldNumber_Display,
 240         .hasIndex = 6,
 241         .offset = (uint32_t)offsetof(GtalkRosterItem__storage_, display),
 242         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
 243         .dataType = GPBDataTypeEnum,
 244       },
 245       {
 246         .name = "rejected",
 247         .dataTypeSpecific.className = NULL,
 248         .number = GtalkRosterItem_FieldNumber_Rejected,
 249         .hasIndex = 7,
 250         .offset = 8,  // Stored in _has_storage_ to save space.
 251         .flags = GPBFieldOptional,
 252         .dataType = GPBDataTypeBool,
 253       },
 254     };
 255     GPBDescriptor *localDescriptor =
 256         [GPBDescriptor allocDescriptorForClass:[GtalkRosterItem class]
 257                                      rootClass:[GtalkGtalkExtensionsRoot class]
 258                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 259                                         fields:fields
 260                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 261                                    storageSize:sizeof(GtalkRosterItem__storage_)
 262                                          flags:GPBDescriptorInitializationFlag_None];
 263     NSAssert(descriptor == nil, @"Startup recursed!");
 264     descriptor = localDescriptor;
 265   }
 266   return descriptor;
 267 }
 268
 269 @end
 270
 271 #pragma mark - Enum GtalkRosterItem_SubscriptionType
 272
 273 GPBEnumDescriptor *GtalkRosterItem_SubscriptionType_EnumDescriptor(void) {
 274   static GPBEnumDescriptor *descriptor = NULL;
 275   if (!descriptor) {
 276     static const char *valueNames =
 277         "None\000To\000From\000Both\000Remove\000";
 278     static const int32_t values[] = {
 279         GtalkRosterItem_SubscriptionType_None,
 280         GtalkRosterItem_SubscriptionType_To,
 281         GtalkRosterItem_SubscriptionType_From,
 282         GtalkRosterItem_SubscriptionType_Both,
 283         GtalkRosterItem_SubscriptionType_Remove,
 284     };
 285     GPBEnumDescriptor *worker =
 286         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkRosterItem_SubscriptionType)
 287                                        valueNames:valueNames
 288                                            values:values
 289                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
 290                                      enumVerifier:GtalkRosterItem_SubscriptionType_IsValidValue];
 291     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
 292       [worker release];
 293     }
 294   }
 295   return descriptor;
 296 }
 297
 298 BOOL GtalkRosterItem_SubscriptionType_IsValidValue(int32_t value__) {
 299   switch (value__) {
 300     case GtalkRosterItem_SubscriptionType_None:
 301     case GtalkRosterItem_SubscriptionType_To:
 302     case GtalkRosterItem_SubscriptionType_From:
 303     case GtalkRosterItem_SubscriptionType_Both:
 304     case GtalkRosterItem_SubscriptionType_Remove:
 305       return YES;
 306     default:
 307       return NO;
 308   }
 309 }
 310
 311 #pragma mark - Enum GtalkRosterItem_AskType
 312
 313 GPBEnumDescriptor *GtalkRosterItem_AskType_EnumDescriptor(void) {
 314   static GPBEnumDescriptor *descriptor = NULL;
 315   if (!descriptor) {
 316     static const char *valueNames =
 317         "Subscribe\000";
 318     static const int32_t values[] = {
 319         GtalkRosterItem_AskType_Subscribe,
 320     };
 321     GPBEnumDescriptor *worker =
 322         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkRosterItem_AskType)
 323                                        valueNames:valueNames
 324                                            values:values
 325                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
 326                                      enumVerifier:GtalkRosterItem_AskType_IsValidValue];
 327     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
 328       [worker release];
 329     }
 330   }
 331   return descriptor;
 332 }
 333
 334 BOOL GtalkRosterItem_AskType_IsValidValue(int32_t value__) {
 335   switch (value__) {
 336     case GtalkRosterItem_AskType_Subscribe:
 337       return YES;
 338     default:
 339       return NO;
 340   }
 341 }
 342
 343 #pragma mark - Enum GtalkRosterItem_DisplayType
 344
 345 GPBEnumDescriptor *GtalkRosterItem_DisplayType_EnumDescriptor(void) {
 346   static GPBEnumDescriptor *descriptor = NULL;
 347   if (!descriptor) {
 348     static const char *valueNames =
 349         "Blocked\000Hidden\000Pinned\000";
 350     static const int32_t values[] = {
 351         GtalkRosterItem_DisplayType_Blocked,
 352         GtalkRosterItem_DisplayType_Hidden,
 353         GtalkRosterItem_DisplayType_Pinned,
 354     };
 355     GPBEnumDescriptor *worker =
 356         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkRosterItem_DisplayType)
 357                                        valueNames:valueNames
 358                                            values:values
 359                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
 360                                      enumVerifier:GtalkRosterItem_DisplayType_IsValidValue];
 361     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
 362       [worker release];
 363     }
 364   }
 365   return descriptor;
 366 }
 367
 368 BOOL GtalkRosterItem_DisplayType_IsValidValue(int32_t value__) {
 369   switch (value__) {
 370     case GtalkRosterItem_DisplayType_Blocked:
 371     case GtalkRosterItem_DisplayType_Hidden:
 372     case GtalkRosterItem_DisplayType_Pinned:
 373       return YES;
 374     default:
 375       return NO;
 376   }
 377 }
 378
 379 #pragma mark - GtalkRmqLastId
 380
 381 @implementation GtalkRmqLastId
 382
 383 @dynamic hasId_p, id_p;
 384
 385 typedef struct GtalkRmqLastId__storage_ {
 386   uint32_t _has_storage_[1];
 387   int64_t id_p;
 388 } GtalkRmqLastId__storage_;
 389
 390 // This method is threadsafe because it is initially called
 391 // in +initialize for each subclass.
 392 + (GPBDescriptor *)descriptor {
 393   static GPBDescriptor *descriptor = nil;
 394   if (!descriptor) {
 395     static GPBMessageFieldDescription fields[] = {
 396       {
 397         .name = "id_p",
 398         .dataTypeSpecific.className = NULL,
 399         .number = GtalkRmqLastId_FieldNumber_Id_p,
 400         .hasIndex = 0,
 401         .offset = (uint32_t)offsetof(GtalkRmqLastId__storage_, id_p),
 402         .flags = GPBFieldRequired,
 403         .dataType = GPBDataTypeInt64,
 404       },
 405     };
 406     GPBDescriptor *localDescriptor =
 407         [GPBDescriptor allocDescriptorForClass:[GtalkRmqLastId class]
 408                                      rootClass:[GtalkGtalkExtensionsRoot class]
 409                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 410                                         fields:fields
 411                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 412                                    storageSize:sizeof(GtalkRmqLastId__storage_)
 413                                          flags:GPBDescriptorInitializationFlag_None];
 414     NSAssert(descriptor == nil, @"Startup recursed!");
 415     descriptor = localDescriptor;
 416   }
 417   return descriptor;
 418 }
 419
 420 @end
 421
 422 #pragma mark - GtalkRmqAck
 423
 424 @implementation GtalkRmqAck
 425
 426 @dynamic hasId_p, id_p;
 427
 428 typedef struct GtalkRmqAck__storage_ {
 429   uint32_t _has_storage_[1];
 430   int64_t id_p;
 431 } GtalkRmqAck__storage_;
 432
 433 // This method is threadsafe because it is initially called
 434 // in +initialize for each subclass.
 435 + (GPBDescriptor *)descriptor {
 436   static GPBDescriptor *descriptor = nil;
 437   if (!descriptor) {
 438     static GPBMessageFieldDescription fields[] = {
 439       {
 440         .name = "id_p",
 441         .dataTypeSpecific.className = NULL,
 442         .number = GtalkRmqAck_FieldNumber_Id_p,
 443         .hasIndex = 0,
 444         .offset = (uint32_t)offsetof(GtalkRmqAck__storage_, id_p),
 445         .flags = GPBFieldRequired,
 446         .dataType = GPBDataTypeInt64,
 447       },
 448     };
 449     GPBDescriptor *localDescriptor =
 450         [GPBDescriptor allocDescriptorForClass:[GtalkRmqAck class]
 451                                      rootClass:[GtalkGtalkExtensionsRoot class]
 452                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 453                                         fields:fields
 454                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 455                                    storageSize:sizeof(GtalkRmqAck__storage_)
 456                                          flags:GPBDescriptorInitializationFlag_None];
 457     NSAssert(descriptor == nil, @"Startup recursed!");
 458     descriptor = localDescriptor;
 459   }
 460   return descriptor;
 461 }
 462
 463 @end
 464
 465 #pragma mark - GtalkVCard
 466
 467 @implementation GtalkVCard
 468
 469 @dynamic hasVersion, version;
 470 @dynamic hasFullName, fullName;
 471 @dynamic hasPhoto, photo;
 472 @dynamic hasAvatarHash, avatarHash;
 473 @dynamic hasModified, modified;
 474
 475 typedef struct GtalkVCard__storage_ {
 476   uint32_t _has_storage_[1];
 477   NSString *version;
 478   NSString *fullName;
 479   GtalkPhoto *photo;
 480   NSString *avatarHash;
 481 } GtalkVCard__storage_;
 482
 483 // This method is threadsafe because it is initially called
 484 // in +initialize for each subclass.
 485 + (GPBDescriptor *)descriptor {
 486   static GPBDescriptor *descriptor = nil;
 487   if (!descriptor) {
 488     static GPBMessageFieldDescription fields[] = {
 489       {
 490         .name = "version",
 491         .dataTypeSpecific.className = NULL,
 492         .number = GtalkVCard_FieldNumber_Version,
 493         .hasIndex = 0,
 494         .offset = (uint32_t)offsetof(GtalkVCard__storage_, version),
 495         .flags = GPBFieldOptional,
 496         .dataType = GPBDataTypeString,
 497       },
 498       {
 499         .name = "fullName",
 500         .dataTypeSpecific.className = NULL,
 501         .number = GtalkVCard_FieldNumber_FullName,
 502         .hasIndex = 1,
 503         .offset = (uint32_t)offsetof(GtalkVCard__storage_, fullName),
 504         .flags = GPBFieldOptional,
 505         .dataType = GPBDataTypeString,
 506       },
 507       {
 508         .name = "photo",
 509         .dataTypeSpecific.className = GPBStringifySymbol(GtalkPhoto),
 510         .number = GtalkVCard_FieldNumber_Photo,
 511         .hasIndex = 2,
 512         .offset = (uint32_t)offsetof(GtalkVCard__storage_, photo),
 513         .flags = GPBFieldOptional,
 514         .dataType = GPBDataTypeMessage,
 515       },
 516       {
 517         .name = "avatarHash",
 518         .dataTypeSpecific.className = NULL,
 519         .number = GtalkVCard_FieldNumber_AvatarHash,
 520         .hasIndex = 3,
 521         .offset = (uint32_t)offsetof(GtalkVCard__storage_, avatarHash),
 522         .flags = GPBFieldOptional,
 523         .dataType = GPBDataTypeString,
 524       },
 525       {
 526         .name = "modified",
 527         .dataTypeSpecific.className = NULL,
 528         .number = GtalkVCard_FieldNumber_Modified,
 529         .hasIndex = 4,
 530         .offset = 5,  // Stored in _has_storage_ to save space.
 531         .flags = GPBFieldOptional,
 532         .dataType = GPBDataTypeBool,
 533       },
 534     };
 535     GPBDescriptor *localDescriptor =
 536         [GPBDescriptor allocDescriptorForClass:[GtalkVCard class]
 537                                      rootClass:[GtalkGtalkExtensionsRoot class]
 538                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 539                                         fields:fields
 540                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 541                                    storageSize:sizeof(GtalkVCard__storage_)
 542                                          flags:GPBDescriptorInitializationFlag_None];
 543     NSAssert(descriptor == nil, @"Startup recursed!");
 544     descriptor = localDescriptor;
 545   }
 546   return descriptor;
 547 }
 548
 549 @end
 550
 551 #pragma mark - GtalkPhoto
 552
 553 @implementation GtalkPhoto
 554
 555 @dynamic hasType, type;
 556 @dynamic hasData_p, data_p;
 557
 558 typedef struct GtalkPhoto__storage_ {
 559   uint32_t _has_storage_[1];
 560   NSString *type;
 561   NSString *data_p;
 562 } GtalkPhoto__storage_;
 563
 564 // This method is threadsafe because it is initially called
 565 // in +initialize for each subclass.
 566 + (GPBDescriptor *)descriptor {
 567   static GPBDescriptor *descriptor = nil;
 568   if (!descriptor) {
 569     static GPBMessageFieldDescription fields[] = {
 570       {
 571         .name = "type",
 572         .dataTypeSpecific.className = NULL,
 573         .number = GtalkPhoto_FieldNumber_Type,
 574         .hasIndex = 0,
 575         .offset = (uint32_t)offsetof(GtalkPhoto__storage_, type),
 576         .flags = GPBFieldOptional,
 577         .dataType = GPBDataTypeString,
 578       },
 579       {
 580         .name = "data_p",
 581         .dataTypeSpecific.className = NULL,
 582         .number = GtalkPhoto_FieldNumber_Data_p,
 583         .hasIndex = 1,
 584         .offset = (uint32_t)offsetof(GtalkPhoto__storage_, data_p),
 585         .flags = GPBFieldOptional,
 586         .dataType = GPBDataTypeString,
 587       },
 588     };
 589     GPBDescriptor *localDescriptor =
 590         [GPBDescriptor allocDescriptorForClass:[GtalkPhoto class]
 591                                      rootClass:[GtalkGtalkExtensionsRoot class]
 592                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 593                                         fields:fields
 594                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 595                                    storageSize:sizeof(GtalkPhoto__storage_)
 596                                          flags:GPBDescriptorInitializationFlag_None];
 597     NSAssert(descriptor == nil, @"Startup recursed!");
 598     descriptor = localDescriptor;
 599   }
 600   return descriptor;
 601 }
 602
 603 @end
 604
 605 #pragma mark - GtalkChatRead
 606
 607 @implementation GtalkChatRead
 608
 609 @dynamic hasUser, user;
 610
 611 typedef struct GtalkChatRead__storage_ {
 612   uint32_t _has_storage_[1];
 613   NSString *user;
 614 } GtalkChatRead__storage_;
 615
 616 // This method is threadsafe because it is initially called
 617 // in +initialize for each subclass.
 618 + (GPBDescriptor *)descriptor {
 619   static GPBDescriptor *descriptor = nil;
 620   if (!descriptor) {
 621     static GPBMessageFieldDescription fields[] = {
 622       {
 623         .name = "user",
 624         .dataTypeSpecific.className = NULL,
 625         .number = GtalkChatRead_FieldNumber_User,
 626         .hasIndex = 0,
 627         .offset = (uint32_t)offsetof(GtalkChatRead__storage_, user),
 628         .flags = GPBFieldRequired,
 629         .dataType = GPBDataTypeString,
 630       },
 631     };
 632     GPBDescriptor *localDescriptor =
 633         [GPBDescriptor allocDescriptorForClass:[GtalkChatRead class]
 634                                      rootClass:[GtalkGtalkExtensionsRoot class]
 635                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 636                                         fields:fields
 637                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 638                                    storageSize:sizeof(GtalkChatRead__storage_)
 639                                          flags:GPBDescriptorInitializationFlag_None];
 640     NSAssert(descriptor == nil, @"Startup recursed!");
 641     descriptor = localDescriptor;
 642   }
 643   return descriptor;
 644 }
 645
 646 @end
 647
 648 #pragma mark - GtalkChatClosed
 649
 650 @implementation GtalkChatClosed
 651
 652 @dynamic hasUser, user;
 653
 654 typedef struct GtalkChatClosed__storage_ {
 655   uint32_t _has_storage_[1];
 656   NSString *user;
 657 } GtalkChatClosed__storage_;
 658
 659 // This method is threadsafe because it is initially called
 660 // in +initialize for each subclass.
 661 + (GPBDescriptor *)descriptor {
 662   static GPBDescriptor *descriptor = nil;
 663   if (!descriptor) {
 664     static GPBMessageFieldDescription fields[] = {
 665       {
 666         .name = "user",
 667         .dataTypeSpecific.className = NULL,
 668         .number = GtalkChatClosed_FieldNumber_User,
 669         .hasIndex = 0,
 670         .offset = (uint32_t)offsetof(GtalkChatClosed__storage_, user),
 671         .flags = GPBFieldRequired,
 672         .dataType = GPBDataTypeString,
 673       },
 674     };
 675     GPBDescriptor *localDescriptor =
 676         [GPBDescriptor allocDescriptorForClass:[GtalkChatClosed class]
 677                                      rootClass:[GtalkGtalkExtensionsRoot class]
 678                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 679                                         fields:fields
 680                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 681                                    storageSize:sizeof(GtalkChatClosed__storage_)
 682                                          flags:GPBDescriptorInitializationFlag_None];
 683     NSAssert(descriptor == nil, @"Startup recursed!");
 684     descriptor = localDescriptor;
 685   }
 686   return descriptor;
 687 }
 688
 689 @end
 690
 691 #pragma mark - GtalkCapabilities
 692
 693 @implementation GtalkCapabilities
 694
 695 @dynamic hasNode, node;
 696 @dynamic hasVer, ver;
 697 @dynamic hasExt, ext;
 698 @dynamic hasHash_p, hash_p;
 699
 700 typedef struct GtalkCapabilities__storage_ {
 701   uint32_t _has_storage_[1];
 702   NSString *node;
 703   NSString *ver;
 704   NSString *ext;
 705   NSString *hash_p;
 706 } GtalkCapabilities__storage_;
 707
 708 // This method is threadsafe because it is initially called
 709 // in +initialize for each subclass.
 710 + (GPBDescriptor *)descriptor {
 711   static GPBDescriptor *descriptor = nil;
 712   if (!descriptor) {
 713     static GPBMessageFieldDescription fields[] = {
 714       {
 715         .name = "node",
 716         .dataTypeSpecific.className = NULL,
 717         .number = GtalkCapabilities_FieldNumber_Node,
 718         .hasIndex = 0,
 719         .offset = (uint32_t)offsetof(GtalkCapabilities__storage_, node),
 720         .flags = GPBFieldRequired,
 721         .dataType = GPBDataTypeString,
 722       },
 723       {
 724         .name = "ver",
 725         .dataTypeSpecific.className = NULL,
 726         .number = GtalkCapabilities_FieldNumber_Ver,
 727         .hasIndex = 1,
 728         .offset = (uint32_t)offsetof(GtalkCapabilities__storage_, ver),
 729         .flags = GPBFieldRequired,
 730         .dataType = GPBDataTypeString,
 731       },
 732       {
 733         .name = "ext",
 734         .dataTypeSpecific.className = NULL,
 735         .number = GtalkCapabilities_FieldNumber_Ext,
 736         .hasIndex = 2,
 737         .offset = (uint32_t)offsetof(GtalkCapabilities__storage_, ext),
 738         .flags = GPBFieldOptional,
 739         .dataType = GPBDataTypeString,
 740       },
 741       {
 742         .name = "hash_p",
 743         .dataTypeSpecific.className = NULL,
 744         .number = GtalkCapabilities_FieldNumber_Hash_p,
 745         .hasIndex = 3,
 746         .offset = (uint32_t)offsetof(GtalkCapabilities__storage_, hash_p),
 747         .flags = GPBFieldOptional,
 748         .dataType = GPBDataTypeString,
 749       },
 750     };
 751     GPBDescriptor *localDescriptor =
 752         [GPBDescriptor allocDescriptorForClass:[GtalkCapabilities class]
 753                                      rootClass:[GtalkGtalkExtensionsRoot class]
 754                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 755                                         fields:fields
 756                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 757                                    storageSize:sizeof(GtalkCapabilities__storage_)
 758                                          flags:GPBDescriptorInitializationFlag_None];
 759     NSAssert(descriptor == nil, @"Startup recursed!");
 760     descriptor = localDescriptor;
 761   }
 762   return descriptor;
 763 }
 764
 765 @end
 766
 767 #pragma mark - GtalkSharedStatus
 768
 769 @implementation GtalkSharedStatus
 770
 771 @dynamic hasStatusMax, statusMax;
 772 @dynamic hasStatusListMax, statusListMax;
 773 @dynamic hasStatusListContentsMax, statusListContentsMax;
 774 @dynamic hasStatus, status;
 775 @dynamic hasShow, show;
 776 @dynamic statusListArray, statusListArray_Count;
 777 @dynamic hasInvisible, invisible;
 778 @dynamic hasStatusMinVersion, statusMinVersion;
 779
 780 typedef struct GtalkSharedStatus__storage_ {
 781   uint32_t _has_storage_[1];
 782   int32_t statusMax;
 783   int32_t statusListMax;
 784   int32_t statusListContentsMax;
 785   GtalkSharedStatus_ShowType show;
 786   int32_t statusMinVersion;
 787   NSString *status;
 788   NSMutableArray *statusListArray;
 789 } GtalkSharedStatus__storage_;
 790
 791 // This method is threadsafe because it is initially called
 792 // in +initialize for each subclass.
 793 + (GPBDescriptor *)descriptor {
 794   static GPBDescriptor *descriptor = nil;
 795   if (!descriptor) {
 796     static GPBMessageFieldDescription fields[] = {
 797       {
 798         .name = "statusMax",
 799         .dataTypeSpecific.className = NULL,
 800         .number = GtalkSharedStatus_FieldNumber_StatusMax,
 801         .hasIndex = 0,
 802         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, statusMax),
 803         .flags = GPBFieldOptional,
 804         .dataType = GPBDataTypeInt32,
 805       },
 806       {
 807         .name = "statusListMax",
 808         .dataTypeSpecific.className = NULL,
 809         .number = GtalkSharedStatus_FieldNumber_StatusListMax,
 810         .hasIndex = 1,
 811         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, statusListMax),
 812         .flags = GPBFieldOptional,
 813         .dataType = GPBDataTypeInt32,
 814       },
 815       {
 816         .name = "statusListContentsMax",
 817         .dataTypeSpecific.className = NULL,
 818         .number = GtalkSharedStatus_FieldNumber_StatusListContentsMax,
 819         .hasIndex = 2,
 820         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, statusListContentsMax),
 821         .flags = GPBFieldOptional,
 822         .dataType = GPBDataTypeInt32,
 823       },
 824       {
 825         .name = "status",
 826         .dataTypeSpecific.className = NULL,
 827         .number = GtalkSharedStatus_FieldNumber_Status,
 828         .hasIndex = 3,
 829         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, status),
 830         .flags = GPBFieldOptional,
 831         .dataType = GPBDataTypeString,
 832       },
 833       {
 834         .name = "show",
 835         .dataTypeSpecific.enumDescFunc = GtalkSharedStatus_ShowType_EnumDescriptor,
 836         .number = GtalkSharedStatus_FieldNumber_Show,
 837         .hasIndex = 4,
 838         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, show),
 839         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
 840         .dataType = GPBDataTypeEnum,
 841       },
 842       {
 843         .name = "statusListArray",
 844         .dataTypeSpecific.className = GPBStringifySymbol(GtalkSharedStatus_StatusList),
 845         .number = GtalkSharedStatus_FieldNumber_StatusListArray,
 846         .hasIndex = GPBNoHasBit,
 847         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, statusListArray),
 848         .flags = GPBFieldRepeated,
 849         .dataType = GPBDataTypeGroup,
 850       },
 851       {
 852         .name = "invisible",
 853         .dataTypeSpecific.className = NULL,
 854         .number = GtalkSharedStatus_FieldNumber_Invisible,
 855         .hasIndex = 5,
 856         .offset = 6,  // Stored in _has_storage_ to save space.
 857         .flags = GPBFieldOptional,
 858         .dataType = GPBDataTypeBool,
 859       },
 860       {
 861         .name = "statusMinVersion",
 862         .dataTypeSpecific.className = NULL,
 863         .number = GtalkSharedStatus_FieldNumber_StatusMinVersion,
 864         .hasIndex = 7,
 865         .offset = (uint32_t)offsetof(GtalkSharedStatus__storage_, statusMinVersion),
 866         .flags = GPBFieldOptional,
 867         .dataType = GPBDataTypeInt32,
 868       },
 869     };
 870     GPBDescriptor *localDescriptor =
 871         [GPBDescriptor allocDescriptorForClass:[GtalkSharedStatus class]
 872                                      rootClass:[GtalkGtalkExtensionsRoot class]
 873                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 874                                         fields:fields
 875                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 876                                    storageSize:sizeof(GtalkSharedStatus__storage_)
 877                                          flags:GPBDescriptorInitializationFlag_None];
 878     NSAssert(descriptor == nil, @"Startup recursed!");
 879     descriptor = localDescriptor;
 880   }
 881   return descriptor;
 882 }
 883
 884 @end
 885
 886 #pragma mark - Enum GtalkSharedStatus_ShowType
 887
 888 GPBEnumDescriptor *GtalkSharedStatus_ShowType_EnumDescriptor(void) {
 889   static GPBEnumDescriptor *descriptor = NULL;
 890   if (!descriptor) {
 891     static const char *valueNames =
 892         "Default\000Dnd\000";
 893     static const int32_t values[] = {
 894         GtalkSharedStatus_ShowType_Default,
 895         GtalkSharedStatus_ShowType_Dnd,
 896     };
 897     GPBEnumDescriptor *worker =
 898         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkSharedStatus_ShowType)
 899                                        valueNames:valueNames
 900                                            values:values
 901                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
 902                                      enumVerifier:GtalkSharedStatus_ShowType_IsValidValue];
 903     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
 904       [worker release];
 905     }
 906   }
 907   return descriptor;
 908 }
 909
 910 BOOL GtalkSharedStatus_ShowType_IsValidValue(int32_t value__) {
 911   switch (value__) {
 912     case GtalkSharedStatus_ShowType_Default:
 913     case GtalkSharedStatus_ShowType_Dnd:
 914       return YES;
 915     default:
 916       return NO;
 917   }
 918 }
 919
 920 #pragma mark - GtalkSharedStatus_StatusList
 921
 922 @implementation GtalkSharedStatus_StatusList
 923
 924 @dynamic hasShow, show;
 925 @dynamic statusArray, statusArray_Count;
 926
 927 typedef struct GtalkSharedStatus_StatusList__storage_ {
 928   uint32_t _has_storage_[1];
 929   GtalkSharedStatus_ShowType show;
 930   NSMutableArray *statusArray;
 931 } GtalkSharedStatus_StatusList__storage_;
 932
 933 // This method is threadsafe because it is initially called
 934 // in +initialize for each subclass.
 935 + (GPBDescriptor *)descriptor {
 936   static GPBDescriptor *descriptor = nil;
 937   if (!descriptor) {
 938     static GPBMessageFieldDescription fields[] = {
 939       {
 940         .name = "show",
 941         .dataTypeSpecific.enumDescFunc = GtalkSharedStatus_ShowType_EnumDescriptor,
 942         .number = GtalkSharedStatus_StatusList_FieldNumber_Show,
 943         .hasIndex = 0,
 944         .offset = (uint32_t)offsetof(GtalkSharedStatus_StatusList__storage_, show),
 945         .flags = (GPBFieldFlags)(GPBFieldRequired | GPBFieldHasEnumDescriptor),
 946         .dataType = GPBDataTypeEnum,
 947       },
 948       {
 949         .name = "statusArray",
 950         .dataTypeSpecific.className = NULL,
 951         .number = GtalkSharedStatus_StatusList_FieldNumber_StatusArray,
 952         .hasIndex = GPBNoHasBit,
 953         .offset = (uint32_t)offsetof(GtalkSharedStatus_StatusList__storage_, statusArray),
 954         .flags = GPBFieldRepeated,
 955         .dataType = GPBDataTypeString,
 956       },
 957     };
 958     GPBDescriptor *localDescriptor =
 959         [GPBDescriptor allocDescriptorForClass:[GtalkSharedStatus_StatusList class]
 960                                      rootClass:[GtalkGtalkExtensionsRoot class]
 961                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
 962                                         fields:fields
 963                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 964                                    storageSize:sizeof(GtalkSharedStatus_StatusList__storage_)
 965                                          flags:GPBDescriptorInitializationFlag_None];
 966     [localDescriptor setupContainingMessageClassName:GPBStringifySymbol(GtalkSharedStatus)];
 967     NSAssert(descriptor == nil, @"Startup recursed!");
 968     descriptor = localDescriptor;
 969   }
 970   return descriptor;
 971 }
 972
 973 @end
 974
 975 #pragma mark - GtalkOtrQuery
 976
 977 @implementation GtalkOtrQuery
 978
 979 @dynamic hasNosaveDefault, nosaveDefault;
 980 @dynamic itemArray, itemArray_Count;
 981 @dynamic hasEtag, etag;
 982 @dynamic hasNotModified, notModified;
 983
 984 typedef struct GtalkOtrQuery__storage_ {
 985   uint32_t _has_storage_[1];
 986   NSMutableArray *itemArray;
 987   NSString *etag;
 988 } GtalkOtrQuery__storage_;
 989
 990 // This method is threadsafe because it is initially called
 991 // in +initialize for each subclass.
 992 + (GPBDescriptor *)descriptor {
 993   static GPBDescriptor *descriptor = nil;
 994   if (!descriptor) {
 995     static GPBMessageFieldDescription fields[] = {
 996       {
 997         .name = "nosaveDefault",
 998         .dataTypeSpecific.className = NULL,
 999         .number = GtalkOtrQuery_FieldNumber_NosaveDefault,
1000         .hasIndex = 0,
1001         .offset = 1,  // Stored in _has_storage_ to save space.
1002         .flags = GPBFieldOptional,
1003         .dataType = GPBDataTypeBool,
1004       },
1005       {
1006         .name = "itemArray",
1007         .dataTypeSpecific.className = GPBStringifySymbol(GtalkOtrItem),
1008         .number = GtalkOtrQuery_FieldNumber_ItemArray,
1009         .hasIndex = GPBNoHasBit,
1010         .offset = (uint32_t)offsetof(GtalkOtrQuery__storage_, itemArray),
1011         .flags = GPBFieldRepeated,
1012         .dataType = GPBDataTypeMessage,
1013       },
1014       {
1015         .name = "etag",
1016         .dataTypeSpecific.className = NULL,
1017         .number = GtalkOtrQuery_FieldNumber_Etag,
1018         .hasIndex = 2,
1019         .offset = (uint32_t)offsetof(GtalkOtrQuery__storage_, etag),
1020         .flags = GPBFieldOptional,
1021         .dataType = GPBDataTypeString,
1022       },
1023       {
1024         .name = "notModified",
1025         .dataTypeSpecific.className = NULL,
1026         .number = GtalkOtrQuery_FieldNumber_NotModified,
1027         .hasIndex = 3,
1028         .offset = 4,  // Stored in _has_storage_ to save space.
1029         .flags = GPBFieldOptional,
1030         .dataType = GPBDataTypeBool,
1031       },
1032     };
1033     GPBDescriptor *localDescriptor =
1034         [GPBDescriptor allocDescriptorForClass:[GtalkOtrQuery class]
1035                                      rootClass:[GtalkGtalkExtensionsRoot class]
1036                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
1037                                         fields:fields
1038                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1039                                    storageSize:sizeof(GtalkOtrQuery__storage_)
1040                                          flags:GPBDescriptorInitializationFlag_None];
1041     NSAssert(descriptor == nil, @"Startup recursed!");
1042     descriptor = localDescriptor;
1043   }
1044   return descriptor;
1045 }
1046
1047 @end
1048
1049 #pragma mark - GtalkOtrItem
1050
1051 @implementation GtalkOtrItem
1052
1053 @dynamic hasJid, jid;
1054 @dynamic hasNosave, nosave;
1055 @dynamic hasChangedByBuddy, changedByBuddy;
1056
1057 typedef struct GtalkOtrItem__storage_ {
1058   uint32_t _has_storage_[1];
1059   NSString *jid;
1060 } GtalkOtrItem__storage_;
1061
1062 // This method is threadsafe because it is initially called
1063 // in +initialize for each subclass.
1064 + (GPBDescriptor *)descriptor {
1065   static GPBDescriptor *descriptor = nil;
1066   if (!descriptor) {
1067     static GPBMessageFieldDescription fields[] = {
1068       {
1069         .name = "jid",
1070         .dataTypeSpecific.className = NULL,
1071         .number = GtalkOtrItem_FieldNumber_Jid,
1072         .hasIndex = 0,
1073         .offset = (uint32_t)offsetof(GtalkOtrItem__storage_, jid),
1074         .flags = GPBFieldRequired,
1075         .dataType = GPBDataTypeString,
1076       },
1077       {
1078         .name = "nosave",
1079         .dataTypeSpecific.className = NULL,
1080         .number = GtalkOtrItem_FieldNumber_Nosave,
1081         .hasIndex = 1,
1082         .offset = 2,  // Stored in _has_storage_ to save space.
1083         .flags = GPBFieldRequired,
1084         .dataType = GPBDataTypeBool,
1085       },
1086       {
1087         .name = "changedByBuddy",
1088         .dataTypeSpecific.className = NULL,
1089         .number = GtalkOtrItem_FieldNumber_ChangedByBuddy,
1090         .hasIndex = 3,
1091         .offset = 4,  // Stored in _has_storage_ to save space.
1092         .flags = GPBFieldOptional,
1093         .dataType = GPBDataTypeBool,
1094       },
1095     };
1096     GPBDescriptor *localDescriptor =
1097         [GPBDescriptor allocDescriptorForClass:[GtalkOtrItem class]
1098                                      rootClass:[GtalkGtalkExtensionsRoot class]
1099                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
1100                                         fields:fields
1101                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1102                                    storageSize:sizeof(GtalkOtrItem__storage_)
1103                                          flags:GPBDescriptorInitializationFlag_None];
1104     NSAssert(descriptor == nil, @"Startup recursed!");
1105     descriptor = localDescriptor;
1106   }
1107   return descriptor;
1108 }
1109
1110 @end
1111
1112 #pragma mark - GtalkIdle
1113
1114 @implementation GtalkIdle
1115
1116 @dynamic hasIdle, idle;
1117 @dynamic hasAway, away;
1118
1119 typedef struct GtalkIdle__storage_ {
1120   uint32_t _has_storage_[1];
1121 } GtalkIdle__storage_;
1122
1123 // This method is threadsafe because it is initially called
1124 // in +initialize for each subclass.
1125 + (GPBDescriptor *)descriptor {
1126   static GPBDescriptor *descriptor = nil;
1127   if (!descriptor) {
1128     static GPBMessageFieldDescription fields[] = {
1129       {
1130         .name = "idle",
1131         .dataTypeSpecific.className = NULL,
1132         .number = GtalkIdle_FieldNumber_Idle,
1133         .hasIndex = 0,
1134         .offset = 1,  // Stored in _has_storage_ to save space.
1135         .flags = GPBFieldRequired,
1136         .dataType = GPBDataTypeBool,
1137       },
1138       {
1139         .name = "away",
1140         .dataTypeSpecific.className = NULL,
1141         .number = GtalkIdle_FieldNumber_Away,
1142         .hasIndex = 2,
1143         .offset = 3,  // Stored in _has_storage_ to save space.
1144         .flags = GPBFieldOptional,
1145         .dataType = GPBDataTypeBool,
1146       },
1147     };
1148     GPBDescriptor *localDescriptor =
1149         [GPBDescriptor allocDescriptorForClass:[GtalkIdle class]
1150                                      rootClass:[GtalkGtalkExtensionsRoot class]
1151                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
1152                                         fields:fields
1153                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1154                                    storageSize:sizeof(GtalkIdle__storage_)
1155                                          flags:GPBDescriptorInitializationFlag_None];
1156     NSAssert(descriptor == nil, @"Startup recursed!");
1157     descriptor = localDescriptor;
1158   }
1159   return descriptor;
1160 }
1161
1162 @end
1163
1164 #pragma mark - GtalkPostAuthBatchQuery
1165
1166 @implementation GtalkPostAuthBatchQuery
1167
1168 @dynamic hasAvailable, available;
1169 @dynamic hasDeviceIdle, deviceIdle;
1170 @dynamic hasMobileIndicator, mobileIndicator;
1171 @dynamic hasSharedStatusVersion, sharedStatusVersion;
1172 @dynamic hasRosterEtag, rosterEtag;
1173 @dynamic hasOtrEtag, otrEtag;
1174 @dynamic hasAvatarHash, avatarHash;
1175 @dynamic hasVcardQueryStanzaId, vcardQueryStanzaId;
1176 @dynamic hasCapabilitiesExtFlags, capabilitiesExtFlags;
1177
1178 typedef struct GtalkPostAuthBatchQuery__storage_ {
1179   uint32_t _has_storage_[1];
1180   int32_t sharedStatusVersion;
1181   int32_t capabilitiesExtFlags;
1182   NSString *rosterEtag;
1183   NSString *otrEtag;
1184   NSString *avatarHash;
1185   NSString *vcardQueryStanzaId;
1186 } GtalkPostAuthBatchQuery__storage_;
1187
1188 // This method is threadsafe because it is initially called
1189 // in +initialize for each subclass.
1190 + (GPBDescriptor *)descriptor {
1191   static GPBDescriptor *descriptor = nil;
1192   if (!descriptor) {
1193     static GPBMessageFieldDescription fields[] = {
1194       {
1195         .name = "available",
1196         .dataTypeSpecific.className = NULL,
1197         .number = GtalkPostAuthBatchQuery_FieldNumber_Available,
1198         .hasIndex = 0,
1199         .offset = 1,  // Stored in _has_storage_ to save space.
1200         .flags = GPBFieldRequired,
1201         .dataType = GPBDataTypeBool,
1202       },
1203       {
1204         .name = "deviceIdle",
1205         .dataTypeSpecific.className = NULL,
1206         .number = GtalkPostAuthBatchQuery_FieldNumber_DeviceIdle,
1207         .hasIndex = 2,
1208         .offset = 3,  // Stored in _has_storage_ to save space.
1209         .flags = GPBFieldOptional,
1210         .dataType = GPBDataTypeBool,
1211       },
1212       {
1213         .name = "mobileIndicator",
1214         .dataTypeSpecific.className = NULL,
1215         .number = GtalkPostAuthBatchQuery_FieldNumber_MobileIndicator,
1216         .hasIndex = 4,
1217         .offset = 5,  // Stored in _has_storage_ to save space.
1218         .flags = GPBFieldOptional,
1219         .dataType = GPBDataTypeBool,
1220       },
1221       {
1222         .name = "sharedStatusVersion",
1223         .dataTypeSpecific.className = NULL,
1224         .number = GtalkPostAuthBatchQuery_FieldNumber_SharedStatusVersion,
1225         .hasIndex = 6,
1226         .offset = (uint32_t)offsetof(GtalkPostAuthBatchQuery__storage_, sharedStatusVersion),
1227         .flags = GPBFieldOptional,
1228         .dataType = GPBDataTypeInt32,
1229       },
1230       {
1231         .name = "rosterEtag",
1232         .dataTypeSpecific.className = NULL,
1233         .number = GtalkPostAuthBatchQuery_FieldNumber_RosterEtag,
1234         .hasIndex = 7,
1235         .offset = (uint32_t)offsetof(GtalkPostAuthBatchQuery__storage_, rosterEtag),
1236         .flags = GPBFieldOptional,
1237         .dataType = GPBDataTypeString,
1238       },
1239       {
1240         .name = "otrEtag",
1241         .dataTypeSpecific.className = NULL,
1242         .number = GtalkPostAuthBatchQuery_FieldNumber_OtrEtag,
1243         .hasIndex = 8,
1244         .offset = (uint32_t)offsetof(GtalkPostAuthBatchQuery__storage_, otrEtag),
1245         .flags = GPBFieldOptional,
1246         .dataType = GPBDataTypeString,
1247       },
1248       {
1249         .name = "avatarHash",
1250         .dataTypeSpecific.className = NULL,
1251         .number = GtalkPostAuthBatchQuery_FieldNumber_AvatarHash,
1252         .hasIndex = 9,
1253         .offset = (uint32_t)offsetof(GtalkPostAuthBatchQuery__storage_, avatarHash),
1254         .flags = GPBFieldOptional,
1255         .dataType = GPBDataTypeString,
1256       },
1257       {
1258         .name = "vcardQueryStanzaId",
1259         .dataTypeSpecific.className = NULL,
1260         .number = GtalkPostAuthBatchQuery_FieldNumber_VcardQueryStanzaId,
1261         .hasIndex = 10,
1262         .offset = (uint32_t)offsetof(GtalkPostAuthBatchQuery__storage_, vcardQueryStanzaId),
1263         .flags = GPBFieldOptional,
1264         .dataType = GPBDataTypeString,
1265       },
1266       {
1267         .name = "capabilitiesExtFlags",
1268         .dataTypeSpecific.className = NULL,
1269         .number = GtalkPostAuthBatchQuery_FieldNumber_CapabilitiesExtFlags,
1270         .hasIndex = 11,
1271         .offset = (uint32_t)offsetof(GtalkPostAuthBatchQuery__storage_, capabilitiesExtFlags),
1272         .flags = GPBFieldOptional,
1273         .dataType = GPBDataTypeInt32,
1274       },
1275     };
1276     GPBDescriptor *localDescriptor =
1277         [GPBDescriptor allocDescriptorForClass:[GtalkPostAuthBatchQuery class]
1278                                      rootClass:[GtalkGtalkExtensionsRoot class]
1279                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
1280                                         fields:fields
1281                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1282                                    storageSize:sizeof(GtalkPostAuthBatchQuery__storage_)
1283                                          flags:GPBDescriptorInitializationFlag_None];
1284     NSAssert(descriptor == nil, @"Startup recursed!");
1285     descriptor = localDescriptor;
1286   }
1287   return descriptor;
1288 }
1289
1290 @end
1291
1292 #pragma mark - Enum GtalkPostAuthBatchQuery_CapabilitiesExtFlags
1293
1294 GPBEnumDescriptor *GtalkPostAuthBatchQuery_CapabilitiesExtFlags_EnumDescriptor(void) {
1295   static GPBEnumDescriptor *descriptor = NULL;
1296   if (!descriptor) {
1297     static const char *valueNames =
1298         "HasVoiceV1\000HasVideoV1\000HasCameraV1\000HasPmu"
1299         "cV1\000";
1300     static const int32_t values[] = {
1301         GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasVoiceV1,
1302         GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasVideoV1,
1303         GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasCameraV1,
1304         GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasPmucV1,
1305     };
1306     GPBEnumDescriptor *worker =
1307         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkPostAuthBatchQuery_CapabilitiesExtFlags)
1308                                        valueNames:valueNames
1309                                            values:values
1310                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
1311                                      enumVerifier:GtalkPostAuthBatchQuery_CapabilitiesExtFlags_IsValidValue];
1312     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
1313       [worker release];
1314     }
1315   }
1316   return descriptor;
1317 }
1318
1319 BOOL GtalkPostAuthBatchQuery_CapabilitiesExtFlags_IsValidValue(int32_t value__) {
1320   switch (value__) {
1321     case GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasVoiceV1:
1322     case GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasVideoV1:
1323     case GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasCameraV1:
1324     case GtalkPostAuthBatchQuery_CapabilitiesExtFlags_HasPmucV1:
1325       return YES;
1326     default:
1327       return NO;
1328   }
1329 }
1330
1331 #pragma mark - GtalkStreamAck
1332
1333 @implementation GtalkStreamAck
1334
1335
1336 typedef struct GtalkStreamAck__storage_ {
1337   uint32_t _has_storage_[1];
1338 } GtalkStreamAck__storage_;
1339
1340 // This method is threadsafe because it is initially called
1341 // in +initialize for each subclass.
1342 + (GPBDescriptor *)descriptor {
1343   static GPBDescriptor *descriptor = nil;
1344   if (!descriptor) {
1345     GPBDescriptor *localDescriptor =
1346         [GPBDescriptor allocDescriptorForClass:[GtalkStreamAck class]
1347                                      rootClass:[GtalkGtalkExtensionsRoot class]
1348                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
1349                                         fields:NULL
1350                                     fieldCount:0
1351                                    storageSize:sizeof(GtalkStreamAck__storage_)
1352                                          flags:GPBDescriptorInitializationFlag_None];
1353     NSAssert(descriptor == nil, @"Startup recursed!");
1354     descriptor = localDescriptor;
1355   }
1356   return descriptor;
1357 }
1358
1359 @end
1360
1361 #pragma mark - GtalkSelectiveAck
1362
1363 @implementation GtalkSelectiveAck
1364
1365 @dynamic idArray, idArray_Count;
1366
1367 typedef struct GtalkSelectiveAck__storage_ {
1368   uint32_t _has_storage_[1];
1369   NSMutableArray *idArray;
1370 } GtalkSelectiveAck__storage_;
1371
1372 // This method is threadsafe because it is initially called
1373 // in +initialize for each subclass.
1374 + (GPBDescriptor *)descriptor {
1375   static GPBDescriptor *descriptor = nil;
1376   if (!descriptor) {
1377     static GPBMessageFieldDescription fields[] = {
1378       {
1379         .name = "idArray",
1380         .dataTypeSpecific.className = NULL,
1381         .number = GtalkSelectiveAck_FieldNumber_IdArray,
1382         .hasIndex = GPBNoHasBit,
1383         .offset = (uint32_t)offsetof(GtalkSelectiveAck__storage_, idArray),
1384         .flags = GPBFieldRepeated,
1385         .dataType = GPBDataTypeString,
1386       },
1387     };
1388     GPBDescriptor *localDescriptor =
1389         [GPBDescriptor allocDescriptorForClass:[GtalkSelectiveAck class]
1390                                      rootClass:[GtalkGtalkExtensionsRoot class]
1391                                           file:GtalkGtalkExtensionsRoot_FileDescriptor()
1392                                         fields:fields
1393                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1394                                    storageSize:sizeof(GtalkSelectiveAck__storage_)
1395                                          flags:GPBDescriptorInitializationFlag_None];
1396     NSAssert(descriptor == nil, @"Startup recursed!");
1397     descriptor = localDescriptor;
1398   }
1399   return descriptor;
1400 }
1401
1402 @end
1403
1404
1405 #pragma clang diagnostic pop
1406
1407 // @@protoc_insertion_point(global_scope)