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