iOS/Pods/FirebaseMessaging/Firebase/Messaging/Protos/GtalkCore.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_core.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 "GtalkCore.pbobjc.h"
  33 // @@protoc_insertion_point(imports)
  34
  35 #pragma clang diagnostic push
  36 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
  37
  38 #pragma mark - GtalkGtalkCoreRoot
  39
  40 @implementation GtalkGtalkCoreRoot
  41
  42 // No extensions in the file and no imports, so no need to generate
  43 // +extensionRegistry.
  44
  45 @end
  46
  47 #pragma mark - GtalkGtalkCoreRoot_FileDescriptor
  48
  49 static GPBFileDescriptor *GtalkGtalkCoreRoot_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 - GtalkHeartbeatPing
  63
  64 @implementation GtalkHeartbeatPing
  65
  66 @dynamic hasStreamId, streamId;
  67 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
  68 @dynamic hasStatus, status;
  69 @dynamic hasCellTower, cellTower;
  70 @dynamic hasIntervalMs, intervalMs;
  71
  72 typedef struct GtalkHeartbeatPing__storage_ {
  73   uint32_t _has_storage_[1];
  74   int32_t streamId;
  75   int32_t lastStreamIdReceived;
  76   int32_t intervalMs;
  77   GtalkCellTower *cellTower;
  78   int64_t status;
  79 } GtalkHeartbeatPing__storage_;
  80
  81 // This method is threadsafe because it is initially called
  82 // in +initialize for each subclass.
  83 + (GPBDescriptor *)descriptor {
  84   static GPBDescriptor *descriptor = nil;
  85   if (!descriptor) {
  86     static GPBMessageFieldDescription fields[] = {
  87       {
  88         .name = "streamId",
  89         .dataTypeSpecific.className = NULL,
  90         .number = GtalkHeartbeatPing_FieldNumber_StreamId,
  91         .hasIndex = 0,
  92         .offset = (uint32_t)offsetof(GtalkHeartbeatPing__storage_, streamId),
  93         .flags = GPBFieldOptional,
  94         .dataType = GPBDataTypeInt32,
  95       },
  96       {
  97         .name = "lastStreamIdReceived",
  98         .dataTypeSpecific.className = NULL,
  99         .number = GtalkHeartbeatPing_FieldNumber_LastStreamIdReceived,
 100         .hasIndex = 1,
 101         .offset = (uint32_t)offsetof(GtalkHeartbeatPing__storage_, lastStreamIdReceived),
 102         .flags = GPBFieldOptional,
 103         .dataType = GPBDataTypeInt32,
 104       },
 105       {
 106         .name = "status",
 107         .dataTypeSpecific.className = NULL,
 108         .number = GtalkHeartbeatPing_FieldNumber_Status,
 109         .hasIndex = 2,
 110         .offset = (uint32_t)offsetof(GtalkHeartbeatPing__storage_, status),
 111         .flags = GPBFieldOptional,
 112         .dataType = GPBDataTypeInt64,
 113       },
 114       {
 115         .name = "cellTower",
 116         .dataTypeSpecific.className = GPBStringifySymbol(GtalkCellTower),
 117         .number = GtalkHeartbeatPing_FieldNumber_CellTower,
 118         .hasIndex = 3,
 119         .offset = (uint32_t)offsetof(GtalkHeartbeatPing__storage_, cellTower),
 120         .flags = GPBFieldOptional,
 121         .dataType = GPBDataTypeMessage,
 122       },
 123       {
 124         .name = "intervalMs",
 125         .dataTypeSpecific.className = NULL,
 126         .number = GtalkHeartbeatPing_FieldNumber_IntervalMs,
 127         .hasIndex = 4,
 128         .offset = (uint32_t)offsetof(GtalkHeartbeatPing__storage_, intervalMs),
 129         .flags = GPBFieldOptional,
 130         .dataType = GPBDataTypeInt32,
 131       },
 132     };
 133     GPBDescriptor *localDescriptor =
 134         [GPBDescriptor allocDescriptorForClass:[GtalkHeartbeatPing class]
 135                                      rootClass:[GtalkGtalkCoreRoot class]
 136                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 137                                         fields:fields
 138                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 139                                    storageSize:sizeof(GtalkHeartbeatPing__storage_)
 140                                          flags:GPBDescriptorInitializationFlag_None];
 141     NSAssert(descriptor == nil, @"Startup recursed!");
 142     descriptor = localDescriptor;
 143   }
 144   return descriptor;
 145 }
 146
 147 @end
 148
 149 #pragma mark - GtalkHeartbeatAck
 150
 151 @implementation GtalkHeartbeatAck
 152
 153 @dynamic hasStreamId, streamId;
 154 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
 155 @dynamic hasStatus, status;
 156 @dynamic hasCellTower, cellTower;
 157 @dynamic hasIntervalMs, intervalMs;
 158
 159 typedef struct GtalkHeartbeatAck__storage_ {
 160   uint32_t _has_storage_[1];
 161   int32_t streamId;
 162   int32_t lastStreamIdReceived;
 163   int32_t intervalMs;
 164   GtalkCellTower *cellTower;
 165   int64_t status;
 166 } GtalkHeartbeatAck__storage_;
 167
 168 // This method is threadsafe because it is initially called
 169 // in +initialize for each subclass.
 170 + (GPBDescriptor *)descriptor {
 171   static GPBDescriptor *descriptor = nil;
 172   if (!descriptor) {
 173     static GPBMessageFieldDescription fields[] = {
 174       {
 175         .name = "streamId",
 176         .dataTypeSpecific.className = NULL,
 177         .number = GtalkHeartbeatAck_FieldNumber_StreamId,
 178         .hasIndex = 0,
 179         .offset = (uint32_t)offsetof(GtalkHeartbeatAck__storage_, streamId),
 180         .flags = GPBFieldOptional,
 181         .dataType = GPBDataTypeInt32,
 182       },
 183       {
 184         .name = "lastStreamIdReceived",
 185         .dataTypeSpecific.className = NULL,
 186         .number = GtalkHeartbeatAck_FieldNumber_LastStreamIdReceived,
 187         .hasIndex = 1,
 188         .offset = (uint32_t)offsetof(GtalkHeartbeatAck__storage_, lastStreamIdReceived),
 189         .flags = GPBFieldOptional,
 190         .dataType = GPBDataTypeInt32,
 191       },
 192       {
 193         .name = "status",
 194         .dataTypeSpecific.className = NULL,
 195         .number = GtalkHeartbeatAck_FieldNumber_Status,
 196         .hasIndex = 2,
 197         .offset = (uint32_t)offsetof(GtalkHeartbeatAck__storage_, status),
 198         .flags = GPBFieldOptional,
 199         .dataType = GPBDataTypeInt64,
 200       },
 201       {
 202         .name = "cellTower",
 203         .dataTypeSpecific.className = GPBStringifySymbol(GtalkCellTower),
 204         .number = GtalkHeartbeatAck_FieldNumber_CellTower,
 205         .hasIndex = 3,
 206         .offset = (uint32_t)offsetof(GtalkHeartbeatAck__storage_, cellTower),
 207         .flags = GPBFieldOptional,
 208         .dataType = GPBDataTypeMessage,
 209       },
 210       {
 211         .name = "intervalMs",
 212         .dataTypeSpecific.className = NULL,
 213         .number = GtalkHeartbeatAck_FieldNumber_IntervalMs,
 214         .hasIndex = 4,
 215         .offset = (uint32_t)offsetof(GtalkHeartbeatAck__storage_, intervalMs),
 216         .flags = GPBFieldOptional,
 217         .dataType = GPBDataTypeInt32,
 218       },
 219     };
 220     GPBDescriptor *localDescriptor =
 221         [GPBDescriptor allocDescriptorForClass:[GtalkHeartbeatAck class]
 222                                      rootClass:[GtalkGtalkCoreRoot class]
 223                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 224                                         fields:fields
 225                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 226                                    storageSize:sizeof(GtalkHeartbeatAck__storage_)
 227                                          flags:GPBDescriptorInitializationFlag_None];
 228     NSAssert(descriptor == nil, @"Startup recursed!");
 229     descriptor = localDescriptor;
 230   }
 231   return descriptor;
 232 }
 233
 234 @end
 235
 236 #pragma mark - GtalkErrorInfo
 237
 238 @implementation GtalkErrorInfo
 239
 240 @dynamic hasCode, code;
 241 @dynamic hasMessage, message;
 242 @dynamic hasType, type;
 243 @dynamic hasExtension, extension;
 244
 245 typedef struct GtalkErrorInfo__storage_ {
 246   uint32_t _has_storage_[1];
 247   int32_t code;
 248   NSString *message;
 249   NSString *type;
 250   GtalkExtension *extension;
 251 } GtalkErrorInfo__storage_;
 252
 253 // This method is threadsafe because it is initially called
 254 // in +initialize for each subclass.
 255 + (GPBDescriptor *)descriptor {
 256   static GPBDescriptor *descriptor = nil;
 257   if (!descriptor) {
 258     static GPBMessageFieldDescription fields[] = {
 259       {
 260         .name = "code",
 261         .dataTypeSpecific.className = NULL,
 262         .number = GtalkErrorInfo_FieldNumber_Code,
 263         .hasIndex = 0,
 264         .offset = (uint32_t)offsetof(GtalkErrorInfo__storage_, code),
 265         .flags = GPBFieldRequired,
 266         .dataType = GPBDataTypeInt32,
 267       },
 268       {
 269         .name = "message",
 270         .dataTypeSpecific.className = NULL,
 271         .number = GtalkErrorInfo_FieldNumber_Message,
 272         .hasIndex = 1,
 273         .offset = (uint32_t)offsetof(GtalkErrorInfo__storage_, message),
 274         .flags = GPBFieldOptional,
 275         .dataType = GPBDataTypeString,
 276       },
 277       {
 278         .name = "type",
 279         .dataTypeSpecific.className = NULL,
 280         .number = GtalkErrorInfo_FieldNumber_Type,
 281         .hasIndex = 2,
 282         .offset = (uint32_t)offsetof(GtalkErrorInfo__storage_, type),
 283         .flags = GPBFieldOptional,
 284         .dataType = GPBDataTypeString,
 285       },
 286       {
 287         .name = "extension",
 288         .dataTypeSpecific.className = GPBStringifySymbol(GtalkExtension),
 289         .number = GtalkErrorInfo_FieldNumber_Extension,
 290         .hasIndex = 3,
 291         .offset = (uint32_t)offsetof(GtalkErrorInfo__storage_, extension),
 292         .flags = GPBFieldOptional,
 293         .dataType = GPBDataTypeMessage,
 294       },
 295     };
 296     GPBDescriptor *localDescriptor =
 297         [GPBDescriptor allocDescriptorForClass:[GtalkErrorInfo class]
 298                                      rootClass:[GtalkGtalkCoreRoot class]
 299                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 300                                         fields:fields
 301                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 302                                    storageSize:sizeof(GtalkErrorInfo__storage_)
 303                                          flags:GPBDescriptorInitializationFlag_None];
 304     NSAssert(descriptor == nil, @"Startup recursed!");
 305     descriptor = localDescriptor;
 306   }
 307   return descriptor;
 308 }
 309
 310 @end
 311
 312 #pragma mark - GtalkSetting
 313
 314 @implementation GtalkSetting
 315
 316 @dynamic hasName, name;
 317 @dynamic hasValue, value;
 318
 319 typedef struct GtalkSetting__storage_ {
 320   uint32_t _has_storage_[1];
 321   NSString *name;
 322   NSString *value;
 323 } GtalkSetting__storage_;
 324
 325 // This method is threadsafe because it is initially called
 326 // in +initialize for each subclass.
 327 + (GPBDescriptor *)descriptor {
 328   static GPBDescriptor *descriptor = nil;
 329   if (!descriptor) {
 330     static GPBMessageFieldDescription fields[] = {
 331       {
 332         .name = "name",
 333         .dataTypeSpecific.className = NULL,
 334         .number = GtalkSetting_FieldNumber_Name,
 335         .hasIndex = 0,
 336         .offset = (uint32_t)offsetof(GtalkSetting__storage_, name),
 337         .flags = GPBFieldRequired,
 338         .dataType = GPBDataTypeString,
 339       },
 340       {
 341         .name = "value",
 342         .dataTypeSpecific.className = NULL,
 343         .number = GtalkSetting_FieldNumber_Value,
 344         .hasIndex = 1,
 345         .offset = (uint32_t)offsetof(GtalkSetting__storage_, value),
 346         .flags = GPBFieldRequired,
 347         .dataType = GPBDataTypeString,
 348       },
 349     };
 350     GPBDescriptor *localDescriptor =
 351         [GPBDescriptor allocDescriptorForClass:[GtalkSetting class]
 352                                      rootClass:[GtalkGtalkCoreRoot class]
 353                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 354                                         fields:fields
 355                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 356                                    storageSize:sizeof(GtalkSetting__storage_)
 357                                          flags:GPBDescriptorInitializationFlag_None];
 358     NSAssert(descriptor == nil, @"Startup recursed!");
 359     descriptor = localDescriptor;
 360   }
 361   return descriptor;
 362 }
 363
 364 @end
 365
 366 #pragma mark - GtalkHeartbeatStat
 367
 368 @implementation GtalkHeartbeatStat
 369
 370 @dynamic hasIp, ip;
 371 @dynamic hasTimeout, timeout;
 372 @dynamic hasIntervalMs, intervalMs;
 373
 374 typedef struct GtalkHeartbeatStat__storage_ {
 375   uint32_t _has_storage_[1];
 376   int32_t intervalMs;
 377   NSString *ip;
 378 } GtalkHeartbeatStat__storage_;
 379
 380 // This method is threadsafe because it is initially called
 381 // in +initialize for each subclass.
 382 + (GPBDescriptor *)descriptor {
 383   static GPBDescriptor *descriptor = nil;
 384   if (!descriptor) {
 385     static GPBMessageFieldDescription fields[] = {
 386       {
 387         .name = "ip",
 388         .dataTypeSpecific.className = NULL,
 389         .number = GtalkHeartbeatStat_FieldNumber_Ip,
 390         .hasIndex = 0,
 391         .offset = (uint32_t)offsetof(GtalkHeartbeatStat__storage_, ip),
 392         .flags = GPBFieldRequired,
 393         .dataType = GPBDataTypeString,
 394       },
 395       {
 396         .name = "timeout",
 397         .dataTypeSpecific.className = NULL,
 398         .number = GtalkHeartbeatStat_FieldNumber_Timeout,
 399         .hasIndex = 1,
 400         .offset = 2,  // Stored in _has_storage_ to save space.
 401         .flags = GPBFieldRequired,
 402         .dataType = GPBDataTypeBool,
 403       },
 404       {
 405         .name = "intervalMs",
 406         .dataTypeSpecific.className = NULL,
 407         .number = GtalkHeartbeatStat_FieldNumber_IntervalMs,
 408         .hasIndex = 3,
 409         .offset = (uint32_t)offsetof(GtalkHeartbeatStat__storage_, intervalMs),
 410         .flags = GPBFieldRequired,
 411         .dataType = GPBDataTypeInt32,
 412       },
 413     };
 414     GPBDescriptor *localDescriptor =
 415         [GPBDescriptor allocDescriptorForClass:[GtalkHeartbeatStat class]
 416                                      rootClass:[GtalkGtalkCoreRoot class]
 417                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 418                                         fields:fields
 419                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 420                                    storageSize:sizeof(GtalkHeartbeatStat__storage_)
 421                                          flags:GPBDescriptorInitializationFlag_None];
 422     NSAssert(descriptor == nil, @"Startup recursed!");
 423     descriptor = localDescriptor;
 424   }
 425   return descriptor;
 426 }
 427
 428 @end
 429
 430 #pragma mark - GtalkHeartbeatConfig
 431
 432 @implementation GtalkHeartbeatConfig
 433
 434 @dynamic hasUploadStat, uploadStat;
 435 @dynamic hasIp, ip;
 436 @dynamic hasIntervalMs, intervalMs;
 437
 438 typedef struct GtalkHeartbeatConfig__storage_ {
 439   uint32_t _has_storage_[1];
 440   int32_t intervalMs;
 441   NSString *ip;
 442 } GtalkHeartbeatConfig__storage_;
 443
 444 // This method is threadsafe because it is initially called
 445 // in +initialize for each subclass.
 446 + (GPBDescriptor *)descriptor {
 447   static GPBDescriptor *descriptor = nil;
 448   if (!descriptor) {
 449     static GPBMessageFieldDescription fields[] = {
 450       {
 451         .name = "uploadStat",
 452         .dataTypeSpecific.className = NULL,
 453         .number = GtalkHeartbeatConfig_FieldNumber_UploadStat,
 454         .hasIndex = 0,
 455         .offset = 1,  // Stored in _has_storage_ to save space.
 456         .flags = GPBFieldOptional,
 457         .dataType = GPBDataTypeBool,
 458       },
 459       {
 460         .name = "ip",
 461         .dataTypeSpecific.className = NULL,
 462         .number = GtalkHeartbeatConfig_FieldNumber_Ip,
 463         .hasIndex = 2,
 464         .offset = (uint32_t)offsetof(GtalkHeartbeatConfig__storage_, ip),
 465         .flags = GPBFieldOptional,
 466         .dataType = GPBDataTypeString,
 467       },
 468       {
 469         .name = "intervalMs",
 470         .dataTypeSpecific.className = NULL,
 471         .number = GtalkHeartbeatConfig_FieldNumber_IntervalMs,
 472         .hasIndex = 3,
 473         .offset = (uint32_t)offsetof(GtalkHeartbeatConfig__storage_, intervalMs),
 474         .flags = GPBFieldOptional,
 475         .dataType = GPBDataTypeInt32,
 476       },
 477     };
 478     GPBDescriptor *localDescriptor =
 479         [GPBDescriptor allocDescriptorForClass:[GtalkHeartbeatConfig class]
 480                                      rootClass:[GtalkGtalkCoreRoot class]
 481                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 482                                         fields:fields
 483                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 484                                    storageSize:sizeof(GtalkHeartbeatConfig__storage_)
 485                                          flags:GPBDescriptorInitializationFlag_None];
 486     NSAssert(descriptor == nil, @"Startup recursed!");
 487     descriptor = localDescriptor;
 488   }
 489   return descriptor;
 490 }
 491
 492 @end
 493
 494 #pragma mark - GtalkLoginRequest
 495
 496 @implementation GtalkLoginRequest
 497
 498 @dynamic hasId_p, id_p;
 499 @dynamic hasDomain, domain;
 500 @dynamic hasUser, user;
 501 @dynamic hasResource, resource;
 502 @dynamic hasAuthToken, authToken;
 503 @dynamic hasDeviceId, deviceId;
 504 @dynamic hasLastRmqId, lastRmqId;
 505 @dynamic settingArray, settingArray_Count;
 506 @dynamic receivedPersistentIdArray, receivedPersistentIdArray_Count;
 507 @dynamic hasIncludeStreamIds, includeStreamIds;
 508 @dynamic hasHeartbeatStat, heartbeatStat;
 509 @dynamic hasUseRmq2, useRmq2;
 510 @dynamic hasAccountId, accountId;
 511 @dynamic hasAuthService, authService;
 512 @dynamic hasNetworkType, networkType;
 513 @dynamic hasStatus, status;
 514 @dynamic hasTokenVersionInfo, tokenVersionInfo;
 515 @dynamic hasCellTower, cellTower;
 516 @dynamic hasGcmStartTimeMs, gcmStartTimeMs;
 517 @dynamic clientEventArray, clientEventArray_Count;
 518 @dynamic hasOnFallback, onFallback;
 519 @dynamic hasNoPendingUpstream, noPendingUpstream;
 520 @dynamic hasReconnectRequestId, reconnectRequestId;
 521
 522 typedef struct GtalkLoginRequest__storage_ {
 523   uint32_t _has_storage_[1];
 524   GtalkLoginRequest_AuthService authService;
 525   int32_t networkType;
 526   int32_t reconnectRequestId;
 527   NSString *id_p;
 528   NSString *domain;
 529   NSString *user;
 530   NSString *resource;
 531   NSString *authToken;
 532   NSString *deviceId;
 533   NSMutableArray *settingArray;
 534   NSMutableArray *receivedPersistentIdArray;
 535   GtalkHeartbeatStat *heartbeatStat;
 536   NSString *tokenVersionInfo;
 537   GtalkCellTower *cellTower;
 538   NSMutableArray *clientEventArray;
 539   int64_t lastRmqId;
 540   int64_t accountId;
 541   int64_t status;
 542   uint64_t gcmStartTimeMs;
 543 } GtalkLoginRequest__storage_;
 544
 545 // This method is threadsafe because it is initially called
 546 // in +initialize for each subclass.
 547 + (GPBDescriptor *)descriptor {
 548   static GPBDescriptor *descriptor = nil;
 549   if (!descriptor) {
 550     static GPBMessageFieldDescription fields[] = {
 551       {
 552         .name = "id_p",
 553         .dataTypeSpecific.className = NULL,
 554         .number = GtalkLoginRequest_FieldNumber_Id_p,
 555         .hasIndex = 0,
 556         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, id_p),
 557         .flags = GPBFieldRequired,
 558         .dataType = GPBDataTypeString,
 559       },
 560       {
 561         .name = "domain",
 562         .dataTypeSpecific.className = NULL,
 563         .number = GtalkLoginRequest_FieldNumber_Domain,
 564         .hasIndex = 1,
 565         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, domain),
 566         .flags = GPBFieldRequired,
 567         .dataType = GPBDataTypeString,
 568       },
 569       {
 570         .name = "user",
 571         .dataTypeSpecific.className = NULL,
 572         .number = GtalkLoginRequest_FieldNumber_User,
 573         .hasIndex = 2,
 574         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, user),
 575         .flags = GPBFieldRequired,
 576         .dataType = GPBDataTypeString,
 577       },
 578       {
 579         .name = "resource",
 580         .dataTypeSpecific.className = NULL,
 581         .number = GtalkLoginRequest_FieldNumber_Resource,
 582         .hasIndex = 3,
 583         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, resource),
 584         .flags = GPBFieldRequired,
 585         .dataType = GPBDataTypeString,
 586       },
 587       {
 588         .name = "authToken",
 589         .dataTypeSpecific.className = NULL,
 590         .number = GtalkLoginRequest_FieldNumber_AuthToken,
 591         .hasIndex = 4,
 592         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, authToken),
 593         .flags = GPBFieldRequired,
 594         .dataType = GPBDataTypeString,
 595       },
 596       {
 597         .name = "deviceId",
 598         .dataTypeSpecific.className = NULL,
 599         .number = GtalkLoginRequest_FieldNumber_DeviceId,
 600         .hasIndex = 5,
 601         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, deviceId),
 602         .flags = GPBFieldOptional,
 603         .dataType = GPBDataTypeString,
 604       },
 605       {
 606         .name = "lastRmqId",
 607         .dataTypeSpecific.className = NULL,
 608         .number = GtalkLoginRequest_FieldNumber_LastRmqId,
 609         .hasIndex = 6,
 610         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, lastRmqId),
 611         .flags = GPBFieldOptional,
 612         .dataType = GPBDataTypeInt64,
 613       },
 614       {
 615         .name = "settingArray",
 616         .dataTypeSpecific.className = GPBStringifySymbol(GtalkSetting),
 617         .number = GtalkLoginRequest_FieldNumber_SettingArray,
 618         .hasIndex = GPBNoHasBit,
 619         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, settingArray),
 620         .flags = GPBFieldRepeated,
 621         .dataType = GPBDataTypeMessage,
 622       },
 623       {
 624         .name = "receivedPersistentIdArray",
 625         .dataTypeSpecific.className = NULL,
 626         .number = GtalkLoginRequest_FieldNumber_ReceivedPersistentIdArray,
 627         .hasIndex = GPBNoHasBit,
 628         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, receivedPersistentIdArray),
 629         .flags = GPBFieldRepeated,
 630         .dataType = GPBDataTypeString,
 631       },
 632       {
 633         .name = "includeStreamIds",
 634         .dataTypeSpecific.className = NULL,
 635         .number = GtalkLoginRequest_FieldNumber_IncludeStreamIds,
 636         .hasIndex = 7,
 637         .offset = 8,  // Stored in _has_storage_ to save space.
 638         .flags = GPBFieldOptional,
 639         .dataType = GPBDataTypeBool,
 640       },
 641       {
 642         .name = "heartbeatStat",
 643         .dataTypeSpecific.className = GPBStringifySymbol(GtalkHeartbeatStat),
 644         .number = GtalkLoginRequest_FieldNumber_HeartbeatStat,
 645         .hasIndex = 9,
 646         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, heartbeatStat),
 647         .flags = GPBFieldOptional,
 648         .dataType = GPBDataTypeMessage,
 649       },
 650       {
 651         .name = "useRmq2",
 652         .dataTypeSpecific.className = NULL,
 653         .number = GtalkLoginRequest_FieldNumber_UseRmq2,
 654         .hasIndex = 10,
 655         .offset = 11,  // Stored in _has_storage_ to save space.
 656         .flags = GPBFieldOptional,
 657         .dataType = GPBDataTypeBool,
 658       },
 659       {
 660         .name = "accountId",
 661         .dataTypeSpecific.className = NULL,
 662         .number = GtalkLoginRequest_FieldNumber_AccountId,
 663         .hasIndex = 12,
 664         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, accountId),
 665         .flags = GPBFieldOptional,
 666         .dataType = GPBDataTypeInt64,
 667       },
 668       {
 669         .name = "authService",
 670         .dataTypeSpecific.enumDescFunc = GtalkLoginRequest_AuthService_EnumDescriptor,
 671         .number = GtalkLoginRequest_FieldNumber_AuthService,
 672         .hasIndex = 13,
 673         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, authService),
 674         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
 675         .dataType = GPBDataTypeEnum,
 676       },
 677       {
 678         .name = "networkType",
 679         .dataTypeSpecific.className = NULL,
 680         .number = GtalkLoginRequest_FieldNumber_NetworkType,
 681         .hasIndex = 14,
 682         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, networkType),
 683         .flags = GPBFieldOptional,
 684         .dataType = GPBDataTypeInt32,
 685       },
 686       {
 687         .name = "status",
 688         .dataTypeSpecific.className = NULL,
 689         .number = GtalkLoginRequest_FieldNumber_Status,
 690         .hasIndex = 15,
 691         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, status),
 692         .flags = GPBFieldOptional,
 693         .dataType = GPBDataTypeInt64,
 694       },
 695       {
 696         .name = "tokenVersionInfo",
 697         .dataTypeSpecific.className = NULL,
 698         .number = GtalkLoginRequest_FieldNumber_TokenVersionInfo,
 699         .hasIndex = 16,
 700         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, tokenVersionInfo),
 701         .flags = GPBFieldOptional,
 702         .dataType = GPBDataTypeString,
 703       },
 704       {
 705         .name = "cellTower",
 706         .dataTypeSpecific.className = GPBStringifySymbol(GtalkCellTower),
 707         .number = GtalkLoginRequest_FieldNumber_CellTower,
 708         .hasIndex = 17,
 709         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, cellTower),
 710         .flags = GPBFieldOptional,
 711         .dataType = GPBDataTypeMessage,
 712       },
 713       {
 714         .name = "gcmStartTimeMs",
 715         .dataTypeSpecific.className = NULL,
 716         .number = GtalkLoginRequest_FieldNumber_GcmStartTimeMs,
 717         .hasIndex = 18,
 718         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, gcmStartTimeMs),
 719         .flags = GPBFieldOptional,
 720         .dataType = GPBDataTypeUInt64,
 721       },
 722       {
 723         .name = "clientEventArray",
 724         .dataTypeSpecific.className = GPBStringifySymbol(GtalkClientEvent),
 725         .number = GtalkLoginRequest_FieldNumber_ClientEventArray,
 726         .hasIndex = GPBNoHasBit,
 727         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, clientEventArray),
 728         .flags = GPBFieldRepeated,
 729         .dataType = GPBDataTypeMessage,
 730       },
 731       {
 732         .name = "onFallback",
 733         .dataTypeSpecific.className = NULL,
 734         .number = GtalkLoginRequest_FieldNumber_OnFallback,
 735         .hasIndex = 19,
 736         .offset = 20,  // Stored in _has_storage_ to save space.
 737         .flags = GPBFieldOptional,
 738         .dataType = GPBDataTypeBool,
 739       },
 740       {
 741         .name = "noPendingUpstream",
 742         .dataTypeSpecific.className = NULL,
 743         .number = GtalkLoginRequest_FieldNumber_NoPendingUpstream,
 744         .hasIndex = 21,
 745         .offset = 22,  // Stored in _has_storage_ to save space.
 746         .flags = GPBFieldOptional,
 747         .dataType = GPBDataTypeBool,
 748       },
 749       {
 750         .name = "reconnectRequestId",
 751         .dataTypeSpecific.className = NULL,
 752         .number = GtalkLoginRequest_FieldNumber_ReconnectRequestId,
 753         .hasIndex = 23,
 754         .offset = (uint32_t)offsetof(GtalkLoginRequest__storage_, reconnectRequestId),
 755         .flags = GPBFieldOptional,
 756         .dataType = GPBDataTypeInt32,
 757       },
 758     };
 759     GPBDescriptor *localDescriptor =
 760         [GPBDescriptor allocDescriptorForClass:[GtalkLoginRequest class]
 761                                      rootClass:[GtalkGtalkCoreRoot class]
 762                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 763                                         fields:fields
 764                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 765                                    storageSize:sizeof(GtalkLoginRequest__storage_)
 766                                          flags:GPBDescriptorInitializationFlag_None];
 767     NSAssert(descriptor == nil, @"Startup recursed!");
 768     descriptor = localDescriptor;
 769   }
 770   return descriptor;
 771 }
 772
 773 @end
 774
 775 #pragma mark - Enum GtalkLoginRequest_AuthService
 776
 777 GPBEnumDescriptor *GtalkLoginRequest_AuthService_EnumDescriptor(void) {
 778   static GPBEnumDescriptor *descriptor = NULL;
 779   if (!descriptor) {
 780     static const char *valueNames =
 781         "Mail\000AndroidCloudToDeviceMessage\000Android"
 782         "Id\000";
 783     static const int32_t values[] = {
 784         GtalkLoginRequest_AuthService_Mail,
 785         GtalkLoginRequest_AuthService_AndroidCloudToDeviceMessage,
 786         GtalkLoginRequest_AuthService_AndroidId,
 787     };
 788     GPBEnumDescriptor *worker =
 789         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkLoginRequest_AuthService)
 790                                        valueNames:valueNames
 791                                            values:values
 792                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
 793                                      enumVerifier:GtalkLoginRequest_AuthService_IsValidValue];
 794     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
 795       [worker release];
 796     }
 797   }
 798   return descriptor;
 799 }
 800
 801 BOOL GtalkLoginRequest_AuthService_IsValidValue(int32_t value__) {
 802   switch (value__) {
 803     case GtalkLoginRequest_AuthService_Mail:
 804     case GtalkLoginRequest_AuthService_AndroidCloudToDeviceMessage:
 805     case GtalkLoginRequest_AuthService_AndroidId:
 806       return YES;
 807     default:
 808       return NO;
 809   }
 810 }
 811
 812 #pragma mark - GtalkLoginResponse
 813
 814 @implementation GtalkLoginResponse
 815
 816 @dynamic hasId_p, id_p;
 817 @dynamic hasJid, jid;
 818 @dynamic hasError, error;
 819 @dynamic settingArray, settingArray_Count;
 820 @dynamic hasStreamId, streamId;
 821 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
 822 @dynamic hasHeartbeatConfig, heartbeatConfig;
 823 @dynamic hasServerTimestamp, serverTimestamp;
 824
 825 typedef struct GtalkLoginResponse__storage_ {
 826   uint32_t _has_storage_[1];
 827   int32_t streamId;
 828   int32_t lastStreamIdReceived;
 829   NSString *id_p;
 830   NSString *jid;
 831   GtalkErrorInfo *error;
 832   NSMutableArray *settingArray;
 833   GtalkHeartbeatConfig *heartbeatConfig;
 834   int64_t serverTimestamp;
 835 } GtalkLoginResponse__storage_;
 836
 837 // This method is threadsafe because it is initially called
 838 // in +initialize for each subclass.
 839 + (GPBDescriptor *)descriptor {
 840   static GPBDescriptor *descriptor = nil;
 841   if (!descriptor) {
 842     static GPBMessageFieldDescription fields[] = {
 843       {
 844         .name = "id_p",
 845         .dataTypeSpecific.className = NULL,
 846         .number = GtalkLoginResponse_FieldNumber_Id_p,
 847         .hasIndex = 0,
 848         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, id_p),
 849         .flags = GPBFieldRequired,
 850         .dataType = GPBDataTypeString,
 851       },
 852       {
 853         .name = "jid",
 854         .dataTypeSpecific.className = NULL,
 855         .number = GtalkLoginResponse_FieldNumber_Jid,
 856         .hasIndex = 1,
 857         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, jid),
 858         .flags = GPBFieldOptional,
 859         .dataType = GPBDataTypeString,
 860       },
 861       {
 862         .name = "error",
 863         .dataTypeSpecific.className = GPBStringifySymbol(GtalkErrorInfo),
 864         .number = GtalkLoginResponse_FieldNumber_Error,
 865         .hasIndex = 2,
 866         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, error),
 867         .flags = GPBFieldOptional,
 868         .dataType = GPBDataTypeMessage,
 869       },
 870       {
 871         .name = "settingArray",
 872         .dataTypeSpecific.className = GPBStringifySymbol(GtalkSetting),
 873         .number = GtalkLoginResponse_FieldNumber_SettingArray,
 874         .hasIndex = GPBNoHasBit,
 875         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, settingArray),
 876         .flags = GPBFieldRepeated,
 877         .dataType = GPBDataTypeMessage,
 878       },
 879       {
 880         .name = "streamId",
 881         .dataTypeSpecific.className = NULL,
 882         .number = GtalkLoginResponse_FieldNumber_StreamId,
 883         .hasIndex = 3,
 884         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, streamId),
 885         .flags = GPBFieldOptional,
 886         .dataType = GPBDataTypeInt32,
 887       },
 888       {
 889         .name = "lastStreamIdReceived",
 890         .dataTypeSpecific.className = NULL,
 891         .number = GtalkLoginResponse_FieldNumber_LastStreamIdReceived,
 892         .hasIndex = 4,
 893         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, lastStreamIdReceived),
 894         .flags = GPBFieldOptional,
 895         .dataType = GPBDataTypeInt32,
 896       },
 897       {
 898         .name = "heartbeatConfig",
 899         .dataTypeSpecific.className = GPBStringifySymbol(GtalkHeartbeatConfig),
 900         .number = GtalkLoginResponse_FieldNumber_HeartbeatConfig,
 901         .hasIndex = 5,
 902         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, heartbeatConfig),
 903         .flags = GPBFieldOptional,
 904         .dataType = GPBDataTypeMessage,
 905       },
 906       {
 907         .name = "serverTimestamp",
 908         .dataTypeSpecific.className = NULL,
 909         .number = GtalkLoginResponse_FieldNumber_ServerTimestamp,
 910         .hasIndex = 6,
 911         .offset = (uint32_t)offsetof(GtalkLoginResponse__storage_, serverTimestamp),
 912         .flags = GPBFieldOptional,
 913         .dataType = GPBDataTypeInt64,
 914       },
 915     };
 916     GPBDescriptor *localDescriptor =
 917         [GPBDescriptor allocDescriptorForClass:[GtalkLoginResponse class]
 918                                      rootClass:[GtalkGtalkCoreRoot class]
 919                                           file:GtalkGtalkCoreRoot_FileDescriptor()
 920                                         fields:fields
 921                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 922                                    storageSize:sizeof(GtalkLoginResponse__storage_)
 923                                          flags:GPBDescriptorInitializationFlag_None];
 924     NSAssert(descriptor == nil, @"Startup recursed!");
 925     descriptor = localDescriptor;
 926   }
 927   return descriptor;
 928 }
 929
 930 @end
 931
 932 #pragma mark - GtalkBindAccountRequest
 933
 934 @implementation GtalkBindAccountRequest
 935
 936 @dynamic hasId_p, id_p;
 937 @dynamic hasDomain, domain;
 938 @dynamic hasUser, user;
 939 @dynamic hasResource, resource;
 940 @dynamic hasAuthToken, authToken;
 941 @dynamic hasPersistentId, persistentId;
 942 @dynamic hasStreamId, streamId;
 943 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
 944 @dynamic hasAccountId, accountId;
 945
 946 typedef struct GtalkBindAccountRequest__storage_ {
 947   uint32_t _has_storage_[1];
 948   int32_t streamId;
 949   int32_t lastStreamIdReceived;
 950   NSString *id_p;
 951   NSString *domain;
 952   NSString *user;
 953   NSString *resource;
 954   NSString *authToken;
 955   NSString *persistentId;
 956   int64_t accountId;
 957 } GtalkBindAccountRequest__storage_;
 958
 959 // This method is threadsafe because it is initially called
 960 // in +initialize for each subclass.
 961 + (GPBDescriptor *)descriptor {
 962   static GPBDescriptor *descriptor = nil;
 963   if (!descriptor) {
 964     static GPBMessageFieldDescription fields[] = {
 965       {
 966         .name = "id_p",
 967         .dataTypeSpecific.className = NULL,
 968         .number = GtalkBindAccountRequest_FieldNumber_Id_p,
 969         .hasIndex = 0,
 970         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, id_p),
 971         .flags = GPBFieldRequired,
 972         .dataType = GPBDataTypeString,
 973       },
 974       {
 975         .name = "domain",
 976         .dataTypeSpecific.className = NULL,
 977         .number = GtalkBindAccountRequest_FieldNumber_Domain,
 978         .hasIndex = 1,
 979         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, domain),
 980         .flags = GPBFieldRequired,
 981         .dataType = GPBDataTypeString,
 982       },
 983       {
 984         .name = "user",
 985         .dataTypeSpecific.className = NULL,
 986         .number = GtalkBindAccountRequest_FieldNumber_User,
 987         .hasIndex = 2,
 988         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, user),
 989         .flags = GPBFieldRequired,
 990         .dataType = GPBDataTypeString,
 991       },
 992       {
 993         .name = "resource",
 994         .dataTypeSpecific.className = NULL,
 995         .number = GtalkBindAccountRequest_FieldNumber_Resource,
 996         .hasIndex = 3,
 997         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, resource),
 998         .flags = GPBFieldRequired,
 999         .dataType = GPBDataTypeString,
1000       },
1001       {
1002         .name = "authToken",
1003         .dataTypeSpecific.className = NULL,
1004         .number = GtalkBindAccountRequest_FieldNumber_AuthToken,
1005         .hasIndex = 4,
1006         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, authToken),
1007         .flags = GPBFieldRequired,
1008         .dataType = GPBDataTypeString,
1009       },
1010       {
1011         .name = "persistentId",
1012         .dataTypeSpecific.className = NULL,
1013         .number = GtalkBindAccountRequest_FieldNumber_PersistentId,
1014         .hasIndex = 5,
1015         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, persistentId),
1016         .flags = GPBFieldOptional,
1017         .dataType = GPBDataTypeString,
1018       },
1019       {
1020         .name = "streamId",
1021         .dataTypeSpecific.className = NULL,
1022         .number = GtalkBindAccountRequest_FieldNumber_StreamId,
1023         .hasIndex = 6,
1024         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, streamId),
1025         .flags = GPBFieldOptional,
1026         .dataType = GPBDataTypeInt32,
1027       },
1028       {
1029         .name = "lastStreamIdReceived",
1030         .dataTypeSpecific.className = NULL,
1031         .number = GtalkBindAccountRequest_FieldNumber_LastStreamIdReceived,
1032         .hasIndex = 7,
1033         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, lastStreamIdReceived),
1034         .flags = GPBFieldOptional,
1035         .dataType = GPBDataTypeInt32,
1036       },
1037       {
1038         .name = "accountId",
1039         .dataTypeSpecific.className = NULL,
1040         .number = GtalkBindAccountRequest_FieldNumber_AccountId,
1041         .hasIndex = 8,
1042         .offset = (uint32_t)offsetof(GtalkBindAccountRequest__storage_, accountId),
1043         .flags = GPBFieldOptional,
1044         .dataType = GPBDataTypeInt64,
1045       },
1046     };
1047     GPBDescriptor *localDescriptor =
1048         [GPBDescriptor allocDescriptorForClass:[GtalkBindAccountRequest class]
1049                                      rootClass:[GtalkGtalkCoreRoot class]
1050                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1051                                         fields:fields
1052                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1053                                    storageSize:sizeof(GtalkBindAccountRequest__storage_)
1054                                          flags:GPBDescriptorInitializationFlag_None];
1055     NSAssert(descriptor == nil, @"Startup recursed!");
1056     descriptor = localDescriptor;
1057   }
1058   return descriptor;
1059 }
1060
1061 @end
1062
1063 #pragma mark - GtalkBindAccountResponse
1064
1065 @implementation GtalkBindAccountResponse
1066
1067 @dynamic hasId_p, id_p;
1068 @dynamic hasJid, jid;
1069 @dynamic hasError, error;
1070 @dynamic hasStreamId, streamId;
1071 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
1072
1073 typedef struct GtalkBindAccountResponse__storage_ {
1074   uint32_t _has_storage_[1];
1075   int32_t streamId;
1076   int32_t lastStreamIdReceived;
1077   NSString *id_p;
1078   NSString *jid;
1079   GtalkErrorInfo *error;
1080 } GtalkBindAccountResponse__storage_;
1081
1082 // This method is threadsafe because it is initially called
1083 // in +initialize for each subclass.
1084 + (GPBDescriptor *)descriptor {
1085   static GPBDescriptor *descriptor = nil;
1086   if (!descriptor) {
1087     static GPBMessageFieldDescription fields[] = {
1088       {
1089         .name = "id_p",
1090         .dataTypeSpecific.className = NULL,
1091         .number = GtalkBindAccountResponse_FieldNumber_Id_p,
1092         .hasIndex = 0,
1093         .offset = (uint32_t)offsetof(GtalkBindAccountResponse__storage_, id_p),
1094         .flags = GPBFieldRequired,
1095         .dataType = GPBDataTypeString,
1096       },
1097       {
1098         .name = "jid",
1099         .dataTypeSpecific.className = NULL,
1100         .number = GtalkBindAccountResponse_FieldNumber_Jid,
1101         .hasIndex = 1,
1102         .offset = (uint32_t)offsetof(GtalkBindAccountResponse__storage_, jid),
1103         .flags = GPBFieldOptional,
1104         .dataType = GPBDataTypeString,
1105       },
1106       {
1107         .name = "error",
1108         .dataTypeSpecific.className = GPBStringifySymbol(GtalkErrorInfo),
1109         .number = GtalkBindAccountResponse_FieldNumber_Error,
1110         .hasIndex = 2,
1111         .offset = (uint32_t)offsetof(GtalkBindAccountResponse__storage_, error),
1112         .flags = GPBFieldOptional,
1113         .dataType = GPBDataTypeMessage,
1114       },
1115       {
1116         .name = "streamId",
1117         .dataTypeSpecific.className = NULL,
1118         .number = GtalkBindAccountResponse_FieldNumber_StreamId,
1119         .hasIndex = 3,
1120         .offset = (uint32_t)offsetof(GtalkBindAccountResponse__storage_, streamId),
1121         .flags = GPBFieldOptional,
1122         .dataType = GPBDataTypeInt32,
1123       },
1124       {
1125         .name = "lastStreamIdReceived",
1126         .dataTypeSpecific.className = NULL,
1127         .number = GtalkBindAccountResponse_FieldNumber_LastStreamIdReceived,
1128         .hasIndex = 4,
1129         .offset = (uint32_t)offsetof(GtalkBindAccountResponse__storage_, lastStreamIdReceived),
1130         .flags = GPBFieldOptional,
1131         .dataType = GPBDataTypeInt32,
1132       },
1133     };
1134     GPBDescriptor *localDescriptor =
1135         [GPBDescriptor allocDescriptorForClass:[GtalkBindAccountResponse class]
1136                                      rootClass:[GtalkGtalkCoreRoot class]
1137                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1138                                         fields:fields
1139                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1140                                    storageSize:sizeof(GtalkBindAccountResponse__storage_)
1141                                          flags:GPBDescriptorInitializationFlag_None];
1142     NSAssert(descriptor == nil, @"Startup recursed!");
1143     descriptor = localDescriptor;
1144   }
1145   return descriptor;
1146 }
1147
1148 @end
1149
1150 #pragma mark - GtalkStreamErrorStanza
1151
1152 @implementation GtalkStreamErrorStanza
1153
1154 @dynamic hasType, type;
1155 @dynamic hasText, text;
1156
1157 typedef struct GtalkStreamErrorStanza__storage_ {
1158   uint32_t _has_storage_[1];
1159   NSString *type;
1160   NSString *text;
1161 } GtalkStreamErrorStanza__storage_;
1162
1163 // This method is threadsafe because it is initially called
1164 // in +initialize for each subclass.
1165 + (GPBDescriptor *)descriptor {
1166   static GPBDescriptor *descriptor = nil;
1167   if (!descriptor) {
1168     static GPBMessageFieldDescription fields[] = {
1169       {
1170         .name = "type",
1171         .dataTypeSpecific.className = NULL,
1172         .number = GtalkStreamErrorStanza_FieldNumber_Type,
1173         .hasIndex = 0,
1174         .offset = (uint32_t)offsetof(GtalkStreamErrorStanza__storage_, type),
1175         .flags = GPBFieldRequired,
1176         .dataType = GPBDataTypeString,
1177       },
1178       {
1179         .name = "text",
1180         .dataTypeSpecific.className = NULL,
1181         .number = GtalkStreamErrorStanza_FieldNumber_Text,
1182         .hasIndex = 1,
1183         .offset = (uint32_t)offsetof(GtalkStreamErrorStanza__storage_, text),
1184         .flags = GPBFieldOptional,
1185         .dataType = GPBDataTypeString,
1186       },
1187     };
1188     GPBDescriptor *localDescriptor =
1189         [GPBDescriptor allocDescriptorForClass:[GtalkStreamErrorStanza class]
1190                                      rootClass:[GtalkGtalkCoreRoot class]
1191                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1192                                         fields:fields
1193                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1194                                    storageSize:sizeof(GtalkStreamErrorStanza__storage_)
1195                                          flags:GPBDescriptorInitializationFlag_None];
1196     NSAssert(descriptor == nil, @"Startup recursed!");
1197     descriptor = localDescriptor;
1198   }
1199   return descriptor;
1200 }
1201
1202 @end
1203
1204 #pragma mark - GtalkClose
1205
1206 @implementation GtalkClose
1207
1208
1209 typedef struct GtalkClose__storage_ {
1210   uint32_t _has_storage_[1];
1211 } GtalkClose__storage_;
1212
1213 // This method is threadsafe because it is initially called
1214 // in +initialize for each subclass.
1215 + (GPBDescriptor *)descriptor {
1216   static GPBDescriptor *descriptor = nil;
1217   if (!descriptor) {
1218     GPBDescriptor *localDescriptor =
1219         [GPBDescriptor allocDescriptorForClass:[GtalkClose class]
1220                                      rootClass:[GtalkGtalkCoreRoot class]
1221                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1222                                         fields:NULL
1223                                     fieldCount:0
1224                                    storageSize:sizeof(GtalkClose__storage_)
1225                                          flags:GPBDescriptorInitializationFlag_None];
1226     NSAssert(descriptor == nil, @"Startup recursed!");
1227     descriptor = localDescriptor;
1228   }
1229   return descriptor;
1230 }
1231
1232 @end
1233
1234 #pragma mark - GtalkExtension
1235
1236 @implementation GtalkExtension
1237
1238 @dynamic hasId_p, id_p;
1239 @dynamic hasData_p, data_p;
1240
1241 typedef struct GtalkExtension__storage_ {
1242   uint32_t _has_storage_[1];
1243   int32_t id_p;
1244   NSString *data_p;
1245 } GtalkExtension__storage_;
1246
1247 // This method is threadsafe because it is initially called
1248 // in +initialize for each subclass.
1249 + (GPBDescriptor *)descriptor {
1250   static GPBDescriptor *descriptor = nil;
1251   if (!descriptor) {
1252     static GPBMessageFieldDescription fields[] = {
1253       {
1254         .name = "id_p",
1255         .dataTypeSpecific.className = NULL,
1256         .number = GtalkExtension_FieldNumber_Id_p,
1257         .hasIndex = 0,
1258         .offset = (uint32_t)offsetof(GtalkExtension__storage_, id_p),
1259         .flags = GPBFieldRequired,
1260         .dataType = GPBDataTypeInt32,
1261       },
1262       {
1263         .name = "data_p",
1264         .dataTypeSpecific.className = NULL,
1265         .number = GtalkExtension_FieldNumber_Data_p,
1266         .hasIndex = 1,
1267         .offset = (uint32_t)offsetof(GtalkExtension__storage_, data_p),
1268         .flags = GPBFieldRequired,
1269         .dataType = GPBDataTypeString,
1270       },
1271     };
1272     GPBDescriptor *localDescriptor =
1273         [GPBDescriptor allocDescriptorForClass:[GtalkExtension class]
1274                                      rootClass:[GtalkGtalkCoreRoot class]
1275                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1276                                         fields:fields
1277                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1278                                    storageSize:sizeof(GtalkExtension__storage_)
1279                                          flags:GPBDescriptorInitializationFlag_None];
1280     NSAssert(descriptor == nil, @"Startup recursed!");
1281     descriptor = localDescriptor;
1282   }
1283   return descriptor;
1284 }
1285
1286 @end
1287
1288 #pragma mark - GtalkMessageStanza
1289
1290 @implementation GtalkMessageStanza
1291
1292 @dynamic hasRmqId, rmqId;
1293 @dynamic hasType, type;
1294 @dynamic hasId_p, id_p;
1295 @dynamic hasFrom, from;
1296 @dynamic hasTo, to;
1297 @dynamic hasSubject, subject;
1298 @dynamic hasBody, body;
1299 @dynamic hasThread, thread;
1300 @dynamic hasError, error;
1301 @dynamic extensionArray, extensionArray_Count;
1302 @dynamic hasNosave, nosave;
1303 @dynamic hasTimestamp, timestamp;
1304 @dynamic hasPersistentId, persistentId;
1305 @dynamic hasStreamId, streamId;
1306 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
1307 @dynamic hasRead, read;
1308 @dynamic hasAccountId, accountId;
1309
1310 typedef struct GtalkMessageStanza__storage_ {
1311   uint32_t _has_storage_[1];
1312   GtalkMessageStanza_MessageType type;
1313   int32_t streamId;
1314   int32_t lastStreamIdReceived;
1315   NSString *id_p;
1316   NSString *from;
1317   NSString *to;
1318   NSString *subject;
1319   NSString *body;
1320   NSString *thread;
1321   GtalkErrorInfo *error;
1322   NSMutableArray *extensionArray;
1323   NSString *persistentId;
1324   int64_t rmqId;
1325   int64_t timestamp;
1326   int64_t accountId;
1327 } GtalkMessageStanza__storage_;
1328
1329 // This method is threadsafe because it is initially called
1330 // in +initialize for each subclass.
1331 + (GPBDescriptor *)descriptor {
1332   static GPBDescriptor *descriptor = nil;
1333   if (!descriptor) {
1334     static GPBMessageFieldDescription fields[] = {
1335       {
1336         .name = "rmqId",
1337         .dataTypeSpecific.className = NULL,
1338         .number = GtalkMessageStanza_FieldNumber_RmqId,
1339         .hasIndex = 0,
1340         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, rmqId),
1341         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
1342         .dataType = GPBDataTypeInt64,
1343       },
1344       {
1345         .name = "type",
1346         .dataTypeSpecific.enumDescFunc = GtalkMessageStanza_MessageType_EnumDescriptor,
1347         .number = GtalkMessageStanza_FieldNumber_Type,
1348         .hasIndex = 1,
1349         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, type),
1350         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
1351         .dataType = GPBDataTypeEnum,
1352       },
1353       {
1354         .name = "id_p",
1355         .dataTypeSpecific.className = NULL,
1356         .number = GtalkMessageStanza_FieldNumber_Id_p,
1357         .hasIndex = 2,
1358         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, id_p),
1359         .flags = GPBFieldOptional,
1360         .dataType = GPBDataTypeString,
1361       },
1362       {
1363         .name = "from",
1364         .dataTypeSpecific.className = NULL,
1365         .number = GtalkMessageStanza_FieldNumber_From,
1366         .hasIndex = 3,
1367         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, from),
1368         .flags = GPBFieldOptional,
1369         .dataType = GPBDataTypeString,
1370       },
1371       {
1372         .name = "to",
1373         .dataTypeSpecific.className = NULL,
1374         .number = GtalkMessageStanza_FieldNumber_To,
1375         .hasIndex = 4,
1376         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, to),
1377         .flags = GPBFieldOptional,
1378         .dataType = GPBDataTypeString,
1379       },
1380       {
1381         .name = "subject",
1382         .dataTypeSpecific.className = NULL,
1383         .number = GtalkMessageStanza_FieldNumber_Subject,
1384         .hasIndex = 5,
1385         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, subject),
1386         .flags = GPBFieldOptional,
1387         .dataType = GPBDataTypeString,
1388       },
1389       {
1390         .name = "body",
1391         .dataTypeSpecific.className = NULL,
1392         .number = GtalkMessageStanza_FieldNumber_Body,
1393         .hasIndex = 6,
1394         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, body),
1395         .flags = GPBFieldOptional,
1396         .dataType = GPBDataTypeString,
1397       },
1398       {
1399         .name = "thread",
1400         .dataTypeSpecific.className = NULL,
1401         .number = GtalkMessageStanza_FieldNumber_Thread,
1402         .hasIndex = 7,
1403         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, thread),
1404         .flags = GPBFieldOptional,
1405         .dataType = GPBDataTypeString,
1406       },
1407       {
1408         .name = "error",
1409         .dataTypeSpecific.className = GPBStringifySymbol(GtalkErrorInfo),
1410         .number = GtalkMessageStanza_FieldNumber_Error,
1411         .hasIndex = 8,
1412         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, error),
1413         .flags = GPBFieldOptional,
1414         .dataType = GPBDataTypeMessage,
1415       },
1416       {
1417         .name = "extensionArray",
1418         .dataTypeSpecific.className = GPBStringifySymbol(GtalkExtension),
1419         .number = GtalkMessageStanza_FieldNumber_ExtensionArray,
1420         .hasIndex = GPBNoHasBit,
1421         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, extensionArray),
1422         .flags = GPBFieldRepeated,
1423         .dataType = GPBDataTypeMessage,
1424       },
1425       {
1426         .name = "nosave",
1427         .dataTypeSpecific.className = NULL,
1428         .number = GtalkMessageStanza_FieldNumber_Nosave,
1429         .hasIndex = 9,
1430         .offset = 10,  // Stored in _has_storage_ to save space.
1431         .flags = GPBFieldOptional,
1432         .dataType = GPBDataTypeBool,
1433       },
1434       {
1435         .name = "timestamp",
1436         .dataTypeSpecific.className = NULL,
1437         .number = GtalkMessageStanza_FieldNumber_Timestamp,
1438         .hasIndex = 11,
1439         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, timestamp),
1440         .flags = GPBFieldOptional,
1441         .dataType = GPBDataTypeInt64,
1442       },
1443       {
1444         .name = "persistentId",
1445         .dataTypeSpecific.className = NULL,
1446         .number = GtalkMessageStanza_FieldNumber_PersistentId,
1447         .hasIndex = 12,
1448         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, persistentId),
1449         .flags = GPBFieldOptional,
1450         .dataType = GPBDataTypeString,
1451       },
1452       {
1453         .name = "streamId",
1454         .dataTypeSpecific.className = NULL,
1455         .number = GtalkMessageStanza_FieldNumber_StreamId,
1456         .hasIndex = 13,
1457         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, streamId),
1458         .flags = GPBFieldOptional,
1459         .dataType = GPBDataTypeInt32,
1460       },
1461       {
1462         .name = "lastStreamIdReceived",
1463         .dataTypeSpecific.className = NULL,
1464         .number = GtalkMessageStanza_FieldNumber_LastStreamIdReceived,
1465         .hasIndex = 14,
1466         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, lastStreamIdReceived),
1467         .flags = GPBFieldOptional,
1468         .dataType = GPBDataTypeInt32,
1469       },
1470       {
1471         .name = "read",
1472         .dataTypeSpecific.className = NULL,
1473         .number = GtalkMessageStanza_FieldNumber_Read,
1474         .hasIndex = 15,
1475         .offset = 16,  // Stored in _has_storage_ to save space.
1476         .flags = GPBFieldOptional,
1477         .dataType = GPBDataTypeBool,
1478       },
1479       {
1480         .name = "accountId",
1481         .dataTypeSpecific.className = NULL,
1482         .number = GtalkMessageStanza_FieldNumber_AccountId,
1483         .hasIndex = 17,
1484         .offset = (uint32_t)offsetof(GtalkMessageStanza__storage_, accountId),
1485         .flags = GPBFieldOptional,
1486         .dataType = GPBDataTypeInt64,
1487       },
1488     };
1489     GPBDescriptor *localDescriptor =
1490         [GPBDescriptor allocDescriptorForClass:[GtalkMessageStanza class]
1491                                      rootClass:[GtalkGtalkCoreRoot class]
1492                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1493                                         fields:fields
1494                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1495                                    storageSize:sizeof(GtalkMessageStanza__storage_)
1496                                          flags:GPBDescriptorInitializationFlag_None];
1497 #if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
1498     static const char *extraTextFormatInfo =
1499         "\001\001\005\000";
1500     [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
1501 #endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
1502     NSAssert(descriptor == nil, @"Startup recursed!");
1503     descriptor = localDescriptor;
1504   }
1505   return descriptor;
1506 }
1507
1508 @end
1509
1510 #pragma mark - Enum GtalkMessageStanza_MessageType
1511
1512 GPBEnumDescriptor *GtalkMessageStanza_MessageType_EnumDescriptor(void) {
1513   static GPBEnumDescriptor *descriptor = NULL;
1514   if (!descriptor) {
1515     static const char *valueNames =
1516         "Normal\000Chat\000Groupchat\000Headline\000Error\000";
1517     static const int32_t values[] = {
1518         GtalkMessageStanza_MessageType_Normal,
1519         GtalkMessageStanza_MessageType_Chat,
1520         GtalkMessageStanza_MessageType_Groupchat,
1521         GtalkMessageStanza_MessageType_Headline,
1522         GtalkMessageStanza_MessageType_Error,
1523     };
1524     GPBEnumDescriptor *worker =
1525         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkMessageStanza_MessageType)
1526                                        valueNames:valueNames
1527                                            values:values
1528                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
1529                                      enumVerifier:GtalkMessageStanza_MessageType_IsValidValue];
1530     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
1531       [worker release];
1532     }
1533   }
1534   return descriptor;
1535 }
1536
1537 BOOL GtalkMessageStanza_MessageType_IsValidValue(int32_t value__) {
1538   switch (value__) {
1539     case GtalkMessageStanza_MessageType_Normal:
1540     case GtalkMessageStanza_MessageType_Chat:
1541     case GtalkMessageStanza_MessageType_Groupchat:
1542     case GtalkMessageStanza_MessageType_Headline:
1543     case GtalkMessageStanza_MessageType_Error:
1544       return YES;
1545     default:
1546       return NO;
1547   }
1548 }
1549
1550 #pragma mark - GtalkPresenceStanza
1551
1552 @implementation GtalkPresenceStanza
1553
1554 @dynamic hasRmqId, rmqId;
1555 @dynamic hasType, type;
1556 @dynamic hasId_p, id_p;
1557 @dynamic hasFrom, from;
1558 @dynamic hasTo, to;
1559 @dynamic hasShow, show;
1560 @dynamic hasStatus, status;
1561 @dynamic hasPriority, priority;
1562 @dynamic hasError, error;
1563 @dynamic extensionArray, extensionArray_Count;
1564 @dynamic hasClient, client;
1565 @dynamic hasAvatarHash, avatarHash;
1566 @dynamic hasPersistentId, persistentId;
1567 @dynamic hasStreamId, streamId;
1568 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
1569 @dynamic hasCapabilitiesFlags, capabilitiesFlags;
1570 @dynamic hasAccountId, accountId;
1571
1572 typedef struct GtalkPresenceStanza__storage_ {
1573   uint32_t _has_storage_[1];
1574   GtalkPresenceStanza_PresenceType type;
1575   GtalkPresenceStanza_ShowType show;
1576   int32_t priority;
1577   GtalkPresenceStanza_ClientType client;
1578   int32_t streamId;
1579   int32_t lastStreamIdReceived;
1580   int32_t capabilitiesFlags;
1581   NSString *id_p;
1582   NSString *from;
1583   NSString *to;
1584   NSString *status;
1585   GtalkErrorInfo *error;
1586   NSMutableArray *extensionArray;
1587   NSString *avatarHash;
1588   NSString *persistentId;
1589   int64_t rmqId;
1590   int64_t accountId;
1591 } GtalkPresenceStanza__storage_;
1592
1593 // This method is threadsafe because it is initially called
1594 // in +initialize for each subclass.
1595 + (GPBDescriptor *)descriptor {
1596   static GPBDescriptor *descriptor = nil;
1597   if (!descriptor) {
1598     static GPBMessageFieldDescription fields[] = {
1599       {
1600         .name = "rmqId",
1601         .dataTypeSpecific.className = NULL,
1602         .number = GtalkPresenceStanza_FieldNumber_RmqId,
1603         .hasIndex = 0,
1604         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, rmqId),
1605         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
1606         .dataType = GPBDataTypeInt64,
1607       },
1608       {
1609         .name = "type",
1610         .dataTypeSpecific.enumDescFunc = GtalkPresenceStanza_PresenceType_EnumDescriptor,
1611         .number = GtalkPresenceStanza_FieldNumber_Type,
1612         .hasIndex = 1,
1613         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, type),
1614         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
1615         .dataType = GPBDataTypeEnum,
1616       },
1617       {
1618         .name = "id_p",
1619         .dataTypeSpecific.className = NULL,
1620         .number = GtalkPresenceStanza_FieldNumber_Id_p,
1621         .hasIndex = 2,
1622         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, id_p),
1623         .flags = GPBFieldOptional,
1624         .dataType = GPBDataTypeString,
1625       },
1626       {
1627         .name = "from",
1628         .dataTypeSpecific.className = NULL,
1629         .number = GtalkPresenceStanza_FieldNumber_From,
1630         .hasIndex = 3,
1631         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, from),
1632         .flags = GPBFieldOptional,
1633         .dataType = GPBDataTypeString,
1634       },
1635       {
1636         .name = "to",
1637         .dataTypeSpecific.className = NULL,
1638         .number = GtalkPresenceStanza_FieldNumber_To,
1639         .hasIndex = 4,
1640         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, to),
1641         .flags = GPBFieldOptional,
1642         .dataType = GPBDataTypeString,
1643       },
1644       {
1645         .name = "show",
1646         .dataTypeSpecific.enumDescFunc = GtalkPresenceStanza_ShowType_EnumDescriptor,
1647         .number = GtalkPresenceStanza_FieldNumber_Show,
1648         .hasIndex = 5,
1649         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, show),
1650         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
1651         .dataType = GPBDataTypeEnum,
1652       },
1653       {
1654         .name = "status",
1655         .dataTypeSpecific.className = NULL,
1656         .number = GtalkPresenceStanza_FieldNumber_Status,
1657         .hasIndex = 6,
1658         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, status),
1659         .flags = GPBFieldOptional,
1660         .dataType = GPBDataTypeString,
1661       },
1662       {
1663         .name = "priority",
1664         .dataTypeSpecific.className = NULL,
1665         .number = GtalkPresenceStanza_FieldNumber_Priority,
1666         .hasIndex = 7,
1667         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, priority),
1668         .flags = GPBFieldOptional,
1669         .dataType = GPBDataTypeInt32,
1670       },
1671       {
1672         .name = "error",
1673         .dataTypeSpecific.className = GPBStringifySymbol(GtalkErrorInfo),
1674         .number = GtalkPresenceStanza_FieldNumber_Error,
1675         .hasIndex = 8,
1676         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, error),
1677         .flags = GPBFieldOptional,
1678         .dataType = GPBDataTypeMessage,
1679       },
1680       {
1681         .name = "extensionArray",
1682         .dataTypeSpecific.className = GPBStringifySymbol(GtalkExtension),
1683         .number = GtalkPresenceStanza_FieldNumber_ExtensionArray,
1684         .hasIndex = GPBNoHasBit,
1685         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, extensionArray),
1686         .flags = GPBFieldRepeated,
1687         .dataType = GPBDataTypeMessage,
1688       },
1689       {
1690         .name = "client",
1691         .dataTypeSpecific.enumDescFunc = GtalkPresenceStanza_ClientType_EnumDescriptor,
1692         .number = GtalkPresenceStanza_FieldNumber_Client,
1693         .hasIndex = 9,
1694         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, client),
1695         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
1696         .dataType = GPBDataTypeEnum,
1697       },
1698       {
1699         .name = "avatarHash",
1700         .dataTypeSpecific.className = NULL,
1701         .number = GtalkPresenceStanza_FieldNumber_AvatarHash,
1702         .hasIndex = 10,
1703         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, avatarHash),
1704         .flags = GPBFieldOptional,
1705         .dataType = GPBDataTypeString,
1706       },
1707       {
1708         .name = "persistentId",
1709         .dataTypeSpecific.className = NULL,
1710         .number = GtalkPresenceStanza_FieldNumber_PersistentId,
1711         .hasIndex = 11,
1712         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, persistentId),
1713         .flags = GPBFieldOptional,
1714         .dataType = GPBDataTypeString,
1715       },
1716       {
1717         .name = "streamId",
1718         .dataTypeSpecific.className = NULL,
1719         .number = GtalkPresenceStanza_FieldNumber_StreamId,
1720         .hasIndex = 12,
1721         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, streamId),
1722         .flags = GPBFieldOptional,
1723         .dataType = GPBDataTypeInt32,
1724       },
1725       {
1726         .name = "lastStreamIdReceived",
1727         .dataTypeSpecific.className = NULL,
1728         .number = GtalkPresenceStanza_FieldNumber_LastStreamIdReceived,
1729         .hasIndex = 13,
1730         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, lastStreamIdReceived),
1731         .flags = GPBFieldOptional,
1732         .dataType = GPBDataTypeInt32,
1733       },
1734       {
1735         .name = "capabilitiesFlags",
1736         .dataTypeSpecific.className = NULL,
1737         .number = GtalkPresenceStanza_FieldNumber_CapabilitiesFlags,
1738         .hasIndex = 14,
1739         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, capabilitiesFlags),
1740         .flags = GPBFieldOptional,
1741         .dataType = GPBDataTypeInt32,
1742       },
1743       {
1744         .name = "accountId",
1745         .dataTypeSpecific.className = NULL,
1746         .number = GtalkPresenceStanza_FieldNumber_AccountId,
1747         .hasIndex = 15,
1748         .offset = (uint32_t)offsetof(GtalkPresenceStanza__storage_, accountId),
1749         .flags = GPBFieldOptional,
1750         .dataType = GPBDataTypeInt64,
1751       },
1752     };
1753     GPBDescriptor *localDescriptor =
1754         [GPBDescriptor allocDescriptorForClass:[GtalkPresenceStanza class]
1755                                      rootClass:[GtalkGtalkCoreRoot class]
1756                                           file:GtalkGtalkCoreRoot_FileDescriptor()
1757                                         fields:fields
1758                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
1759                                    storageSize:sizeof(GtalkPresenceStanza__storage_)
1760                                          flags:GPBDescriptorInitializationFlag_None];
1761 #if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
1762     static const char *extraTextFormatInfo =
1763         "\001\001\005\000";
1764     [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
1765 #endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
1766     NSAssert(descriptor == nil, @"Startup recursed!");
1767     descriptor = localDescriptor;
1768   }
1769   return descriptor;
1770 }
1771
1772 @end
1773
1774 #pragma mark - Enum GtalkPresenceStanza_PresenceType
1775
1776 GPBEnumDescriptor *GtalkPresenceStanza_PresenceType_EnumDescriptor(void) {
1777   static GPBEnumDescriptor *descriptor = NULL;
1778   if (!descriptor) {
1779     static const char *valueNames =
1780         "Unavailable\000Subscribe\000Subscribed\000Unsubsc"
1781         "ribe\000Unsubscribed\000Probe\000Error\000";
1782     static const int32_t values[] = {
1783         GtalkPresenceStanza_PresenceType_Unavailable,
1784         GtalkPresenceStanza_PresenceType_Subscribe,
1785         GtalkPresenceStanza_PresenceType_Subscribed,
1786         GtalkPresenceStanza_PresenceType_Unsubscribe,
1787         GtalkPresenceStanza_PresenceType_Unsubscribed,
1788         GtalkPresenceStanza_PresenceType_Probe,
1789         GtalkPresenceStanza_PresenceType_Error,
1790     };
1791     GPBEnumDescriptor *worker =
1792         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkPresenceStanza_PresenceType)
1793                                        valueNames:valueNames
1794                                            values:values
1795                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
1796                                      enumVerifier:GtalkPresenceStanza_PresenceType_IsValidValue];
1797     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
1798       [worker release];
1799     }
1800   }
1801   return descriptor;
1802 }
1803
1804 BOOL GtalkPresenceStanza_PresenceType_IsValidValue(int32_t value__) {
1805   switch (value__) {
1806     case GtalkPresenceStanza_PresenceType_Unavailable:
1807     case GtalkPresenceStanza_PresenceType_Subscribe:
1808     case GtalkPresenceStanza_PresenceType_Subscribed:
1809     case GtalkPresenceStanza_PresenceType_Unsubscribe:
1810     case GtalkPresenceStanza_PresenceType_Unsubscribed:
1811     case GtalkPresenceStanza_PresenceType_Probe:
1812     case GtalkPresenceStanza_PresenceType_Error:
1813       return YES;
1814     default:
1815       return NO;
1816   }
1817 }
1818
1819 #pragma mark - Enum GtalkPresenceStanza_ShowType
1820
1821 GPBEnumDescriptor *GtalkPresenceStanza_ShowType_EnumDescriptor(void) {
1822   static GPBEnumDescriptor *descriptor = NULL;
1823   if (!descriptor) {
1824     static const char *valueNames =
1825         "Away\000Chat\000Dnd\000Xa\000";
1826     static const int32_t values[] = {
1827         GtalkPresenceStanza_ShowType_Away,
1828         GtalkPresenceStanza_ShowType_Chat,
1829         GtalkPresenceStanza_ShowType_Dnd,
1830         GtalkPresenceStanza_ShowType_Xa,
1831     };
1832     GPBEnumDescriptor *worker =
1833         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkPresenceStanza_ShowType)
1834                                        valueNames:valueNames
1835                                            values:values
1836                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
1837                                      enumVerifier:GtalkPresenceStanza_ShowType_IsValidValue];
1838     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
1839       [worker release];
1840     }
1841   }
1842   return descriptor;
1843 }
1844
1845 BOOL GtalkPresenceStanza_ShowType_IsValidValue(int32_t value__) {
1846   switch (value__) {
1847     case GtalkPresenceStanza_ShowType_Away:
1848     case GtalkPresenceStanza_ShowType_Chat:
1849     case GtalkPresenceStanza_ShowType_Dnd:
1850     case GtalkPresenceStanza_ShowType_Xa:
1851       return YES;
1852     default:
1853       return NO;
1854   }
1855 }
1856
1857 #pragma mark - Enum GtalkPresenceStanza_ClientType
1858
1859 GPBEnumDescriptor *GtalkPresenceStanza_ClientType_EnumDescriptor(void) {
1860   static GPBEnumDescriptor *descriptor = NULL;
1861   if (!descriptor) {
1862     static const char *valueNames =
1863         "Mobile\000Android\000";
1864     static const int32_t values[] = {
1865         GtalkPresenceStanza_ClientType_Mobile,
1866         GtalkPresenceStanza_ClientType_Android,
1867     };
1868     GPBEnumDescriptor *worker =
1869         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkPresenceStanza_ClientType)
1870                                        valueNames:valueNames
1871                                            values:values
1872                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
1873                                      enumVerifier:GtalkPresenceStanza_ClientType_IsValidValue];
1874     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
1875       [worker release];
1876     }
1877   }
1878   return descriptor;
1879 }
1880
1881 BOOL GtalkPresenceStanza_ClientType_IsValidValue(int32_t value__) {
1882   switch (value__) {
1883     case GtalkPresenceStanza_ClientType_Mobile:
1884     case GtalkPresenceStanza_ClientType_Android:
1885       return YES;
1886     default:
1887       return NO;
1888   }
1889 }
1890
1891 #pragma mark - Enum GtalkPresenceStanza_CapabilitiesFlags
1892
1893 GPBEnumDescriptor *GtalkPresenceStanza_CapabilitiesFlags_EnumDescriptor(void) {
1894   static GPBEnumDescriptor *descriptor = NULL;
1895   if (!descriptor) {
1896     static const char *valueNames =
1897         "HasVoiceV1\000HasVideoV1\000HasCameraV1\000HasPmu"
1898         "cV1\000";
1899     static const int32_t values[] = {
1900         GtalkPresenceStanza_CapabilitiesFlags_HasVoiceV1,
1901         GtalkPresenceStanza_CapabilitiesFlags_HasVideoV1,
1902         GtalkPresenceStanza_CapabilitiesFlags_HasCameraV1,
1903         GtalkPresenceStanza_CapabilitiesFlags_HasPmucV1,
1904     };
1905     GPBEnumDescriptor *worker =
1906         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkPresenceStanza_CapabilitiesFlags)
1907                                        valueNames:valueNames
1908                                            values:values
1909                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
1910                                      enumVerifier:GtalkPresenceStanza_CapabilitiesFlags_IsValidValue];
1911     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
1912       [worker release];
1913     }
1914   }
1915   return descriptor;
1916 }
1917
1918 BOOL GtalkPresenceStanza_CapabilitiesFlags_IsValidValue(int32_t value__) {
1919   switch (value__) {
1920     case GtalkPresenceStanza_CapabilitiesFlags_HasVoiceV1:
1921     case GtalkPresenceStanza_CapabilitiesFlags_HasVideoV1:
1922     case GtalkPresenceStanza_CapabilitiesFlags_HasCameraV1:
1923     case GtalkPresenceStanza_CapabilitiesFlags_HasPmucV1:
1924       return YES;
1925     default:
1926       return NO;
1927   }
1928 }
1929
1930 #pragma mark - GtalkBatchPresenceStanza
1931
1932 @implementation GtalkBatchPresenceStanza
1933
1934 @dynamic hasId_p, id_p;
1935 @dynamic hasTo, to;
1936 @dynamic presenceArray, presenceArray_Count;
1937 @dynamic hasPersistentId, persistentId;
1938 @dynamic hasStreamId, streamId;
1939 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
1940 @dynamic hasAccountId, accountId;
1941 @dynamic hasType, type;
1942 @dynamic hasError, error;
1943
1944 typedef struct GtalkBatchPresenceStanza__storage_ {
1945   uint32_t _has_storage_[1];
1946   int32_t streamId;
1947   int32_t lastStreamIdReceived;
1948   GtalkBatchPresenceStanza_Type type;
1949   NSString *id_p;
1950   NSString *to;
1951   NSMutableArray *presenceArray;
1952   NSString *persistentId;
1953   GtalkErrorInfo *error;
1954   int64_t accountId;
1955 } GtalkBatchPresenceStanza__storage_;
1956
1957 // This method is threadsafe because it is initially called
1958 // in +initialize for each subclass.
1959 + (GPBDescriptor *)descriptor {
1960   static GPBDescriptor *descriptor = nil;
1961   if (!descriptor) {
1962     static GPBMessageFieldDescription fields[] = {
1963       {
1964         .name = "id_p",
1965         .dataTypeSpecific.className = NULL,
1966         .number = GtalkBatchPresenceStanza_FieldNumber_Id_p,
1967         .hasIndex = 0,
1968         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, id_p),
1969         .flags = GPBFieldOptional,
1970         .dataType = GPBDataTypeString,
1971       },
1972       {
1973         .name = "to",
1974         .dataTypeSpecific.className = NULL,
1975         .number = GtalkBatchPresenceStanza_FieldNumber_To,
1976         .hasIndex = 1,
1977         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, to),
1978         .flags = GPBFieldOptional,
1979         .dataType = GPBDataTypeString,
1980       },
1981       {
1982         .name = "presenceArray",
1983         .dataTypeSpecific.className = GPBStringifySymbol(GtalkPresenceStanza),
1984         .number = GtalkBatchPresenceStanza_FieldNumber_PresenceArray,
1985         .hasIndex = GPBNoHasBit,
1986         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, presenceArray),
1987         .flags = GPBFieldRepeated,
1988         .dataType = GPBDataTypeMessage,
1989       },
1990       {
1991         .name = "persistentId",
1992         .dataTypeSpecific.className = NULL,
1993         .number = GtalkBatchPresenceStanza_FieldNumber_PersistentId,
1994         .hasIndex = 2,
1995         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, persistentId),
1996         .flags = GPBFieldOptional,
1997         .dataType = GPBDataTypeString,
1998       },
1999       {
2000         .name = "streamId",
2001         .dataTypeSpecific.className = NULL,
2002         .number = GtalkBatchPresenceStanza_FieldNumber_StreamId,
2003         .hasIndex = 3,
2004         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, streamId),
2005         .flags = GPBFieldOptional,
2006         .dataType = GPBDataTypeInt32,
2007       },
2008       {
2009         .name = "lastStreamIdReceived",
2010         .dataTypeSpecific.className = NULL,
2011         .number = GtalkBatchPresenceStanza_FieldNumber_LastStreamIdReceived,
2012         .hasIndex = 4,
2013         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, lastStreamIdReceived),
2014         .flags = GPBFieldOptional,
2015         .dataType = GPBDataTypeInt32,
2016       },
2017       {
2018         .name = "accountId",
2019         .dataTypeSpecific.className = NULL,
2020         .number = GtalkBatchPresenceStanza_FieldNumber_AccountId,
2021         .hasIndex = 5,
2022         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, accountId),
2023         .flags = GPBFieldOptional,
2024         .dataType = GPBDataTypeInt64,
2025       },
2026       {
2027         .name = "type",
2028         .dataTypeSpecific.enumDescFunc = GtalkBatchPresenceStanza_Type_EnumDescriptor,
2029         .number = GtalkBatchPresenceStanza_FieldNumber_Type,
2030         .hasIndex = 6,
2031         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, type),
2032         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
2033         .dataType = GPBDataTypeEnum,
2034       },
2035       {
2036         .name = "error",
2037         .dataTypeSpecific.className = GPBStringifySymbol(GtalkErrorInfo),
2038         .number = GtalkBatchPresenceStanza_FieldNumber_Error,
2039         .hasIndex = 7,
2040         .offset = (uint32_t)offsetof(GtalkBatchPresenceStanza__storage_, error),
2041         .flags = GPBFieldOptional,
2042         .dataType = GPBDataTypeMessage,
2043       },
2044     };
2045     GPBDescriptor *localDescriptor =
2046         [GPBDescriptor allocDescriptorForClass:[GtalkBatchPresenceStanza class]
2047                                      rootClass:[GtalkGtalkCoreRoot class]
2048                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2049                                         fields:fields
2050                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2051                                    storageSize:sizeof(GtalkBatchPresenceStanza__storage_)
2052                                          flags:GPBDescriptorInitializationFlag_None];
2053     NSAssert(descriptor == nil, @"Startup recursed!");
2054     descriptor = localDescriptor;
2055   }
2056   return descriptor;
2057 }
2058
2059 @end
2060
2061 #pragma mark - Enum GtalkBatchPresenceStanza_Type
2062
2063 GPBEnumDescriptor *GtalkBatchPresenceStanza_Type_EnumDescriptor(void) {
2064   static GPBEnumDescriptor *descriptor = NULL;
2065   if (!descriptor) {
2066     static const char *valueNames =
2067         "Get\000Set\000";
2068     static const int32_t values[] = {
2069         GtalkBatchPresenceStanza_Type_Get,
2070         GtalkBatchPresenceStanza_Type_Set,
2071     };
2072     GPBEnumDescriptor *worker =
2073         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkBatchPresenceStanza_Type)
2074                                        valueNames:valueNames
2075                                            values:values
2076                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
2077                                      enumVerifier:GtalkBatchPresenceStanza_Type_IsValidValue];
2078     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
2079       [worker release];
2080     }
2081   }
2082   return descriptor;
2083 }
2084
2085 BOOL GtalkBatchPresenceStanza_Type_IsValidValue(int32_t value__) {
2086   switch (value__) {
2087     case GtalkBatchPresenceStanza_Type_Get:
2088     case GtalkBatchPresenceStanza_Type_Set:
2089       return YES;
2090     default:
2091       return NO;
2092   }
2093 }
2094
2095 #pragma mark - GtalkIqStanza
2096
2097 @implementation GtalkIqStanza
2098
2099 @dynamic hasRmqId, rmqId;
2100 @dynamic hasType, type;
2101 @dynamic hasId_p, id_p;
2102 @dynamic hasFrom, from;
2103 @dynamic hasTo, to;
2104 @dynamic hasError, error;
2105 @dynamic hasExtension, extension;
2106 @dynamic hasPersistentId, persistentId;
2107 @dynamic hasStreamId, streamId;
2108 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
2109 @dynamic hasAccountId, accountId;
2110 @dynamic hasStatus, status;
2111
2112 typedef struct GtalkIqStanza__storage_ {
2113   uint32_t _has_storage_[1];
2114   GtalkIqStanza_IqType type;
2115   int32_t streamId;
2116   int32_t lastStreamIdReceived;
2117   NSString *id_p;
2118   NSString *from;
2119   NSString *to;
2120   GtalkErrorInfo *error;
2121   GtalkExtension *extension;
2122   NSString *persistentId;
2123   int64_t rmqId;
2124   int64_t accountId;
2125   int64_t status;
2126 } GtalkIqStanza__storage_;
2127
2128 // This method is threadsafe because it is initially called
2129 // in +initialize for each subclass.
2130 + (GPBDescriptor *)descriptor {
2131   static GPBDescriptor *descriptor = nil;
2132   if (!descriptor) {
2133     static GPBMessageFieldDescription fields[] = {
2134       {
2135         .name = "rmqId",
2136         .dataTypeSpecific.className = NULL,
2137         .number = GtalkIqStanza_FieldNumber_RmqId,
2138         .hasIndex = 0,
2139         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, rmqId),
2140         .flags = GPBFieldOptional,
2141         .dataType = GPBDataTypeInt64,
2142       },
2143       {
2144         .name = "type",
2145         .dataTypeSpecific.enumDescFunc = GtalkIqStanza_IqType_EnumDescriptor,
2146         .number = GtalkIqStanza_FieldNumber_Type,
2147         .hasIndex = 1,
2148         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, type),
2149         .flags = (GPBFieldFlags)(GPBFieldRequired | GPBFieldHasEnumDescriptor),
2150         .dataType = GPBDataTypeEnum,
2151       },
2152       {
2153         .name = "id_p",
2154         .dataTypeSpecific.className = NULL,
2155         .number = GtalkIqStanza_FieldNumber_Id_p,
2156         .hasIndex = 2,
2157         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, id_p),
2158         .flags = GPBFieldRequired,
2159         .dataType = GPBDataTypeString,
2160       },
2161       {
2162         .name = "from",
2163         .dataTypeSpecific.className = NULL,
2164         .number = GtalkIqStanza_FieldNumber_From,
2165         .hasIndex = 3,
2166         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, from),
2167         .flags = GPBFieldOptional,
2168         .dataType = GPBDataTypeString,
2169       },
2170       {
2171         .name = "to",
2172         .dataTypeSpecific.className = NULL,
2173         .number = GtalkIqStanza_FieldNumber_To,
2174         .hasIndex = 4,
2175         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, to),
2176         .flags = GPBFieldOptional,
2177         .dataType = GPBDataTypeString,
2178       },
2179       {
2180         .name = "error",
2181         .dataTypeSpecific.className = GPBStringifySymbol(GtalkErrorInfo),
2182         .number = GtalkIqStanza_FieldNumber_Error,
2183         .hasIndex = 5,
2184         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, error),
2185         .flags = GPBFieldOptional,
2186         .dataType = GPBDataTypeMessage,
2187       },
2188       {
2189         .name = "extension",
2190         .dataTypeSpecific.className = GPBStringifySymbol(GtalkExtension),
2191         .number = GtalkIqStanza_FieldNumber_Extension,
2192         .hasIndex = 6,
2193         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, extension),
2194         .flags = GPBFieldOptional,
2195         .dataType = GPBDataTypeMessage,
2196       },
2197       {
2198         .name = "persistentId",
2199         .dataTypeSpecific.className = NULL,
2200         .number = GtalkIqStanza_FieldNumber_PersistentId,
2201         .hasIndex = 7,
2202         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, persistentId),
2203         .flags = GPBFieldOptional,
2204         .dataType = GPBDataTypeString,
2205       },
2206       {
2207         .name = "streamId",
2208         .dataTypeSpecific.className = NULL,
2209         .number = GtalkIqStanza_FieldNumber_StreamId,
2210         .hasIndex = 8,
2211         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, streamId),
2212         .flags = GPBFieldOptional,
2213         .dataType = GPBDataTypeInt32,
2214       },
2215       {
2216         .name = "lastStreamIdReceived",
2217         .dataTypeSpecific.className = NULL,
2218         .number = GtalkIqStanza_FieldNumber_LastStreamIdReceived,
2219         .hasIndex = 9,
2220         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, lastStreamIdReceived),
2221         .flags = GPBFieldOptional,
2222         .dataType = GPBDataTypeInt32,
2223       },
2224       {
2225         .name = "accountId",
2226         .dataTypeSpecific.className = NULL,
2227         .number = GtalkIqStanza_FieldNumber_AccountId,
2228         .hasIndex = 10,
2229         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, accountId),
2230         .flags = GPBFieldOptional,
2231         .dataType = GPBDataTypeInt64,
2232       },
2233       {
2234         .name = "status",
2235         .dataTypeSpecific.className = NULL,
2236         .number = GtalkIqStanza_FieldNumber_Status,
2237         .hasIndex = 11,
2238         .offset = (uint32_t)offsetof(GtalkIqStanza__storage_, status),
2239         .flags = GPBFieldOptional,
2240         .dataType = GPBDataTypeInt64,
2241       },
2242     };
2243     GPBDescriptor *localDescriptor =
2244         [GPBDescriptor allocDescriptorForClass:[GtalkIqStanza class]
2245                                      rootClass:[GtalkGtalkCoreRoot class]
2246                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2247                                         fields:fields
2248                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2249                                    storageSize:sizeof(GtalkIqStanza__storage_)
2250                                          flags:GPBDescriptorInitializationFlag_None];
2251     NSAssert(descriptor == nil, @"Startup recursed!");
2252     descriptor = localDescriptor;
2253   }
2254   return descriptor;
2255 }
2256
2257 @end
2258
2259 #pragma mark - Enum GtalkIqStanza_IqType
2260
2261 GPBEnumDescriptor *GtalkIqStanza_IqType_EnumDescriptor(void) {
2262   static GPBEnumDescriptor *descriptor = NULL;
2263   if (!descriptor) {
2264     static const char *valueNames =
2265         "Get\000Set\000Result\000Error\000";
2266     static const int32_t values[] = {
2267         GtalkIqStanza_IqType_Get,
2268         GtalkIqStanza_IqType_Set,
2269         GtalkIqStanza_IqType_Result,
2270         GtalkIqStanza_IqType_Error,
2271     };
2272     GPBEnumDescriptor *worker =
2273         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkIqStanza_IqType)
2274                                        valueNames:valueNames
2275                                            values:values
2276                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
2277                                      enumVerifier:GtalkIqStanza_IqType_IsValidValue];
2278     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
2279       [worker release];
2280     }
2281   }
2282   return descriptor;
2283 }
2284
2285 BOOL GtalkIqStanza_IqType_IsValidValue(int32_t value__) {
2286   switch (value__) {
2287     case GtalkIqStanza_IqType_Get:
2288     case GtalkIqStanza_IqType_Set:
2289     case GtalkIqStanza_IqType_Result:
2290     case GtalkIqStanza_IqType_Error:
2291       return YES;
2292     default:
2293       return NO;
2294   }
2295 }
2296
2297 #pragma mark - GtalkAppData
2298
2299 @implementation GtalkAppData
2300
2301 @dynamic hasKey, key;
2302 @dynamic hasValue, value;
2303
2304 typedef struct GtalkAppData__storage_ {
2305   uint32_t _has_storage_[1];
2306   NSString *key;
2307   NSString *value;
2308 } GtalkAppData__storage_;
2309
2310 // This method is threadsafe because it is initially called
2311 // in +initialize for each subclass.
2312 + (GPBDescriptor *)descriptor {
2313   static GPBDescriptor *descriptor = nil;
2314   if (!descriptor) {
2315     static GPBMessageFieldDescription fields[] = {
2316       {
2317         .name = "key",
2318         .dataTypeSpecific.className = NULL,
2319         .number = GtalkAppData_FieldNumber_Key,
2320         .hasIndex = 0,
2321         .offset = (uint32_t)offsetof(GtalkAppData__storage_, key),
2322         .flags = GPBFieldRequired,
2323         .dataType = GPBDataTypeString,
2324       },
2325       {
2326         .name = "value",
2327         .dataTypeSpecific.className = NULL,
2328         .number = GtalkAppData_FieldNumber_Value,
2329         .hasIndex = 1,
2330         .offset = (uint32_t)offsetof(GtalkAppData__storage_, value),
2331         .flags = GPBFieldRequired,
2332         .dataType = GPBDataTypeString,
2333       },
2334     };
2335     GPBDescriptor *localDescriptor =
2336         [GPBDescriptor allocDescriptorForClass:[GtalkAppData class]
2337                                      rootClass:[GtalkGtalkCoreRoot class]
2338                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2339                                         fields:fields
2340                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2341                                    storageSize:sizeof(GtalkAppData__storage_)
2342                                          flags:GPBDescriptorInitializationFlag_None];
2343     NSAssert(descriptor == nil, @"Startup recursed!");
2344     descriptor = localDescriptor;
2345   }
2346   return descriptor;
2347 }
2348
2349 @end
2350
2351 #pragma mark - GtalkDataMessageStanza
2352
2353 @implementation GtalkDataMessageStanza
2354
2355 @dynamic hasRmqId, rmqId;
2356 @dynamic hasId_p, id_p;
2357 @dynamic hasFrom, from;
2358 @dynamic hasTo, to;
2359 @dynamic hasCategory, category;
2360 @dynamic hasToken, token;
2361 @dynamic appDataArray, appDataArray_Count;
2362 @dynamic hasFromTrustedServer, fromTrustedServer;
2363 @dynamic hasPersistentId, persistentId;
2364 @dynamic hasStreamId, streamId;
2365 @dynamic hasLastStreamIdReceived, lastStreamIdReceived;
2366 @dynamic hasPermission, permission;
2367 @dynamic hasRegId, regId;
2368 @dynamic hasPkgSignature, pkgSignature;
2369 @dynamic hasClientId, clientId;
2370 @dynamic hasDeviceUserId, deviceUserId;
2371 @dynamic hasTtl, ttl;
2372 @dynamic hasSent, sent;
2373 @dynamic hasQueued, queued;
2374 @dynamic hasStatus, status;
2375 @dynamic hasRawData, rawData;
2376 @dynamic hasMaxDelay, maxDelay;
2377 @dynamic hasActualDelay, actualDelay;
2378 @dynamic hasImmediateAck, immediateAck;
2379 @dynamic hasDeliveryReceiptRequested, deliveryReceiptRequested;
2380 @dynamic hasExternalMessageId, externalMessageId;
2381 @dynamic hasFlags, flags;
2382 @dynamic hasCellTower, cellTower;
2383 @dynamic hasPriority, priority;
2384
2385 typedef struct GtalkDataMessageStanza__storage_ {
2386   uint32_t _has_storage_[1];
2387   int32_t streamId;
2388   int32_t lastStreamIdReceived;
2389   int32_t ttl;
2390   int32_t queued;
2391   int32_t maxDelay;
2392   int32_t actualDelay;
2393   int32_t priority;
2394   NSString *id_p;
2395   NSString *from;
2396   NSString *to;
2397   NSString *category;
2398   NSString *token;
2399   NSMutableArray *appDataArray;
2400   NSString *persistentId;
2401   NSString *permission;
2402   NSString *regId;
2403   NSString *pkgSignature;
2404   NSString *clientId;
2405   NSData *rawData;
2406   NSString *externalMessageId;
2407   GtalkCellTower *cellTower;
2408   int64_t rmqId;
2409   int64_t deviceUserId;
2410   int64_t sent;
2411   int64_t status;
2412   int64_t flags;
2413 } GtalkDataMessageStanza__storage_;
2414
2415 // This method is threadsafe because it is initially called
2416 // in +initialize for each subclass.
2417 + (GPBDescriptor *)descriptor {
2418   static GPBDescriptor *descriptor = nil;
2419   if (!descriptor) {
2420     static GPBMessageFieldDescription fields[] = {
2421       {
2422         .name = "rmqId",
2423         .dataTypeSpecific.className = NULL,
2424         .number = GtalkDataMessageStanza_FieldNumber_RmqId,
2425         .hasIndex = 0,
2426         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, rmqId),
2427         .flags = GPBFieldOptional,
2428         .dataType = GPBDataTypeInt64,
2429       },
2430       {
2431         .name = "id_p",
2432         .dataTypeSpecific.className = NULL,
2433         .number = GtalkDataMessageStanza_FieldNumber_Id_p,
2434         .hasIndex = 1,
2435         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, id_p),
2436         .flags = GPBFieldOptional,
2437         .dataType = GPBDataTypeString,
2438       },
2439       {
2440         .name = "from",
2441         .dataTypeSpecific.className = NULL,
2442         .number = GtalkDataMessageStanza_FieldNumber_From,
2443         .hasIndex = 2,
2444         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, from),
2445         .flags = GPBFieldRequired,
2446         .dataType = GPBDataTypeString,
2447       },
2448       {
2449         .name = "to",
2450         .dataTypeSpecific.className = NULL,
2451         .number = GtalkDataMessageStanza_FieldNumber_To,
2452         .hasIndex = 3,
2453         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, to),
2454         .flags = GPBFieldOptional,
2455         .dataType = GPBDataTypeString,
2456       },
2457       {
2458         .name = "category",
2459         .dataTypeSpecific.className = NULL,
2460         .number = GtalkDataMessageStanza_FieldNumber_Category,
2461         .hasIndex = 4,
2462         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, category),
2463         .flags = GPBFieldRequired,
2464         .dataType = GPBDataTypeString,
2465       },
2466       {
2467         .name = "token",
2468         .dataTypeSpecific.className = NULL,
2469         .number = GtalkDataMessageStanza_FieldNumber_Token,
2470         .hasIndex = 5,
2471         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, token),
2472         .flags = GPBFieldOptional,
2473         .dataType = GPBDataTypeString,
2474       },
2475       {
2476         .name = "appDataArray",
2477         .dataTypeSpecific.className = GPBStringifySymbol(GtalkAppData),
2478         .number = GtalkDataMessageStanza_FieldNumber_AppDataArray,
2479         .hasIndex = GPBNoHasBit,
2480         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, appDataArray),
2481         .flags = GPBFieldRepeated,
2482         .dataType = GPBDataTypeMessage,
2483       },
2484       {
2485         .name = "fromTrustedServer",
2486         .dataTypeSpecific.className = NULL,
2487         .number = GtalkDataMessageStanza_FieldNumber_FromTrustedServer,
2488         .hasIndex = 6,
2489         .offset = 7,  // Stored in _has_storage_ to save space.
2490         .flags = GPBFieldOptional,
2491         .dataType = GPBDataTypeBool,
2492       },
2493       {
2494         .name = "persistentId",
2495         .dataTypeSpecific.className = NULL,
2496         .number = GtalkDataMessageStanza_FieldNumber_PersistentId,
2497         .hasIndex = 8,
2498         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, persistentId),
2499         .flags = GPBFieldOptional,
2500         .dataType = GPBDataTypeString,
2501       },
2502       {
2503         .name = "streamId",
2504         .dataTypeSpecific.className = NULL,
2505         .number = GtalkDataMessageStanza_FieldNumber_StreamId,
2506         .hasIndex = 9,
2507         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, streamId),
2508         .flags = GPBFieldOptional,
2509         .dataType = GPBDataTypeInt32,
2510       },
2511       {
2512         .name = "lastStreamIdReceived",
2513         .dataTypeSpecific.className = NULL,
2514         .number = GtalkDataMessageStanza_FieldNumber_LastStreamIdReceived,
2515         .hasIndex = 10,
2516         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, lastStreamIdReceived),
2517         .flags = GPBFieldOptional,
2518         .dataType = GPBDataTypeInt32,
2519       },
2520       {
2521         .name = "permission",
2522         .dataTypeSpecific.className = NULL,
2523         .number = GtalkDataMessageStanza_FieldNumber_Permission,
2524         .hasIndex = 11,
2525         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, permission),
2526         .flags = GPBFieldOptional,
2527         .dataType = GPBDataTypeString,
2528       },
2529       {
2530         .name = "regId",
2531         .dataTypeSpecific.className = NULL,
2532         .number = GtalkDataMessageStanza_FieldNumber_RegId,
2533         .hasIndex = 12,
2534         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, regId),
2535         .flags = GPBFieldOptional,
2536         .dataType = GPBDataTypeString,
2537       },
2538       {
2539         .name = "pkgSignature",
2540         .dataTypeSpecific.className = NULL,
2541         .number = GtalkDataMessageStanza_FieldNumber_PkgSignature,
2542         .hasIndex = 13,
2543         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, pkgSignature),
2544         .flags = GPBFieldOptional,
2545         .dataType = GPBDataTypeString,
2546       },
2547       {
2548         .name = "clientId",
2549         .dataTypeSpecific.className = NULL,
2550         .number = GtalkDataMessageStanza_FieldNumber_ClientId,
2551         .hasIndex = 14,
2552         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, clientId),
2553         .flags = GPBFieldOptional,
2554         .dataType = GPBDataTypeString,
2555       },
2556       {
2557         .name = "deviceUserId",
2558         .dataTypeSpecific.className = NULL,
2559         .number = GtalkDataMessageStanza_FieldNumber_DeviceUserId,
2560         .hasIndex = 15,
2561         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, deviceUserId),
2562         .flags = GPBFieldOptional,
2563         .dataType = GPBDataTypeInt64,
2564       },
2565       {
2566         .name = "ttl",
2567         .dataTypeSpecific.className = NULL,
2568         .number = GtalkDataMessageStanza_FieldNumber_Ttl,
2569         .hasIndex = 16,
2570         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, ttl),
2571         .flags = GPBFieldOptional,
2572         .dataType = GPBDataTypeInt32,
2573       },
2574       {
2575         .name = "sent",
2576         .dataTypeSpecific.className = NULL,
2577         .number = GtalkDataMessageStanza_FieldNumber_Sent,
2578         .hasIndex = 17,
2579         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, sent),
2580         .flags = GPBFieldOptional,
2581         .dataType = GPBDataTypeInt64,
2582       },
2583       {
2584         .name = "queued",
2585         .dataTypeSpecific.className = NULL,
2586         .number = GtalkDataMessageStanza_FieldNumber_Queued,
2587         .hasIndex = 18,
2588         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, queued),
2589         .flags = GPBFieldOptional,
2590         .dataType = GPBDataTypeInt32,
2591       },
2592       {
2593         .name = "status",
2594         .dataTypeSpecific.className = NULL,
2595         .number = GtalkDataMessageStanza_FieldNumber_Status,
2596         .hasIndex = 19,
2597         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, status),
2598         .flags = GPBFieldOptional,
2599         .dataType = GPBDataTypeInt64,
2600       },
2601       {
2602         .name = "rawData",
2603         .dataTypeSpecific.className = NULL,
2604         .number = GtalkDataMessageStanza_FieldNumber_RawData,
2605         .hasIndex = 20,
2606         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, rawData),
2607         .flags = GPBFieldOptional,
2608         .dataType = GPBDataTypeBytes,
2609       },
2610       {
2611         .name = "maxDelay",
2612         .dataTypeSpecific.className = NULL,
2613         .number = GtalkDataMessageStanza_FieldNumber_MaxDelay,
2614         .hasIndex = 21,
2615         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, maxDelay),
2616         .flags = GPBFieldOptional,
2617         .dataType = GPBDataTypeInt32,
2618       },
2619       {
2620         .name = "actualDelay",
2621         .dataTypeSpecific.className = NULL,
2622         .number = GtalkDataMessageStanza_FieldNumber_ActualDelay,
2623         .hasIndex = 22,
2624         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, actualDelay),
2625         .flags = GPBFieldOptional,
2626         .dataType = GPBDataTypeInt32,
2627       },
2628       {
2629         .name = "immediateAck",
2630         .dataTypeSpecific.className = NULL,
2631         .number = GtalkDataMessageStanza_FieldNumber_ImmediateAck,
2632         .hasIndex = 23,
2633         .offset = 24,  // Stored in _has_storage_ to save space.
2634         .flags = GPBFieldOptional,
2635         .dataType = GPBDataTypeBool,
2636       },
2637       {
2638         .name = "deliveryReceiptRequested",
2639         .dataTypeSpecific.className = NULL,
2640         .number = GtalkDataMessageStanza_FieldNumber_DeliveryReceiptRequested,
2641         .hasIndex = 25,
2642         .offset = 26,  // Stored in _has_storage_ to save space.
2643         .flags = GPBFieldOptional,
2644         .dataType = GPBDataTypeBool,
2645       },
2646       {
2647         .name = "externalMessageId",
2648         .dataTypeSpecific.className = NULL,
2649         .number = GtalkDataMessageStanza_FieldNumber_ExternalMessageId,
2650         .hasIndex = 27,
2651         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, externalMessageId),
2652         .flags = GPBFieldOptional,
2653         .dataType = GPBDataTypeString,
2654       },
2655       {
2656         .name = "flags",
2657         .dataTypeSpecific.className = NULL,
2658         .number = GtalkDataMessageStanza_FieldNumber_Flags,
2659         .hasIndex = 28,
2660         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, flags),
2661         .flags = GPBFieldOptional,
2662         .dataType = GPBDataTypeInt64,
2663       },
2664       {
2665         .name = "cellTower",
2666         .dataTypeSpecific.className = GPBStringifySymbol(GtalkCellTower),
2667         .number = GtalkDataMessageStanza_FieldNumber_CellTower,
2668         .hasIndex = 29,
2669         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, cellTower),
2670         .flags = GPBFieldOptional,
2671         .dataType = GPBDataTypeMessage,
2672       },
2673       {
2674         .name = "priority",
2675         .dataTypeSpecific.className = NULL,
2676         .number = GtalkDataMessageStanza_FieldNumber_Priority,
2677         .hasIndex = 30,
2678         .offset = (uint32_t)offsetof(GtalkDataMessageStanza__storage_, priority),
2679         .flags = GPBFieldOptional,
2680         .dataType = GPBDataTypeInt32,
2681       },
2682     };
2683     GPBDescriptor *localDescriptor =
2684         [GPBDescriptor allocDescriptorForClass:[GtalkDataMessageStanza class]
2685                                      rootClass:[GtalkGtalkCoreRoot class]
2686                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2687                                         fields:fields
2688                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2689                                    storageSize:sizeof(GtalkDataMessageStanza__storage_)
2690                                          flags:GPBDescriptorInitializationFlag_None];
2691     NSAssert(descriptor == nil, @"Startup recursed!");
2692     descriptor = localDescriptor;
2693   }
2694   return descriptor;
2695 }
2696
2697 @end
2698
2699 #pragma mark - GtalkTalkMetadata
2700
2701 @implementation GtalkTalkMetadata
2702
2703 @dynamic hasForeground, foreground;
2704
2705 typedef struct GtalkTalkMetadata__storage_ {
2706   uint32_t _has_storage_[1];
2707 } GtalkTalkMetadata__storage_;
2708
2709 // This method is threadsafe because it is initially called
2710 // in +initialize for each subclass.
2711 + (GPBDescriptor *)descriptor {
2712   static GPBDescriptor *descriptor = nil;
2713   if (!descriptor) {
2714     static GPBMessageFieldDescription fields[] = {
2715       {
2716         .name = "foreground",
2717         .dataTypeSpecific.className = NULL,
2718         .number = GtalkTalkMetadata_FieldNumber_Foreground,
2719         .hasIndex = 0,
2720         .offset = 1,  // Stored in _has_storage_ to save space.
2721         .flags = GPBFieldOptional,
2722         .dataType = GPBDataTypeBool,
2723       },
2724     };
2725     GPBDescriptor *localDescriptor =
2726         [GPBDescriptor allocDescriptorForClass:[GtalkTalkMetadata class]
2727                                      rootClass:[GtalkGtalkCoreRoot class]
2728                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2729                                         fields:fields
2730                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2731                                    storageSize:sizeof(GtalkTalkMetadata__storage_)
2732                                          flags:GPBDescriptorInitializationFlag_None];
2733     NSAssert(descriptor == nil, @"Startup recursed!");
2734     descriptor = localDescriptor;
2735   }
2736   return descriptor;
2737 }
2738
2739 @end
2740
2741 #pragma mark - GtalkCellTower
2742
2743 #pragma clang diagnostic push
2744 #pragma clang diagnostic ignored "-Wdeprecated-implementations"
2745
2746 @implementation GtalkCellTower
2747
2748 @dynamic hasId_p, id_p;
2749 @dynamic hasKnownCongestionStatus, knownCongestionStatus;
2750
2751 typedef struct GtalkCellTower__storage_ {
2752   uint32_t _has_storage_[1];
2753   int32_t knownCongestionStatus;
2754   NSString *id_p;
2755 } GtalkCellTower__storage_;
2756
2757 // This method is threadsafe because it is initially called
2758 // in +initialize for each subclass.
2759 + (GPBDescriptor *)descriptor {
2760   static GPBDescriptor *descriptor = nil;
2761   if (!descriptor) {
2762     static GPBMessageFieldDescription fields[] = {
2763       {
2764         .name = "id_p",
2765         .dataTypeSpecific.className = NULL,
2766         .number = GtalkCellTower_FieldNumber_Id_p,
2767         .hasIndex = 0,
2768         .offset = (uint32_t)offsetof(GtalkCellTower__storage_, id_p),
2769         .flags = GPBFieldOptional,
2770         .dataType = GPBDataTypeString,
2771       },
2772       {
2773         .name = "knownCongestionStatus",
2774         .dataTypeSpecific.className = NULL,
2775         .number = GtalkCellTower_FieldNumber_KnownCongestionStatus,
2776         .hasIndex = 1,
2777         .offset = (uint32_t)offsetof(GtalkCellTower__storage_, knownCongestionStatus),
2778         .flags = GPBFieldOptional,
2779         .dataType = GPBDataTypeInt32,
2780       },
2781     };
2782     GPBDescriptor *localDescriptor =
2783         [GPBDescriptor allocDescriptorForClass:[GtalkCellTower class]
2784                                      rootClass:[GtalkGtalkCoreRoot class]
2785                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2786                                         fields:fields
2787                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2788                                    storageSize:sizeof(GtalkCellTower__storage_)
2789                                          flags:GPBDescriptorInitializationFlag_None];
2790     NSAssert(descriptor == nil, @"Startup recursed!");
2791     descriptor = localDescriptor;
2792   }
2793   return descriptor;
2794 }
2795
2796 @end
2797
2798 #pragma clang diagnostic pop
2799
2800 #pragma mark - GtalkClientEvent
2801
2802 @implementation GtalkClientEvent
2803
2804 @dynamic hasType, type;
2805 @dynamic hasNumberDiscardedEvents, numberDiscardedEvents;
2806 @dynamic hasNetworkType, networkType;
2807 @dynamic hasNetworkPort, networkPort;
2808 @dynamic hasTimeConnectionStartedMs, timeConnectionStartedMs;
2809 @dynamic hasTimeConnectionEndedMs, timeConnectionEndedMs;
2810 @dynamic hasErrorCode, errorCode;
2811 @dynamic hasTimeConnectionEstablishedMs, timeConnectionEstablishedMs;
2812 @dynamic hasMcsReconnectAction, mcsReconnectAction;
2813
2814 typedef struct GtalkClientEvent__storage_ {
2815   uint32_t _has_storage_[1];
2816   GtalkClientEvent_Type type;
2817   uint32_t numberDiscardedEvents;
2818   int32_t networkType;
2819   int32_t networkPort;
2820   int32_t errorCode;
2821   GtalkClientEvent_McsReconnectAction mcsReconnectAction;
2822   uint64_t timeConnectionStartedMs;
2823   uint64_t timeConnectionEndedMs;
2824   uint64_t timeConnectionEstablishedMs;
2825 } GtalkClientEvent__storage_;
2826
2827 // This method is threadsafe because it is initially called
2828 // in +initialize for each subclass.
2829 + (GPBDescriptor *)descriptor {
2830   static GPBDescriptor *descriptor = nil;
2831   if (!descriptor) {
2832     static GPBMessageFieldDescription fields[] = {
2833       {
2834         .name = "type",
2835         .dataTypeSpecific.enumDescFunc = GtalkClientEvent_Type_EnumDescriptor,
2836         .number = GtalkClientEvent_FieldNumber_Type,
2837         .hasIndex = 0,
2838         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, type),
2839         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
2840         .dataType = GPBDataTypeEnum,
2841       },
2842       {
2843         .name = "numberDiscardedEvents",
2844         .dataTypeSpecific.className = NULL,
2845         .number = GtalkClientEvent_FieldNumber_NumberDiscardedEvents,
2846         .hasIndex = 1,
2847         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, numberDiscardedEvents),
2848         .flags = GPBFieldOptional,
2849         .dataType = GPBDataTypeUInt32,
2850       },
2851       {
2852         .name = "networkType",
2853         .dataTypeSpecific.className = NULL,
2854         .number = GtalkClientEvent_FieldNumber_NetworkType,
2855         .hasIndex = 2,
2856         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, networkType),
2857         .flags = GPBFieldOptional,
2858         .dataType = GPBDataTypeInt32,
2859       },
2860       {
2861         .name = "networkPort",
2862         .dataTypeSpecific.className = NULL,
2863         .number = GtalkClientEvent_FieldNumber_NetworkPort,
2864         .hasIndex = 3,
2865         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, networkPort),
2866         .flags = GPBFieldOptional,
2867         .dataType = GPBDataTypeInt32,
2868       },
2869       {
2870         .name = "timeConnectionStartedMs",
2871         .dataTypeSpecific.className = NULL,
2872         .number = GtalkClientEvent_FieldNumber_TimeConnectionStartedMs,
2873         .hasIndex = 4,
2874         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, timeConnectionStartedMs),
2875         .flags = GPBFieldOptional,
2876         .dataType = GPBDataTypeUInt64,
2877       },
2878       {
2879         .name = "timeConnectionEndedMs",
2880         .dataTypeSpecific.className = NULL,
2881         .number = GtalkClientEvent_FieldNumber_TimeConnectionEndedMs,
2882         .hasIndex = 5,
2883         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, timeConnectionEndedMs),
2884         .flags = GPBFieldOptional,
2885         .dataType = GPBDataTypeUInt64,
2886       },
2887       {
2888         .name = "errorCode",
2889         .dataTypeSpecific.className = NULL,
2890         .number = GtalkClientEvent_FieldNumber_ErrorCode,
2891         .hasIndex = 6,
2892         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, errorCode),
2893         .flags = GPBFieldOptional,
2894         .dataType = GPBDataTypeInt32,
2895       },
2896       {
2897         .name = "timeConnectionEstablishedMs",
2898         .dataTypeSpecific.className = NULL,
2899         .number = GtalkClientEvent_FieldNumber_TimeConnectionEstablishedMs,
2900         .hasIndex = 7,
2901         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, timeConnectionEstablishedMs),
2902         .flags = GPBFieldOptional,
2903         .dataType = GPBDataTypeUInt64,
2904       },
2905       {
2906         .name = "mcsReconnectAction",
2907         .dataTypeSpecific.enumDescFunc = GtalkClientEvent_McsReconnectAction_EnumDescriptor,
2908         .number = GtalkClientEvent_FieldNumber_McsReconnectAction,
2909         .hasIndex = 8,
2910         .offset = (uint32_t)offsetof(GtalkClientEvent__storage_, mcsReconnectAction),
2911         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
2912         .dataType = GPBDataTypeEnum,
2913       },
2914     };
2915     GPBDescriptor *localDescriptor =
2916         [GPBDescriptor allocDescriptorForClass:[GtalkClientEvent class]
2917                                      rootClass:[GtalkGtalkCoreRoot class]
2918                                           file:GtalkGtalkCoreRoot_FileDescriptor()
2919                                         fields:fields
2920                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
2921                                    storageSize:sizeof(GtalkClientEvent__storage_)
2922                                          flags:GPBDescriptorInitializationFlag_None];
2923     NSAssert(descriptor == nil, @"Startup recursed!");
2924     descriptor = localDescriptor;
2925   }
2926   return descriptor;
2927 }
2928
2929 @end
2930
2931 #pragma mark - Enum GtalkClientEvent_Type
2932
2933 GPBEnumDescriptor *GtalkClientEvent_Type_EnumDescriptor(void) {
2934   static GPBEnumDescriptor *descriptor = NULL;
2935   if (!descriptor) {
2936     static const char *valueNames =
2937         "Unknown\000DiscardedEvents\000FailedConnection"
2938         "\000SuccessfulConnection\000McsReconnectReques"
2939         "t\000FailedSocketCreationMcsReconnect\000McsRe"
2940         "connectLimited\000";
2941     static const int32_t values[] = {
2942         GtalkClientEvent_Type_Unknown,
2943         GtalkClientEvent_Type_DiscardedEvents,
2944         GtalkClientEvent_Type_FailedConnection,
2945         GtalkClientEvent_Type_SuccessfulConnection,
2946         GtalkClientEvent_Type_McsReconnectRequest,
2947         GtalkClientEvent_Type_FailedSocketCreationMcsReconnect,
2948         GtalkClientEvent_Type_McsReconnectLimited,
2949     };
2950     GPBEnumDescriptor *worker =
2951         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkClientEvent_Type)
2952                                        valueNames:valueNames
2953                                            values:values
2954                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
2955                                      enumVerifier:GtalkClientEvent_Type_IsValidValue];
2956     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
2957       [worker release];
2958     }
2959   }
2960   return descriptor;
2961 }
2962
2963 BOOL GtalkClientEvent_Type_IsValidValue(int32_t value__) {
2964   switch (value__) {
2965     case GtalkClientEvent_Type_Unknown:
2966     case GtalkClientEvent_Type_DiscardedEvents:
2967     case GtalkClientEvent_Type_FailedConnection:
2968     case GtalkClientEvent_Type_SuccessfulConnection:
2969     case GtalkClientEvent_Type_McsReconnectRequest:
2970     case GtalkClientEvent_Type_FailedSocketCreationMcsReconnect:
2971     case GtalkClientEvent_Type_McsReconnectLimited:
2972       return YES;
2973     default:
2974       return NO;
2975   }
2976 }
2977
2978 #pragma mark - Enum GtalkClientEvent_McsReconnectAction
2979
2980 GPBEnumDescriptor *GtalkClientEvent_McsReconnectAction_EnumDescriptor(void) {
2981   static GPBEnumDescriptor *descriptor = NULL;
2982   if (!descriptor) {
2983     static const char *valueNames =
2984         "None\000NotConnected\000TooSoon\000";
2985     static const int32_t values[] = {
2986         GtalkClientEvent_McsReconnectAction_None,
2987         GtalkClientEvent_McsReconnectAction_NotConnected,
2988         GtalkClientEvent_McsReconnectAction_TooSoon,
2989     };
2990     GPBEnumDescriptor *worker =
2991         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GtalkClientEvent_McsReconnectAction)
2992                                        valueNames:valueNames
2993                                            values:values
2994                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
2995                                      enumVerifier:GtalkClientEvent_McsReconnectAction_IsValidValue];
2996     if (!OSAtomicCompareAndSwapPtrBarrier(nil, worker, (void * volatile *)&descriptor)) {
2997       [worker release];
2998     }
2999   }
3000   return descriptor;
3001 }
3002
3003 BOOL GtalkClientEvent_McsReconnectAction_IsValidValue(int32_t value__) {
3004   switch (value__) {
3005     case GtalkClientEvent_McsReconnectAction_None:
3006     case GtalkClientEvent_McsReconnectAction_NotConnected:
3007     case GtalkClientEvent_McsReconnectAction_TooSoon:
3008       return YES;
3009     default:
3010       return NO;
3011   }
3012 }
3013
3014
3015 #pragma clang diagnostic pop
3016
3017 // @@protoc_insertion_point(global_scope)