Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/protobuf/objectivec/google/protobuf/Descriptor.pbobjc.m

Issue 1842653006: Update //third_party/protobuf to version 3. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: pull whole protobuf Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« third_party/protobuf/README.chromium ('K') | « third_party/protobuf/objectivec/google/protobuf/Descriptor.pbobjc.h ('k') | third_party/protobuf/objectivec/google/protobuf/Duration.pbobjc.h » ('j') | third_party/protobuf/patches/0002-remove-support-for-unnecessary-languages.patch » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: google/protobuf/descriptor.proto
3
4 #import "GPBProtocolBuffers_RuntimeSupport.h"
5 #import "google/protobuf/Descriptor.pbobjc.h"
6 // @@protoc_insertion_point(imports)
7
8 #pragma mark - GPBDescriptorRoot
9
10 @implementation GPBDescriptorRoot
11
12 @end
13
14 #pragma mark - GPBDescriptorRoot_FileDescriptor
15
16 static GPBFileDescriptor *GPBDescriptorRoot_FileDescriptor(void) {
17 // This is called by +initialize so there is no need to worry
18 // about thread safety of the singleton.
19 static GPBFileDescriptor *descriptor = NULL;
20 if (!descriptor) {
21 GPBDebugCheckRuntimeVersion();
22 descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
23 syntax:GPBFileSyntaxProto2] ;
24 }
25 return descriptor;
26 }
27
28 #pragma mark - GPBFileDescriptorSet
29
30 @implementation GPBFileDescriptorSet
31
32 @dynamic fileArray, fileArray_Count;
33
34 typedef struct GPBFileDescriptorSet__storage_ {
35 uint32_t _has_storage_[1];
36 NSMutableArray *fileArray;
37 } GPBFileDescriptorSet__storage_;
38
39 // This method is threadsafe because it is initially called
40 // in +initialize for each subclass.
41 + (GPBDescriptor *)descriptor {
42 static GPBDescriptor *descriptor = nil;
43 if (!descriptor) {
44 static GPBMessageFieldDescription fields[] = {
45 {
46 .name = "fileArray",
47 .number = GPBFileDescriptorSet_FieldNumber_FileArray,
48 .hasIndex = GPBNoHasBit,
49 .flags = GPBFieldRepeated,
50 .dataType = GPBDataTypeMessage,
51 .offset = offsetof(GPBFileDescriptorSet__storage_, fileArray),
52 .defaultValue.valueMessage = nil,
53 .dataTypeSpecific.className = GPBStringifySymbol(GPBFileDescriptorProto) ,
54 .fieldOptions = NULL,
55 },
56 };
57 GPBDescriptor *localDescriptor =
58 [GPBDescriptor allocDescriptorForClass:[GPBFileDescriptorSet class]
59 rootClass:[GPBDescriptorRoot class]
60 file:GPBDescriptorRoot_FileDescriptor( )
61 fields:fields
62 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
63 oneofs:NULL
64 oneofCount:0
65 enums:NULL
66 enumCount:0
67 ranges:NULL
68 rangeCount:0
69 storageSize:sizeof(GPBFileDescriptorSet__stor age_)
70 wireFormat:NO];
71 NSAssert(descriptor == nil, @"Startup recursed!");
72 descriptor = localDescriptor;
73 }
74 return descriptor;
75 }
76
77 @end
78
79 #pragma mark - GPBFileDescriptorProto
80
81 @implementation GPBFileDescriptorProto
82
83 @dynamic hasName, name;
84 @dynamic hasPackage, package;
85 @dynamic dependencyArray, dependencyArray_Count;
86 @dynamic publicDependencyArray, publicDependencyArray_Count;
87 @dynamic weakDependencyArray, weakDependencyArray_Count;
88 @dynamic messageTypeArray, messageTypeArray_Count;
89 @dynamic enumTypeArray, enumTypeArray_Count;
90 @dynamic serviceArray, serviceArray_Count;
91 @dynamic extensionArray, extensionArray_Count;
92 @dynamic hasOptions, options;
93 @dynamic hasSourceCodeInfo, sourceCodeInfo;
94 @dynamic hasSyntax, syntax;
95
96 typedef struct GPBFileDescriptorProto__storage_ {
97 uint32_t _has_storage_[1];
98 NSString *name;
99 NSString *package;
100 NSMutableArray *dependencyArray;
101 NSMutableArray *messageTypeArray;
102 NSMutableArray *enumTypeArray;
103 NSMutableArray *serviceArray;
104 NSMutableArray *extensionArray;
105 GPBFileOptions *options;
106 GPBSourceCodeInfo *sourceCodeInfo;
107 GPBInt32Array *publicDependencyArray;
108 GPBInt32Array *weakDependencyArray;
109 NSString *syntax;
110 } GPBFileDescriptorProto__storage_;
111
112 // This method is threadsafe because it is initially called
113 // in +initialize for each subclass.
114 + (GPBDescriptor *)descriptor {
115 static GPBDescriptor *descriptor = nil;
116 if (!descriptor) {
117 static GPBMessageFieldDescription fields[] = {
118 {
119 .name = "name",
120 .number = GPBFileDescriptorProto_FieldNumber_Name,
121 .hasIndex = 0,
122 .flags = GPBFieldOptional,
123 .dataType = GPBDataTypeString,
124 .offset = offsetof(GPBFileDescriptorProto__storage_, name),
125 .defaultValue.valueString = nil,
126 .dataTypeSpecific.className = NULL,
127 .fieldOptions = NULL,
128 },
129 {
130 .name = "package",
131 .number = GPBFileDescriptorProto_FieldNumber_Package,
132 .hasIndex = 1,
133 .flags = GPBFieldOptional,
134 .dataType = GPBDataTypeString,
135 .offset = offsetof(GPBFileDescriptorProto__storage_, package),
136 .defaultValue.valueString = nil,
137 .dataTypeSpecific.className = NULL,
138 .fieldOptions = NULL,
139 },
140 {
141 .name = "dependencyArray",
142 .number = GPBFileDescriptorProto_FieldNumber_DependencyArray,
143 .hasIndex = GPBNoHasBit,
144 .flags = GPBFieldRepeated,
145 .dataType = GPBDataTypeString,
146 .offset = offsetof(GPBFileDescriptorProto__storage_, dependencyArray),
147 .defaultValue.valueMessage = nil,
148 .dataTypeSpecific.className = NULL,
149 .fieldOptions = NULL,
150 },
151 {
152 .name = "messageTypeArray",
153 .number = GPBFileDescriptorProto_FieldNumber_MessageTypeArray,
154 .hasIndex = GPBNoHasBit,
155 .flags = GPBFieldRepeated,
156 .dataType = GPBDataTypeMessage,
157 .offset = offsetof(GPBFileDescriptorProto__storage_, messageTypeArray),
158 .defaultValue.valueMessage = nil,
159 .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto),
160 .fieldOptions = NULL,
161 },
162 {
163 .name = "enumTypeArray",
164 .number = GPBFileDescriptorProto_FieldNumber_EnumTypeArray,
165 .hasIndex = GPBNoHasBit,
166 .flags = GPBFieldRepeated,
167 .dataType = GPBDataTypeMessage,
168 .offset = offsetof(GPBFileDescriptorProto__storage_, enumTypeArray),
169 .defaultValue.valueMessage = nil,
170 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumDescriptorProto) ,
171 .fieldOptions = NULL,
172 },
173 {
174 .name = "serviceArray",
175 .number = GPBFileDescriptorProto_FieldNumber_ServiceArray,
176 .hasIndex = GPBNoHasBit,
177 .flags = GPBFieldRepeated,
178 .dataType = GPBDataTypeMessage,
179 .offset = offsetof(GPBFileDescriptorProto__storage_, serviceArray),
180 .defaultValue.valueMessage = nil,
181 .dataTypeSpecific.className = GPBStringifySymbol(GPBServiceDescriptorPro to),
182 .fieldOptions = NULL,
183 },
184 {
185 .name = "extensionArray",
186 .number = GPBFileDescriptorProto_FieldNumber_ExtensionArray,
187 .hasIndex = GPBNoHasBit,
188 .flags = GPBFieldRepeated,
189 .dataType = GPBDataTypeMessage,
190 .offset = offsetof(GPBFileDescriptorProto__storage_, extensionArray),
191 .defaultValue.valueMessage = nil,
192 .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto ),
193 .fieldOptions = NULL,
194 },
195 {
196 .name = "options",
197 .number = GPBFileDescriptorProto_FieldNumber_Options,
198 .hasIndex = 9,
199 .flags = GPBFieldOptional,
200 .dataType = GPBDataTypeMessage,
201 .offset = offsetof(GPBFileDescriptorProto__storage_, options),
202 .defaultValue.valueMessage = nil,
203 .dataTypeSpecific.className = GPBStringifySymbol(GPBFileOptions),
204 .fieldOptions = NULL,
205 },
206 {
207 .name = "sourceCodeInfo",
208 .number = GPBFileDescriptorProto_FieldNumber_SourceCodeInfo,
209 .hasIndex = 10,
210 .flags = GPBFieldOptional,
211 .dataType = GPBDataTypeMessage,
212 .offset = offsetof(GPBFileDescriptorProto__storage_, sourceCodeInfo),
213 .defaultValue.valueMessage = nil,
214 .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo),
215 .fieldOptions = NULL,
216 },
217 {
218 .name = "publicDependencyArray",
219 .number = GPBFileDescriptorProto_FieldNumber_PublicDependencyArray,
220 .hasIndex = GPBNoHasBit,
221 .flags = GPBFieldRepeated,
222 .dataType = GPBDataTypeInt32,
223 .offset = offsetof(GPBFileDescriptorProto__storage_, publicDependencyArr ay),
224 .defaultValue.valueMessage = nil,
225 .dataTypeSpecific.className = NULL,
226 .fieldOptions = NULL,
227 },
228 {
229 .name = "weakDependencyArray",
230 .number = GPBFileDescriptorProto_FieldNumber_WeakDependencyArray,
231 .hasIndex = GPBNoHasBit,
232 .flags = GPBFieldRepeated,
233 .dataType = GPBDataTypeInt32,
234 .offset = offsetof(GPBFileDescriptorProto__storage_, weakDependencyArray ),
235 .defaultValue.valueMessage = nil,
236 .dataTypeSpecific.className = NULL,
237 .fieldOptions = NULL,
238 },
239 {
240 .name = "syntax",
241 .number = GPBFileDescriptorProto_FieldNumber_Syntax,
242 .hasIndex = 11,
243 .flags = GPBFieldOptional,
244 .dataType = GPBDataTypeString,
245 .offset = offsetof(GPBFileDescriptorProto__storage_, syntax),
246 .defaultValue.valueString = nil,
247 .dataTypeSpecific.className = NULL,
248 .fieldOptions = NULL,
249 },
250 };
251 GPBDescriptor *localDescriptor =
252 [GPBDescriptor allocDescriptorForClass:[GPBFileDescriptorProto class]
253 rootClass:[GPBDescriptorRoot class]
254 file:GPBDescriptorRoot_FileDescriptor( )
255 fields:fields
256 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
257 oneofs:NULL
258 oneofCount:0
259 enums:NULL
260 enumCount:0
261 ranges:NULL
262 rangeCount:0
263 storageSize:sizeof(GPBFileDescriptorProto__st orage_)
264 wireFormat:NO];
265 NSAssert(descriptor == nil, @"Startup recursed!");
266 descriptor = localDescriptor;
267 }
268 return descriptor;
269 }
270
271 @end
272
273 #pragma mark - GPBDescriptorProto
274
275 @implementation GPBDescriptorProto
276
277 @dynamic hasName, name;
278 @dynamic fieldArray, fieldArray_Count;
279 @dynamic extensionArray, extensionArray_Count;
280 @dynamic nestedTypeArray, nestedTypeArray_Count;
281 @dynamic enumTypeArray, enumTypeArray_Count;
282 @dynamic extensionRangeArray, extensionRangeArray_Count;
283 @dynamic oneofDeclArray, oneofDeclArray_Count;
284 @dynamic hasOptions, options;
285 @dynamic reservedRangeArray, reservedRangeArray_Count;
286 @dynamic reservedNameArray, reservedNameArray_Count;
287
288 typedef struct GPBDescriptorProto__storage_ {
289 uint32_t _has_storage_[1];
290 NSString *name;
291 NSMutableArray *fieldArray;
292 NSMutableArray *nestedTypeArray;
293 NSMutableArray *enumTypeArray;
294 NSMutableArray *extensionRangeArray;
295 NSMutableArray *extensionArray;
296 GPBMessageOptions *options;
297 NSMutableArray *oneofDeclArray;
298 NSMutableArray *reservedRangeArray;
299 NSMutableArray *reservedNameArray;
300 } GPBDescriptorProto__storage_;
301
302 // This method is threadsafe because it is initially called
303 // in +initialize for each subclass.
304 + (GPBDescriptor *)descriptor {
305 static GPBDescriptor *descriptor = nil;
306 if (!descriptor) {
307 static GPBMessageFieldDescription fields[] = {
308 {
309 .name = "name",
310 .number = GPBDescriptorProto_FieldNumber_Name,
311 .hasIndex = 0,
312 .flags = GPBFieldOptional,
313 .dataType = GPBDataTypeString,
314 .offset = offsetof(GPBDescriptorProto__storage_, name),
315 .defaultValue.valueString = nil,
316 .dataTypeSpecific.className = NULL,
317 .fieldOptions = NULL,
318 },
319 {
320 .name = "fieldArray",
321 .number = GPBDescriptorProto_FieldNumber_FieldArray,
322 .hasIndex = GPBNoHasBit,
323 .flags = GPBFieldRepeated,
324 .dataType = GPBDataTypeMessage,
325 .offset = offsetof(GPBDescriptorProto__storage_, fieldArray),
326 .defaultValue.valueMessage = nil,
327 .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto ),
328 .fieldOptions = NULL,
329 },
330 {
331 .name = "nestedTypeArray",
332 .number = GPBDescriptorProto_FieldNumber_NestedTypeArray,
333 .hasIndex = GPBNoHasBit,
334 .flags = GPBFieldRepeated,
335 .dataType = GPBDataTypeMessage,
336 .offset = offsetof(GPBDescriptorProto__storage_, nestedTypeArray),
337 .defaultValue.valueMessage = nil,
338 .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto),
339 .fieldOptions = NULL,
340 },
341 {
342 .name = "enumTypeArray",
343 .number = GPBDescriptorProto_FieldNumber_EnumTypeArray,
344 .hasIndex = GPBNoHasBit,
345 .flags = GPBFieldRepeated,
346 .dataType = GPBDataTypeMessage,
347 .offset = offsetof(GPBDescriptorProto__storage_, enumTypeArray),
348 .defaultValue.valueMessage = nil,
349 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumDescriptorProto) ,
350 .fieldOptions = NULL,
351 },
352 {
353 .name = "extensionRangeArray",
354 .number = GPBDescriptorProto_FieldNumber_ExtensionRangeArray,
355 .hasIndex = GPBNoHasBit,
356 .flags = GPBFieldRepeated,
357 .dataType = GPBDataTypeMessage,
358 .offset = offsetof(GPBDescriptorProto__storage_, extensionRangeArray),
359 .defaultValue.valueMessage = nil,
360 .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto_Exte nsionRange),
361 .fieldOptions = NULL,
362 },
363 {
364 .name = "extensionArray",
365 .number = GPBDescriptorProto_FieldNumber_ExtensionArray,
366 .hasIndex = GPBNoHasBit,
367 .flags = GPBFieldRepeated,
368 .dataType = GPBDataTypeMessage,
369 .offset = offsetof(GPBDescriptorProto__storage_, extensionArray),
370 .defaultValue.valueMessage = nil,
371 .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldDescriptorProto ),
372 .fieldOptions = NULL,
373 },
374 {
375 .name = "options",
376 .number = GPBDescriptorProto_FieldNumber_Options,
377 .hasIndex = 7,
378 .flags = GPBFieldOptional,
379 .dataType = GPBDataTypeMessage,
380 .offset = offsetof(GPBDescriptorProto__storage_, options),
381 .defaultValue.valueMessage = nil,
382 .dataTypeSpecific.className = GPBStringifySymbol(GPBMessageOptions),
383 .fieldOptions = NULL,
384 },
385 {
386 .name = "oneofDeclArray",
387 .number = GPBDescriptorProto_FieldNumber_OneofDeclArray,
388 .hasIndex = GPBNoHasBit,
389 .flags = GPBFieldRepeated,
390 .dataType = GPBDataTypeMessage,
391 .offset = offsetof(GPBDescriptorProto__storage_, oneofDeclArray),
392 .defaultValue.valueMessage = nil,
393 .dataTypeSpecific.className = GPBStringifySymbol(GPBOneofDescriptorProto ),
394 .fieldOptions = NULL,
395 },
396 {
397 .name = "reservedRangeArray",
398 .number = GPBDescriptorProto_FieldNumber_ReservedRangeArray,
399 .hasIndex = GPBNoHasBit,
400 .flags = GPBFieldRepeated,
401 .dataType = GPBDataTypeMessage,
402 .offset = offsetof(GPBDescriptorProto__storage_, reservedRangeArray),
403 .defaultValue.valueMessage = nil,
404 .dataTypeSpecific.className = GPBStringifySymbol(GPBDescriptorProto_Rese rvedRange),
405 .fieldOptions = NULL,
406 },
407 {
408 .name = "reservedNameArray",
409 .number = GPBDescriptorProto_FieldNumber_ReservedNameArray,
410 .hasIndex = GPBNoHasBit,
411 .flags = GPBFieldRepeated,
412 .dataType = GPBDataTypeString,
413 .offset = offsetof(GPBDescriptorProto__storage_, reservedNameArray),
414 .defaultValue.valueMessage = nil,
415 .dataTypeSpecific.className = NULL,
416 .fieldOptions = NULL,
417 },
418 };
419 GPBDescriptor *localDescriptor =
420 [GPBDescriptor allocDescriptorForClass:[GPBDescriptorProto class]
421 rootClass:[GPBDescriptorRoot class]
422 file:GPBDescriptorRoot_FileDescriptor( )
423 fields:fields
424 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
425 oneofs:NULL
426 oneofCount:0
427 enums:NULL
428 enumCount:0
429 ranges:NULL
430 rangeCount:0
431 storageSize:sizeof(GPBDescriptorProto__storag e_)
432 wireFormat:NO];
433 NSAssert(descriptor == nil, @"Startup recursed!");
434 descriptor = localDescriptor;
435 }
436 return descriptor;
437 }
438
439 @end
440
441 #pragma mark - GPBDescriptorProto_ExtensionRange
442
443 @implementation GPBDescriptorProto_ExtensionRange
444
445 @dynamic hasStart, start;
446 @dynamic hasEnd, end;
447
448 typedef struct GPBDescriptorProto_ExtensionRange__storage_ {
449 uint32_t _has_storage_[1];
450 int32_t start;
451 int32_t end;
452 } GPBDescriptorProto_ExtensionRange__storage_;
453
454 // This method is threadsafe because it is initially called
455 // in +initialize for each subclass.
456 + (GPBDescriptor *)descriptor {
457 static GPBDescriptor *descriptor = nil;
458 if (!descriptor) {
459 static GPBMessageFieldDescription fields[] = {
460 {
461 .name = "start",
462 .number = GPBDescriptorProto_ExtensionRange_FieldNumber_Start,
463 .hasIndex = 0,
464 .flags = GPBFieldOptional,
465 .dataType = GPBDataTypeInt32,
466 .offset = offsetof(GPBDescriptorProto_ExtensionRange__storage_, start),
467 .defaultValue.valueInt32 = 0,
468 .dataTypeSpecific.className = NULL,
469 .fieldOptions = NULL,
470 },
471 {
472 .name = "end",
473 .number = GPBDescriptorProto_ExtensionRange_FieldNumber_End,
474 .hasIndex = 1,
475 .flags = GPBFieldOptional,
476 .dataType = GPBDataTypeInt32,
477 .offset = offsetof(GPBDescriptorProto_ExtensionRange__storage_, end),
478 .defaultValue.valueInt32 = 0,
479 .dataTypeSpecific.className = NULL,
480 .fieldOptions = NULL,
481 },
482 };
483 GPBDescriptor *localDescriptor =
484 [GPBDescriptor allocDescriptorForClass:[GPBDescriptorProto_ExtensionRang e class]
485 rootClass:[GPBDescriptorRoot class]
486 file:GPBDescriptorRoot_FileDescriptor( )
487 fields:fields
488 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
489 oneofs:NULL
490 oneofCount:0
491 enums:NULL
492 enumCount:0
493 ranges:NULL
494 rangeCount:0
495 storageSize:sizeof(GPBDescriptorProto_Extensi onRange__storage_)
496 wireFormat:NO];
497 NSAssert(descriptor == nil, @"Startup recursed!");
498 descriptor = localDescriptor;
499 }
500 return descriptor;
501 }
502
503 @end
504
505 #pragma mark - GPBDescriptorProto_ReservedRange
506
507 @implementation GPBDescriptorProto_ReservedRange
508
509 @dynamic hasStart, start;
510 @dynamic hasEnd, end;
511
512 typedef struct GPBDescriptorProto_ReservedRange__storage_ {
513 uint32_t _has_storage_[1];
514 int32_t start;
515 int32_t end;
516 } GPBDescriptorProto_ReservedRange__storage_;
517
518 // This method is threadsafe because it is initially called
519 // in +initialize for each subclass.
520 + (GPBDescriptor *)descriptor {
521 static GPBDescriptor *descriptor = nil;
522 if (!descriptor) {
523 static GPBMessageFieldDescription fields[] = {
524 {
525 .name = "start",
526 .number = GPBDescriptorProto_ReservedRange_FieldNumber_Start,
527 .hasIndex = 0,
528 .flags = GPBFieldOptional,
529 .dataType = GPBDataTypeInt32,
530 .offset = offsetof(GPBDescriptorProto_ReservedRange__storage_, start),
531 .defaultValue.valueInt32 = 0,
532 .dataTypeSpecific.className = NULL,
533 .fieldOptions = NULL,
534 },
535 {
536 .name = "end",
537 .number = GPBDescriptorProto_ReservedRange_FieldNumber_End,
538 .hasIndex = 1,
539 .flags = GPBFieldOptional,
540 .dataType = GPBDataTypeInt32,
541 .offset = offsetof(GPBDescriptorProto_ReservedRange__storage_, end),
542 .defaultValue.valueInt32 = 0,
543 .dataTypeSpecific.className = NULL,
544 .fieldOptions = NULL,
545 },
546 };
547 GPBDescriptor *localDescriptor =
548 [GPBDescriptor allocDescriptorForClass:[GPBDescriptorProto_ReservedRange class]
549 rootClass:[GPBDescriptorRoot class]
550 file:GPBDescriptorRoot_FileDescriptor( )
551 fields:fields
552 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
553 oneofs:NULL
554 oneofCount:0
555 enums:NULL
556 enumCount:0
557 ranges:NULL
558 rangeCount:0
559 storageSize:sizeof(GPBDescriptorProto_Reserve dRange__storage_)
560 wireFormat:NO];
561 NSAssert(descriptor == nil, @"Startup recursed!");
562 descriptor = localDescriptor;
563 }
564 return descriptor;
565 }
566
567 @end
568
569 #pragma mark - GPBFieldDescriptorProto
570
571 @implementation GPBFieldDescriptorProto
572
573 @dynamic hasName, name;
574 @dynamic hasNumber, number;
575 @dynamic hasLabel, label;
576 @dynamic hasType, type;
577 @dynamic hasTypeName, typeName;
578 @dynamic hasExtendee, extendee;
579 @dynamic hasDefaultValue, defaultValue;
580 @dynamic hasOneofIndex, oneofIndex;
581 @dynamic hasJsonName, jsonName;
582 @dynamic hasOptions, options;
583
584 typedef struct GPBFieldDescriptorProto__storage_ {
585 uint32_t _has_storage_[1];
586 int32_t number;
587 GPBFieldDescriptorProto_Label label;
588 GPBFieldDescriptorProto_Type type;
589 int32_t oneofIndex;
590 NSString *name;
591 NSString *extendee;
592 NSString *typeName;
593 NSString *defaultValue;
594 GPBFieldOptions *options;
595 NSString *jsonName;
596 } GPBFieldDescriptorProto__storage_;
597
598 // This method is threadsafe because it is initially called
599 // in +initialize for each subclass.
600 + (GPBDescriptor *)descriptor {
601 static GPBDescriptor *descriptor = nil;
602 if (!descriptor) {
603 static GPBMessageFieldDescription fields[] = {
604 {
605 .name = "name",
606 .number = GPBFieldDescriptorProto_FieldNumber_Name,
607 .hasIndex = 0,
608 .flags = GPBFieldOptional,
609 .dataType = GPBDataTypeString,
610 .offset = offsetof(GPBFieldDescriptorProto__storage_, name),
611 .defaultValue.valueString = nil,
612 .dataTypeSpecific.className = NULL,
613 .fieldOptions = NULL,
614 },
615 {
616 .name = "extendee",
617 .number = GPBFieldDescriptorProto_FieldNumber_Extendee,
618 .hasIndex = 5,
619 .flags = GPBFieldOptional,
620 .dataType = GPBDataTypeString,
621 .offset = offsetof(GPBFieldDescriptorProto__storage_, extendee),
622 .defaultValue.valueString = nil,
623 .dataTypeSpecific.className = NULL,
624 .fieldOptions = NULL,
625 },
626 {
627 .name = "number",
628 .number = GPBFieldDescriptorProto_FieldNumber_Number,
629 .hasIndex = 1,
630 .flags = GPBFieldOptional,
631 .dataType = GPBDataTypeInt32,
632 .offset = offsetof(GPBFieldDescriptorProto__storage_, number),
633 .defaultValue.valueInt32 = 0,
634 .dataTypeSpecific.className = NULL,
635 .fieldOptions = NULL,
636 },
637 {
638 .name = "label",
639 .number = GPBFieldDescriptorProto_FieldNumber_Label,
640 .hasIndex = 2,
641 .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
642 .dataType = GPBDataTypeEnum,
643 .offset = offsetof(GPBFieldDescriptorProto__storage_, label),
644 .defaultValue.valueEnum = GPBFieldDescriptorProto_Label_LabelOptional,
645 .dataTypeSpecific.enumDescFunc = GPBFieldDescriptorProto_Label_EnumDescr iptor,
646 .fieldOptions = NULL,
647 },
648 {
649 .name = "type",
650 .number = GPBFieldDescriptorProto_FieldNumber_Type,
651 .hasIndex = 3,
652 .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
653 .dataType = GPBDataTypeEnum,
654 .offset = offsetof(GPBFieldDescriptorProto__storage_, type),
655 .defaultValue.valueEnum = GPBFieldDescriptorProto_Type_TypeDouble,
656 .dataTypeSpecific.enumDescFunc = GPBFieldDescriptorProto_Type_EnumDescri ptor,
657 .fieldOptions = NULL,
658 },
659 {
660 .name = "typeName",
661 .number = GPBFieldDescriptorProto_FieldNumber_TypeName,
662 .hasIndex = 4,
663 .flags = GPBFieldOptional,
664 .dataType = GPBDataTypeString,
665 .offset = offsetof(GPBFieldDescriptorProto__storage_, typeName),
666 .defaultValue.valueString = nil,
667 .dataTypeSpecific.className = NULL,
668 .fieldOptions = NULL,
669 },
670 {
671 .name = "defaultValue",
672 .number = GPBFieldDescriptorProto_FieldNumber_DefaultValue,
673 .hasIndex = 6,
674 .flags = GPBFieldOptional,
675 .dataType = GPBDataTypeString,
676 .offset = offsetof(GPBFieldDescriptorProto__storage_, defaultValue),
677 .defaultValue.valueString = nil,
678 .dataTypeSpecific.className = NULL,
679 .fieldOptions = NULL,
680 },
681 {
682 .name = "options",
683 .number = GPBFieldDescriptorProto_FieldNumber_Options,
684 .hasIndex = 9,
685 .flags = GPBFieldOptional,
686 .dataType = GPBDataTypeMessage,
687 .offset = offsetof(GPBFieldDescriptorProto__storage_, options),
688 .defaultValue.valueMessage = nil,
689 .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldOptions),
690 .fieldOptions = NULL,
691 },
692 {
693 .name = "oneofIndex",
694 .number = GPBFieldDescriptorProto_FieldNumber_OneofIndex,
695 .hasIndex = 7,
696 .flags = GPBFieldOptional,
697 .dataType = GPBDataTypeInt32,
698 .offset = offsetof(GPBFieldDescriptorProto__storage_, oneofIndex),
699 .defaultValue.valueInt32 = 0,
700 .dataTypeSpecific.className = NULL,
701 .fieldOptions = NULL,
702 },
703 {
704 .name = "jsonName",
705 .number = GPBFieldDescriptorProto_FieldNumber_JsonName,
706 .hasIndex = 8,
707 .flags = GPBFieldOptional,
708 .dataType = GPBDataTypeString,
709 .offset = offsetof(GPBFieldDescriptorProto__storage_, jsonName),
710 .defaultValue.valueString = nil,
711 .dataTypeSpecific.className = NULL,
712 .fieldOptions = NULL,
713 },
714 };
715 static GPBMessageEnumDescription enums[] = {
716 { .enumDescriptorFunc = GPBFieldDescriptorProto_Type_EnumDescriptor },
717 { .enumDescriptorFunc = GPBFieldDescriptorProto_Label_EnumDescriptor },
718 };
719 GPBDescriptor *localDescriptor =
720 [GPBDescriptor allocDescriptorForClass:[GPBFieldDescriptorProto class]
721 rootClass:[GPBDescriptorRoot class]
722 file:GPBDescriptorRoot_FileDescriptor( )
723 fields:fields
724 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
725 oneofs:NULL
726 oneofCount:0
727 enums:enums
728 enumCount:sizeof(enums) / sizeof(GPBMessage EnumDescription)
729 ranges:NULL
730 rangeCount:0
731 storageSize:sizeof(GPBFieldDescriptorProto__s torage_)
732 wireFormat:NO];
733 NSAssert(descriptor == nil, @"Startup recursed!");
734 descriptor = localDescriptor;
735 }
736 return descriptor;
737 }
738
739 @end
740
741 #pragma mark - Enum GPBFieldDescriptorProto_Type
742
743 GPBEnumDescriptor *GPBFieldDescriptorProto_Type_EnumDescriptor(void) {
744 static GPBEnumDescriptor *descriptor = NULL;
745 if (!descriptor) {
746 static GPBMessageEnumValueDescription values[] = {
747 { .name = "TypeDouble", .number = GPBFieldDescriptorProto_Type_TypeDouble },
748 { .name = "TypeFloat", .number = GPBFieldDescriptorProto_Type_TypeFloat },
749 { .name = "TypeInt64", .number = GPBFieldDescriptorProto_Type_TypeInt64 },
750 { .name = "TypeUint64", .number = GPBFieldDescriptorProto_Type_TypeUint64 },
751 { .name = "TypeInt32", .number = GPBFieldDescriptorProto_Type_TypeInt32 },
752 { .name = "TypeFixed64", .number = GPBFieldDescriptorProto_Type_TypeFixed6 4 },
753 { .name = "TypeFixed32", .number = GPBFieldDescriptorProto_Type_TypeFixed3 2 },
754 { .name = "TypeBool", .number = GPBFieldDescriptorProto_Type_TypeBool },
755 { .name = "TypeString", .number = GPBFieldDescriptorProto_Type_TypeString },
756 { .name = "TypeGroup", .number = GPBFieldDescriptorProto_Type_TypeGroup },
757 { .name = "TypeMessage", .number = GPBFieldDescriptorProto_Type_TypeMessag e },
758 { .name = "TypeBytes", .number = GPBFieldDescriptorProto_Type_TypeBytes },
759 { .name = "TypeUint32", .number = GPBFieldDescriptorProto_Type_TypeUint32 },
760 { .name = "TypeEnum", .number = GPBFieldDescriptorProto_Type_TypeEnum },
761 { .name = "TypeSfixed32", .number = GPBFieldDescriptorProto_Type_TypeSfixe d32 },
762 { .name = "TypeSfixed64", .number = GPBFieldDescriptorProto_Type_TypeSfixe d64 },
763 { .name = "TypeSint32", .number = GPBFieldDescriptorProto_Type_TypeSint32 },
764 { .name = "TypeSint64", .number = GPBFieldDescriptorProto_Type_TypeSint64 },
765 };
766 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldDescriptorProto_Type)
767 values:values
768 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
769 enumVerifier:GPBFieldDescriptorProt o_Type_IsValidValue];
770 }
771 return descriptor;
772 }
773
774 BOOL GPBFieldDescriptorProto_Type_IsValidValue(int32_t value__) {
775 switch (value__) {
776 case GPBFieldDescriptorProto_Type_TypeDouble:
777 case GPBFieldDescriptorProto_Type_TypeFloat:
778 case GPBFieldDescriptorProto_Type_TypeInt64:
779 case GPBFieldDescriptorProto_Type_TypeUint64:
780 case GPBFieldDescriptorProto_Type_TypeInt32:
781 case GPBFieldDescriptorProto_Type_TypeFixed64:
782 case GPBFieldDescriptorProto_Type_TypeFixed32:
783 case GPBFieldDescriptorProto_Type_TypeBool:
784 case GPBFieldDescriptorProto_Type_TypeString:
785 case GPBFieldDescriptorProto_Type_TypeGroup:
786 case GPBFieldDescriptorProto_Type_TypeMessage:
787 case GPBFieldDescriptorProto_Type_TypeBytes:
788 case GPBFieldDescriptorProto_Type_TypeUint32:
789 case GPBFieldDescriptorProto_Type_TypeEnum:
790 case GPBFieldDescriptorProto_Type_TypeSfixed32:
791 case GPBFieldDescriptorProto_Type_TypeSfixed64:
792 case GPBFieldDescriptorProto_Type_TypeSint32:
793 case GPBFieldDescriptorProto_Type_TypeSint64:
794 return YES;
795 default:
796 return NO;
797 }
798 }
799
800 #pragma mark - Enum GPBFieldDescriptorProto_Label
801
802 GPBEnumDescriptor *GPBFieldDescriptorProto_Label_EnumDescriptor(void) {
803 static GPBEnumDescriptor *descriptor = NULL;
804 if (!descriptor) {
805 static GPBMessageEnumValueDescription values[] = {
806 { .name = "LabelOptional", .number = GPBFieldDescriptorProto_Label_LabelOp tional },
807 { .name = "LabelRequired", .number = GPBFieldDescriptorProto_Label_LabelRe quired },
808 { .name = "LabelRepeated", .number = GPBFieldDescriptorProto_Label_LabelRe peated },
809 };
810 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldDescriptorProto_Label)
811 values:values
812 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
813 enumVerifier:GPBFieldDescriptorProt o_Label_IsValidValue];
814 }
815 return descriptor;
816 }
817
818 BOOL GPBFieldDescriptorProto_Label_IsValidValue(int32_t value__) {
819 switch (value__) {
820 case GPBFieldDescriptorProto_Label_LabelOptional:
821 case GPBFieldDescriptorProto_Label_LabelRequired:
822 case GPBFieldDescriptorProto_Label_LabelRepeated:
823 return YES;
824 default:
825 return NO;
826 }
827 }
828
829 #pragma mark - GPBOneofDescriptorProto
830
831 @implementation GPBOneofDescriptorProto
832
833 @dynamic hasName, name;
834
835 typedef struct GPBOneofDescriptorProto__storage_ {
836 uint32_t _has_storage_[1];
837 NSString *name;
838 } GPBOneofDescriptorProto__storage_;
839
840 // This method is threadsafe because it is initially called
841 // in +initialize for each subclass.
842 + (GPBDescriptor *)descriptor {
843 static GPBDescriptor *descriptor = nil;
844 if (!descriptor) {
845 static GPBMessageFieldDescription fields[] = {
846 {
847 .name = "name",
848 .number = GPBOneofDescriptorProto_FieldNumber_Name,
849 .hasIndex = 0,
850 .flags = GPBFieldOptional,
851 .dataType = GPBDataTypeString,
852 .offset = offsetof(GPBOneofDescriptorProto__storage_, name),
853 .defaultValue.valueString = nil,
854 .dataTypeSpecific.className = NULL,
855 .fieldOptions = NULL,
856 },
857 };
858 GPBDescriptor *localDescriptor =
859 [GPBDescriptor allocDescriptorForClass:[GPBOneofDescriptorProto class]
860 rootClass:[GPBDescriptorRoot class]
861 file:GPBDescriptorRoot_FileDescriptor( )
862 fields:fields
863 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
864 oneofs:NULL
865 oneofCount:0
866 enums:NULL
867 enumCount:0
868 ranges:NULL
869 rangeCount:0
870 storageSize:sizeof(GPBOneofDescriptorProto__s torage_)
871 wireFormat:NO];
872 NSAssert(descriptor == nil, @"Startup recursed!");
873 descriptor = localDescriptor;
874 }
875 return descriptor;
876 }
877
878 @end
879
880 #pragma mark - GPBEnumDescriptorProto
881
882 @implementation GPBEnumDescriptorProto
883
884 @dynamic hasName, name;
885 @dynamic valueArray, valueArray_Count;
886 @dynamic hasOptions, options;
887
888 typedef struct GPBEnumDescriptorProto__storage_ {
889 uint32_t _has_storage_[1];
890 NSString *name;
891 NSMutableArray *valueArray;
892 GPBEnumOptions *options;
893 } GPBEnumDescriptorProto__storage_;
894
895 // This method is threadsafe because it is initially called
896 // in +initialize for each subclass.
897 + (GPBDescriptor *)descriptor {
898 static GPBDescriptor *descriptor = nil;
899 if (!descriptor) {
900 static GPBMessageFieldDescription fields[] = {
901 {
902 .name = "name",
903 .number = GPBEnumDescriptorProto_FieldNumber_Name,
904 .hasIndex = 0,
905 .flags = GPBFieldOptional,
906 .dataType = GPBDataTypeString,
907 .offset = offsetof(GPBEnumDescriptorProto__storage_, name),
908 .defaultValue.valueString = nil,
909 .dataTypeSpecific.className = NULL,
910 .fieldOptions = NULL,
911 },
912 {
913 .name = "valueArray",
914 .number = GPBEnumDescriptorProto_FieldNumber_ValueArray,
915 .hasIndex = GPBNoHasBit,
916 .flags = GPBFieldRepeated,
917 .dataType = GPBDataTypeMessage,
918 .offset = offsetof(GPBEnumDescriptorProto__storage_, valueArray),
919 .defaultValue.valueMessage = nil,
920 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumValueDescriptorP roto),
921 .fieldOptions = NULL,
922 },
923 {
924 .name = "options",
925 .number = GPBEnumDescriptorProto_FieldNumber_Options,
926 .hasIndex = 2,
927 .flags = GPBFieldOptional,
928 .dataType = GPBDataTypeMessage,
929 .offset = offsetof(GPBEnumDescriptorProto__storage_, options),
930 .defaultValue.valueMessage = nil,
931 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumOptions),
932 .fieldOptions = NULL,
933 },
934 };
935 GPBDescriptor *localDescriptor =
936 [GPBDescriptor allocDescriptorForClass:[GPBEnumDescriptorProto class]
937 rootClass:[GPBDescriptorRoot class]
938 file:GPBDescriptorRoot_FileDescriptor( )
939 fields:fields
940 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
941 oneofs:NULL
942 oneofCount:0
943 enums:NULL
944 enumCount:0
945 ranges:NULL
946 rangeCount:0
947 storageSize:sizeof(GPBEnumDescriptorProto__st orage_)
948 wireFormat:NO];
949 NSAssert(descriptor == nil, @"Startup recursed!");
950 descriptor = localDescriptor;
951 }
952 return descriptor;
953 }
954
955 @end
956
957 #pragma mark - GPBEnumValueDescriptorProto
958
959 @implementation GPBEnumValueDescriptorProto
960
961 @dynamic hasName, name;
962 @dynamic hasNumber, number;
963 @dynamic hasOptions, options;
964
965 typedef struct GPBEnumValueDescriptorProto__storage_ {
966 uint32_t _has_storage_[1];
967 int32_t number;
968 NSString *name;
969 GPBEnumValueOptions *options;
970 } GPBEnumValueDescriptorProto__storage_;
971
972 // This method is threadsafe because it is initially called
973 // in +initialize for each subclass.
974 + (GPBDescriptor *)descriptor {
975 static GPBDescriptor *descriptor = nil;
976 if (!descriptor) {
977 static GPBMessageFieldDescription fields[] = {
978 {
979 .name = "name",
980 .number = GPBEnumValueDescriptorProto_FieldNumber_Name,
981 .hasIndex = 0,
982 .flags = GPBFieldOptional,
983 .dataType = GPBDataTypeString,
984 .offset = offsetof(GPBEnumValueDescriptorProto__storage_, name),
985 .defaultValue.valueString = nil,
986 .dataTypeSpecific.className = NULL,
987 .fieldOptions = NULL,
988 },
989 {
990 .name = "number",
991 .number = GPBEnumValueDescriptorProto_FieldNumber_Number,
992 .hasIndex = 1,
993 .flags = GPBFieldOptional,
994 .dataType = GPBDataTypeInt32,
995 .offset = offsetof(GPBEnumValueDescriptorProto__storage_, number),
996 .defaultValue.valueInt32 = 0,
997 .dataTypeSpecific.className = NULL,
998 .fieldOptions = NULL,
999 },
1000 {
1001 .name = "options",
1002 .number = GPBEnumValueDescriptorProto_FieldNumber_Options,
1003 .hasIndex = 2,
1004 .flags = GPBFieldOptional,
1005 .dataType = GPBDataTypeMessage,
1006 .offset = offsetof(GPBEnumValueDescriptorProto__storage_, options),
1007 .defaultValue.valueMessage = nil,
1008 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumValueOptions),
1009 .fieldOptions = NULL,
1010 },
1011 };
1012 GPBDescriptor *localDescriptor =
1013 [GPBDescriptor allocDescriptorForClass:[GPBEnumValueDescriptorProto clas s]
1014 rootClass:[GPBDescriptorRoot class]
1015 file:GPBDescriptorRoot_FileDescriptor( )
1016 fields:fields
1017 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1018 oneofs:NULL
1019 oneofCount:0
1020 enums:NULL
1021 enumCount:0
1022 ranges:NULL
1023 rangeCount:0
1024 storageSize:sizeof(GPBEnumValueDescriptorProt o__storage_)
1025 wireFormat:NO];
1026 NSAssert(descriptor == nil, @"Startup recursed!");
1027 descriptor = localDescriptor;
1028 }
1029 return descriptor;
1030 }
1031
1032 @end
1033
1034 #pragma mark - GPBServiceDescriptorProto
1035
1036 @implementation GPBServiceDescriptorProto
1037
1038 @dynamic hasName, name;
1039 @dynamic methodArray, methodArray_Count;
1040 @dynamic hasOptions, options;
1041
1042 typedef struct GPBServiceDescriptorProto__storage_ {
1043 uint32_t _has_storage_[1];
1044 NSString *name;
1045 NSMutableArray *methodArray;
1046 GPBServiceOptions *options;
1047 } GPBServiceDescriptorProto__storage_;
1048
1049 // This method is threadsafe because it is initially called
1050 // in +initialize for each subclass.
1051 + (GPBDescriptor *)descriptor {
1052 static GPBDescriptor *descriptor = nil;
1053 if (!descriptor) {
1054 static GPBMessageFieldDescription fields[] = {
1055 {
1056 .name = "name",
1057 .number = GPBServiceDescriptorProto_FieldNumber_Name,
1058 .hasIndex = 0,
1059 .flags = GPBFieldOptional,
1060 .dataType = GPBDataTypeString,
1061 .offset = offsetof(GPBServiceDescriptorProto__storage_, name),
1062 .defaultValue.valueString = nil,
1063 .dataTypeSpecific.className = NULL,
1064 .fieldOptions = NULL,
1065 },
1066 {
1067 .name = "methodArray",
1068 .number = GPBServiceDescriptorProto_FieldNumber_MethodArray,
1069 .hasIndex = GPBNoHasBit,
1070 .flags = GPBFieldRepeated,
1071 .dataType = GPBDataTypeMessage,
1072 .offset = offsetof(GPBServiceDescriptorProto__storage_, methodArray),
1073 .defaultValue.valueMessage = nil,
1074 .dataTypeSpecific.className = GPBStringifySymbol(GPBMethodDescriptorProt o),
1075 .fieldOptions = NULL,
1076 },
1077 {
1078 .name = "options",
1079 .number = GPBServiceDescriptorProto_FieldNumber_Options,
1080 .hasIndex = 2,
1081 .flags = GPBFieldOptional,
1082 .dataType = GPBDataTypeMessage,
1083 .offset = offsetof(GPBServiceDescriptorProto__storage_, options),
1084 .defaultValue.valueMessage = nil,
1085 .dataTypeSpecific.className = GPBStringifySymbol(GPBServiceOptions),
1086 .fieldOptions = NULL,
1087 },
1088 };
1089 GPBDescriptor *localDescriptor =
1090 [GPBDescriptor allocDescriptorForClass:[GPBServiceDescriptorProto class]
1091 rootClass:[GPBDescriptorRoot class]
1092 file:GPBDescriptorRoot_FileDescriptor( )
1093 fields:fields
1094 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1095 oneofs:NULL
1096 oneofCount:0
1097 enums:NULL
1098 enumCount:0
1099 ranges:NULL
1100 rangeCount:0
1101 storageSize:sizeof(GPBServiceDescriptorProto_ _storage_)
1102 wireFormat:NO];
1103 NSAssert(descriptor == nil, @"Startup recursed!");
1104 descriptor = localDescriptor;
1105 }
1106 return descriptor;
1107 }
1108
1109 @end
1110
1111 #pragma mark - GPBMethodDescriptorProto
1112
1113 @implementation GPBMethodDescriptorProto
1114
1115 @dynamic hasName, name;
1116 @dynamic hasInputType, inputType;
1117 @dynamic hasOutputType, outputType;
1118 @dynamic hasOptions, options;
1119 @dynamic hasClientStreaming, clientStreaming;
1120 @dynamic hasServerStreaming, serverStreaming;
1121
1122 typedef struct GPBMethodDescriptorProto__storage_ {
1123 uint32_t _has_storage_[1];
1124 BOOL clientStreaming;
1125 BOOL serverStreaming;
1126 NSString *name;
1127 NSString *inputType;
1128 NSString *outputType;
1129 GPBMethodOptions *options;
1130 } GPBMethodDescriptorProto__storage_;
1131
1132 // This method is threadsafe because it is initially called
1133 // in +initialize for each subclass.
1134 + (GPBDescriptor *)descriptor {
1135 static GPBDescriptor *descriptor = nil;
1136 if (!descriptor) {
1137 static GPBMessageFieldDescription fields[] = {
1138 {
1139 .name = "name",
1140 .number = GPBMethodDescriptorProto_FieldNumber_Name,
1141 .hasIndex = 0,
1142 .flags = GPBFieldOptional,
1143 .dataType = GPBDataTypeString,
1144 .offset = offsetof(GPBMethodDescriptorProto__storage_, name),
1145 .defaultValue.valueString = nil,
1146 .dataTypeSpecific.className = NULL,
1147 .fieldOptions = NULL,
1148 },
1149 {
1150 .name = "inputType",
1151 .number = GPBMethodDescriptorProto_FieldNumber_InputType,
1152 .hasIndex = 1,
1153 .flags = GPBFieldOptional,
1154 .dataType = GPBDataTypeString,
1155 .offset = offsetof(GPBMethodDescriptorProto__storage_, inputType),
1156 .defaultValue.valueString = nil,
1157 .dataTypeSpecific.className = NULL,
1158 .fieldOptions = NULL,
1159 },
1160 {
1161 .name = "outputType",
1162 .number = GPBMethodDescriptorProto_FieldNumber_OutputType,
1163 .hasIndex = 2,
1164 .flags = GPBFieldOptional,
1165 .dataType = GPBDataTypeString,
1166 .offset = offsetof(GPBMethodDescriptorProto__storage_, outputType),
1167 .defaultValue.valueString = nil,
1168 .dataTypeSpecific.className = NULL,
1169 .fieldOptions = NULL,
1170 },
1171 {
1172 .name = "options",
1173 .number = GPBMethodDescriptorProto_FieldNumber_Options,
1174 .hasIndex = 3,
1175 .flags = GPBFieldOptional,
1176 .dataType = GPBDataTypeMessage,
1177 .offset = offsetof(GPBMethodDescriptorProto__storage_, options),
1178 .defaultValue.valueMessage = nil,
1179 .dataTypeSpecific.className = GPBStringifySymbol(GPBMethodOptions),
1180 .fieldOptions = NULL,
1181 },
1182 {
1183 .name = "clientStreaming",
1184 .number = GPBMethodDescriptorProto_FieldNumber_ClientStreaming,
1185 .hasIndex = 4,
1186 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1187 .dataType = GPBDataTypeBool,
1188 .offset = offsetof(GPBMethodDescriptorProto__storage_, clientStreaming),
1189 .defaultValue.valueBool = NO,
1190 .dataTypeSpecific.className = NULL,
1191 .fieldOptions = NULL,
1192 },
1193 {
1194 .name = "serverStreaming",
1195 .number = GPBMethodDescriptorProto_FieldNumber_ServerStreaming,
1196 .hasIndex = 5,
1197 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1198 .dataType = GPBDataTypeBool,
1199 .offset = offsetof(GPBMethodDescriptorProto__storage_, serverStreaming),
1200 .defaultValue.valueBool = NO,
1201 .dataTypeSpecific.className = NULL,
1202 .fieldOptions = NULL,
1203 },
1204 };
1205 GPBDescriptor *localDescriptor =
1206 [GPBDescriptor allocDescriptorForClass:[GPBMethodDescriptorProto class]
1207 rootClass:[GPBDescriptorRoot class]
1208 file:GPBDescriptorRoot_FileDescriptor( )
1209 fields:fields
1210 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1211 oneofs:NULL
1212 oneofCount:0
1213 enums:NULL
1214 enumCount:0
1215 ranges:NULL
1216 rangeCount:0
1217 storageSize:sizeof(GPBMethodDescriptorProto__ storage_)
1218 wireFormat:NO];
1219 NSAssert(descriptor == nil, @"Startup recursed!");
1220 descriptor = localDescriptor;
1221 }
1222 return descriptor;
1223 }
1224
1225 @end
1226
1227 #pragma mark - GPBFileOptions
1228
1229 @implementation GPBFileOptions
1230
1231 @dynamic hasJavaPackage, javaPackage;
1232 @dynamic hasJavaOuterClassname, javaOuterClassname;
1233 @dynamic hasJavaMultipleFiles, javaMultipleFiles;
1234 @dynamic hasJavaGenerateEqualsAndHash, javaGenerateEqualsAndHash;
1235 @dynamic hasJavaStringCheckUtf8, javaStringCheckUtf8;
1236 @dynamic hasOptimizeFor, optimizeFor;
1237 @dynamic hasGoPackage, goPackage;
1238 @dynamic hasCcGenericServices, ccGenericServices;
1239 @dynamic hasJavaGenericServices, javaGenericServices;
1240 @dynamic hasPyGenericServices, pyGenericServices;
1241 @dynamic hasDeprecated, deprecated;
1242 @dynamic hasCcEnableArenas, ccEnableArenas;
1243 @dynamic hasObjcClassPrefix, objcClassPrefix;
1244 @dynamic hasCsharpNamespace, csharpNamespace;
1245 @dynamic hasJavananoUseDeprecatedPackage, javananoUseDeprecatedPackage;
1246 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1247
1248 typedef struct GPBFileOptions__storage_ {
1249 uint32_t _has_storage_[1];
1250 BOOL javaMultipleFiles;
1251 BOOL ccGenericServices;
1252 BOOL javaGenericServices;
1253 BOOL pyGenericServices;
1254 BOOL javaGenerateEqualsAndHash;
1255 BOOL deprecated;
1256 BOOL javaStringCheckUtf8;
1257 BOOL ccEnableArenas;
1258 BOOL javananoUseDeprecatedPackage;
1259 GPBFileOptions_OptimizeMode optimizeFor;
1260 NSString *javaPackage;
1261 NSString *javaOuterClassname;
1262 NSString *goPackage;
1263 NSString *objcClassPrefix;
1264 NSString *csharpNamespace;
1265 NSMutableArray *uninterpretedOptionArray;
1266 } GPBFileOptions__storage_;
1267
1268 // This method is threadsafe because it is initially called
1269 // in +initialize for each subclass.
1270 + (GPBDescriptor *)descriptor {
1271 static GPBDescriptor *descriptor = nil;
1272 if (!descriptor) {
1273 static GPBMessageFieldDescription fields[] = {
1274 {
1275 .name = "javaPackage",
1276 .number = GPBFileOptions_FieldNumber_JavaPackage,
1277 .hasIndex = 0,
1278 .flags = GPBFieldOptional,
1279 .dataType = GPBDataTypeString,
1280 .offset = offsetof(GPBFileOptions__storage_, javaPackage),
1281 .defaultValue.valueString = nil,
1282 .dataTypeSpecific.className = NULL,
1283 .fieldOptions = NULL,
1284 },
1285 {
1286 .name = "javaOuterClassname",
1287 .number = GPBFileOptions_FieldNumber_JavaOuterClassname,
1288 .hasIndex = 1,
1289 .flags = GPBFieldOptional,
1290 .dataType = GPBDataTypeString,
1291 .offset = offsetof(GPBFileOptions__storage_, javaOuterClassname),
1292 .defaultValue.valueString = nil,
1293 .dataTypeSpecific.className = NULL,
1294 .fieldOptions = NULL,
1295 },
1296 {
1297 .name = "optimizeFor",
1298 .number = GPBFileOptions_FieldNumber_OptimizeFor,
1299 .hasIndex = 5,
1300 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDes criptor,
1301 .dataType = GPBDataTypeEnum,
1302 .offset = offsetof(GPBFileOptions__storage_, optimizeFor),
1303 .defaultValue.valueEnum = GPBFileOptions_OptimizeMode_Speed,
1304 .dataTypeSpecific.enumDescFunc = GPBFileOptions_OptimizeMode_EnumDescrip tor,
1305 .fieldOptions = NULL,
1306 },
1307 {
1308 .name = "javaMultipleFiles",
1309 .number = GPBFileOptions_FieldNumber_JavaMultipleFiles,
1310 .hasIndex = 2,
1311 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1312 .dataType = GPBDataTypeBool,
1313 .offset = offsetof(GPBFileOptions__storage_, javaMultipleFiles),
1314 .defaultValue.valueBool = NO,
1315 .dataTypeSpecific.className = NULL,
1316 .fieldOptions = NULL,
1317 },
1318 {
1319 .name = "goPackage",
1320 .number = GPBFileOptions_FieldNumber_GoPackage,
1321 .hasIndex = 6,
1322 .flags = GPBFieldOptional,
1323 .dataType = GPBDataTypeString,
1324 .offset = offsetof(GPBFileOptions__storage_, goPackage),
1325 .defaultValue.valueString = nil,
1326 .dataTypeSpecific.className = NULL,
1327 .fieldOptions = NULL,
1328 },
1329 {
1330 .name = "ccGenericServices",
1331 .number = GPBFileOptions_FieldNumber_CcGenericServices,
1332 .hasIndex = 7,
1333 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1334 .dataType = GPBDataTypeBool,
1335 .offset = offsetof(GPBFileOptions__storage_, ccGenericServices),
1336 .defaultValue.valueBool = NO,
1337 .dataTypeSpecific.className = NULL,
1338 .fieldOptions = NULL,
1339 },
1340 {
1341 .name = "javaGenericServices",
1342 .number = GPBFileOptions_FieldNumber_JavaGenericServices,
1343 .hasIndex = 8,
1344 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1345 .dataType = GPBDataTypeBool,
1346 .offset = offsetof(GPBFileOptions__storage_, javaGenericServices),
1347 .defaultValue.valueBool = NO,
1348 .dataTypeSpecific.className = NULL,
1349 .fieldOptions = NULL,
1350 },
1351 {
1352 .name = "pyGenericServices",
1353 .number = GPBFileOptions_FieldNumber_PyGenericServices,
1354 .hasIndex = 9,
1355 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1356 .dataType = GPBDataTypeBool,
1357 .offset = offsetof(GPBFileOptions__storage_, pyGenericServices),
1358 .defaultValue.valueBool = NO,
1359 .dataTypeSpecific.className = NULL,
1360 .fieldOptions = NULL,
1361 },
1362 {
1363 .name = "javaGenerateEqualsAndHash",
1364 .number = GPBFileOptions_FieldNumber_JavaGenerateEqualsAndHash,
1365 .hasIndex = 3,
1366 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1367 .dataType = GPBDataTypeBool,
1368 .offset = offsetof(GPBFileOptions__storage_, javaGenerateEqualsAndHash),
1369 .defaultValue.valueBool = NO,
1370 .dataTypeSpecific.className = NULL,
1371 .fieldOptions = NULL,
1372 },
1373 {
1374 .name = "deprecated",
1375 .number = GPBFileOptions_FieldNumber_Deprecated,
1376 .hasIndex = 10,
1377 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1378 .dataType = GPBDataTypeBool,
1379 .offset = offsetof(GPBFileOptions__storage_, deprecated),
1380 .defaultValue.valueBool = NO,
1381 .dataTypeSpecific.className = NULL,
1382 .fieldOptions = NULL,
1383 },
1384 {
1385 .name = "javaStringCheckUtf8",
1386 .number = GPBFileOptions_FieldNumber_JavaStringCheckUtf8,
1387 .hasIndex = 4,
1388 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1389 .dataType = GPBDataTypeBool,
1390 .offset = offsetof(GPBFileOptions__storage_, javaStringCheckUtf8),
1391 .defaultValue.valueBool = NO,
1392 .dataTypeSpecific.className = NULL,
1393 .fieldOptions = NULL,
1394 },
1395 {
1396 .name = "ccEnableArenas",
1397 .number = GPBFileOptions_FieldNumber_CcEnableArenas,
1398 .hasIndex = 11,
1399 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1400 .dataType = GPBDataTypeBool,
1401 .offset = offsetof(GPBFileOptions__storage_, ccEnableArenas),
1402 .defaultValue.valueBool = NO,
1403 .dataTypeSpecific.className = NULL,
1404 .fieldOptions = NULL,
1405 },
1406 {
1407 .name = "objcClassPrefix",
1408 .number = GPBFileOptions_FieldNumber_ObjcClassPrefix,
1409 .hasIndex = 12,
1410 .flags = GPBFieldOptional,
1411 .dataType = GPBDataTypeString,
1412 .offset = offsetof(GPBFileOptions__storage_, objcClassPrefix),
1413 .defaultValue.valueString = nil,
1414 .dataTypeSpecific.className = NULL,
1415 .fieldOptions = NULL,
1416 },
1417 {
1418 .name = "csharpNamespace",
1419 .number = GPBFileOptions_FieldNumber_CsharpNamespace,
1420 .hasIndex = 13,
1421 .flags = GPBFieldOptional,
1422 .dataType = GPBDataTypeString,
1423 .offset = offsetof(GPBFileOptions__storage_, csharpNamespace),
1424 .defaultValue.valueString = nil,
1425 .dataTypeSpecific.className = NULL,
1426 .fieldOptions = NULL,
1427 },
1428 {
1429 .name = "javananoUseDeprecatedPackage",
1430 .number = GPBFileOptions_FieldNumber_JavananoUseDeprecatedPackage,
1431 .hasIndex = 14,
1432 .flags = GPBFieldOptional,
1433 .dataType = GPBDataTypeBool,
1434 .offset = offsetof(GPBFileOptions__storage_, javananoUseDeprecatedPackag e),
1435 .defaultValue.valueBool = NO,
1436 .dataTypeSpecific.className = NULL,
1437 .fieldOptions = NULL,
1438 },
1439 {
1440 .name = "uninterpretedOptionArray",
1441 .number = GPBFileOptions_FieldNumber_UninterpretedOptionArray,
1442 .hasIndex = GPBNoHasBit,
1443 .flags = GPBFieldRepeated,
1444 .dataType = GPBDataTypeMessage,
1445 .offset = offsetof(GPBFileOptions__storage_, uninterpretedOptionArray),
1446 .defaultValue.valueMessage = nil,
1447 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1448 .fieldOptions = NULL,
1449 },
1450 };
1451 static GPBMessageEnumDescription enums[] = {
1452 { .enumDescriptorFunc = GPBFileOptions_OptimizeMode_EnumDescriptor },
1453 };
1454 static GPBExtensionRange ranges[] = {
1455 { .start = 1000, .end = 536870912 },
1456 };
1457 GPBDescriptor *localDescriptor =
1458 [GPBDescriptor allocDescriptorForClass:[GPBFileOptions class]
1459 rootClass:[GPBDescriptorRoot class]
1460 file:GPBDescriptorRoot_FileDescriptor( )
1461 fields:fields
1462 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1463 oneofs:NULL
1464 oneofCount:0
1465 enums:enums
1466 enumCount:sizeof(enums) / sizeof(GPBMessage EnumDescription)
1467 ranges:ranges
1468 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1469 storageSize:sizeof(GPBFileOptions__storage_)
1470 wireFormat:NO];
1471 NSAssert(descriptor == nil, @"Startup recursed!");
1472 descriptor = localDescriptor;
1473 }
1474 return descriptor;
1475 }
1476
1477 @end
1478
1479 #pragma mark - Enum GPBFileOptions_OptimizeMode
1480
1481 GPBEnumDescriptor *GPBFileOptions_OptimizeMode_EnumDescriptor(void) {
1482 static GPBEnumDescriptor *descriptor = NULL;
1483 if (!descriptor) {
1484 static GPBMessageEnumValueDescription values[] = {
1485 { .name = "Speed", .number = GPBFileOptions_OptimizeMode_Speed },
1486 { .name = "CodeSize", .number = GPBFileOptions_OptimizeMode_CodeSize },
1487 { .name = "LiteRuntime", .number = GPBFileOptions_OptimizeMode_LiteRuntime },
1488 };
1489 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFileOptions_OptimizeMode)
1490 values:values
1491 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
1492 enumVerifier:GPBFileOptions_Optimiz eMode_IsValidValue];
1493 }
1494 return descriptor;
1495 }
1496
1497 BOOL GPBFileOptions_OptimizeMode_IsValidValue(int32_t value__) {
1498 switch (value__) {
1499 case GPBFileOptions_OptimizeMode_Speed:
1500 case GPBFileOptions_OptimizeMode_CodeSize:
1501 case GPBFileOptions_OptimizeMode_LiteRuntime:
1502 return YES;
1503 default:
1504 return NO;
1505 }
1506 }
1507
1508 #pragma mark - GPBMessageOptions
1509
1510 @implementation GPBMessageOptions
1511
1512 @dynamic hasMessageSetWireFormat, messageSetWireFormat;
1513 @dynamic hasNoStandardDescriptorAccessor, noStandardDescriptorAccessor;
1514 @dynamic hasDeprecated, deprecated;
1515 @dynamic hasMapEntry, mapEntry;
1516 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1517
1518 typedef struct GPBMessageOptions__storage_ {
1519 uint32_t _has_storage_[1];
1520 BOOL messageSetWireFormat;
1521 BOOL noStandardDescriptorAccessor;
1522 BOOL deprecated;
1523 BOOL mapEntry;
1524 NSMutableArray *uninterpretedOptionArray;
1525 } GPBMessageOptions__storage_;
1526
1527 // This method is threadsafe because it is initially called
1528 // in +initialize for each subclass.
1529 + (GPBDescriptor *)descriptor {
1530 static GPBDescriptor *descriptor = nil;
1531 if (!descriptor) {
1532 static GPBMessageFieldDescription fields[] = {
1533 {
1534 .name = "messageSetWireFormat",
1535 .number = GPBMessageOptions_FieldNumber_MessageSetWireFormat,
1536 .hasIndex = 0,
1537 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1538 .dataType = GPBDataTypeBool,
1539 .offset = offsetof(GPBMessageOptions__storage_, messageSetWireFormat),
1540 .defaultValue.valueBool = NO,
1541 .dataTypeSpecific.className = NULL,
1542 .fieldOptions = NULL,
1543 },
1544 {
1545 .name = "noStandardDescriptorAccessor",
1546 .number = GPBMessageOptions_FieldNumber_NoStandardDescriptorAccessor,
1547 .hasIndex = 1,
1548 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1549 .dataType = GPBDataTypeBool,
1550 .offset = offsetof(GPBMessageOptions__storage_, noStandardDescriptorAcce ssor),
1551 .defaultValue.valueBool = NO,
1552 .dataTypeSpecific.className = NULL,
1553 .fieldOptions = NULL,
1554 },
1555 {
1556 .name = "deprecated",
1557 .number = GPBMessageOptions_FieldNumber_Deprecated,
1558 .hasIndex = 2,
1559 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1560 .dataType = GPBDataTypeBool,
1561 .offset = offsetof(GPBMessageOptions__storage_, deprecated),
1562 .defaultValue.valueBool = NO,
1563 .dataTypeSpecific.className = NULL,
1564 .fieldOptions = NULL,
1565 },
1566 {
1567 .name = "mapEntry",
1568 .number = GPBMessageOptions_FieldNumber_MapEntry,
1569 .hasIndex = 3,
1570 .flags = GPBFieldOptional,
1571 .dataType = GPBDataTypeBool,
1572 .offset = offsetof(GPBMessageOptions__storage_, mapEntry),
1573 .defaultValue.valueBool = NO,
1574 .dataTypeSpecific.className = NULL,
1575 .fieldOptions = NULL,
1576 },
1577 {
1578 .name = "uninterpretedOptionArray",
1579 .number = GPBMessageOptions_FieldNumber_UninterpretedOptionArray,
1580 .hasIndex = GPBNoHasBit,
1581 .flags = GPBFieldRepeated,
1582 .dataType = GPBDataTypeMessage,
1583 .offset = offsetof(GPBMessageOptions__storage_, uninterpretedOptionArray ),
1584 .defaultValue.valueMessage = nil,
1585 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1586 .fieldOptions = NULL,
1587 },
1588 };
1589 static GPBExtensionRange ranges[] = {
1590 { .start = 1000, .end = 536870912 },
1591 };
1592 GPBDescriptor *localDescriptor =
1593 [GPBDescriptor allocDescriptorForClass:[GPBMessageOptions class]
1594 rootClass:[GPBDescriptorRoot class]
1595 file:GPBDescriptorRoot_FileDescriptor( )
1596 fields:fields
1597 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1598 oneofs:NULL
1599 oneofCount:0
1600 enums:NULL
1601 enumCount:0
1602 ranges:ranges
1603 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1604 storageSize:sizeof(GPBMessageOptions__storage _)
1605 wireFormat:NO];
1606 NSAssert(descriptor == nil, @"Startup recursed!");
1607 descriptor = localDescriptor;
1608 }
1609 return descriptor;
1610 }
1611
1612 @end
1613
1614 #pragma mark - GPBFieldOptions
1615
1616 @implementation GPBFieldOptions
1617
1618 @dynamic hasCtype, ctype;
1619 @dynamic hasPacked, packed;
1620 @dynamic hasJstype, jstype;
1621 @dynamic hasLazy, lazy;
1622 @dynamic hasDeprecated, deprecated;
1623 @dynamic hasWeak, weak;
1624 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1625
1626 typedef struct GPBFieldOptions__storage_ {
1627 uint32_t _has_storage_[1];
1628 BOOL packed;
1629 BOOL deprecated;
1630 BOOL lazy;
1631 BOOL weak;
1632 GPBFieldOptions_CType ctype;
1633 GPBFieldOptions_JSType jstype;
1634 NSMutableArray *uninterpretedOptionArray;
1635 } GPBFieldOptions__storage_;
1636
1637 // This method is threadsafe because it is initially called
1638 // in +initialize for each subclass.
1639 + (GPBDescriptor *)descriptor {
1640 static GPBDescriptor *descriptor = nil;
1641 if (!descriptor) {
1642 static GPBMessageFieldDescription fields[] = {
1643 {
1644 .name = "ctype",
1645 .number = GPBFieldOptions_FieldNumber_Ctype,
1646 .hasIndex = 0,
1647 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDes criptor,
1648 .dataType = GPBDataTypeEnum,
1649 .offset = offsetof(GPBFieldOptions__storage_, ctype),
1650 .defaultValue.valueEnum = GPBFieldOptions_CType_String,
1651 .dataTypeSpecific.enumDescFunc = GPBFieldOptions_CType_EnumDescriptor,
1652 .fieldOptions = NULL,
1653 },
1654 {
1655 .name = "packed",
1656 .number = GPBFieldOptions_FieldNumber_Packed,
1657 .hasIndex = 1,
1658 .flags = GPBFieldOptional,
1659 .dataType = GPBDataTypeBool,
1660 .offset = offsetof(GPBFieldOptions__storage_, packed),
1661 .defaultValue.valueBool = NO,
1662 .dataTypeSpecific.className = NULL,
1663 .fieldOptions = NULL,
1664 },
1665 {
1666 .name = "deprecated",
1667 .number = GPBFieldOptions_FieldNumber_Deprecated,
1668 .hasIndex = 4,
1669 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1670 .dataType = GPBDataTypeBool,
1671 .offset = offsetof(GPBFieldOptions__storage_, deprecated),
1672 .defaultValue.valueBool = NO,
1673 .dataTypeSpecific.className = NULL,
1674 .fieldOptions = NULL,
1675 },
1676 {
1677 .name = "lazy",
1678 .number = GPBFieldOptions_FieldNumber_Lazy,
1679 .hasIndex = 3,
1680 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1681 .dataType = GPBDataTypeBool,
1682 .offset = offsetof(GPBFieldOptions__storage_, lazy),
1683 .defaultValue.valueBool = NO,
1684 .dataTypeSpecific.className = NULL,
1685 .fieldOptions = NULL,
1686 },
1687 {
1688 .name = "jstype",
1689 .number = GPBFieldOptions_FieldNumber_Jstype,
1690 .hasIndex = 2,
1691 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDes criptor,
1692 .dataType = GPBDataTypeEnum,
1693 .offset = offsetof(GPBFieldOptions__storage_, jstype),
1694 .defaultValue.valueEnum = GPBFieldOptions_JSType_JsNormal,
1695 .dataTypeSpecific.enumDescFunc = GPBFieldOptions_JSType_EnumDescriptor,
1696 .fieldOptions = NULL,
1697 },
1698 {
1699 .name = "weak",
1700 .number = GPBFieldOptions_FieldNumber_Weak,
1701 .hasIndex = 5,
1702 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1703 .dataType = GPBDataTypeBool,
1704 .offset = offsetof(GPBFieldOptions__storage_, weak),
1705 .defaultValue.valueBool = NO,
1706 .dataTypeSpecific.className = NULL,
1707 .fieldOptions = NULL,
1708 },
1709 {
1710 .name = "uninterpretedOptionArray",
1711 .number = GPBFieldOptions_FieldNumber_UninterpretedOptionArray,
1712 .hasIndex = GPBNoHasBit,
1713 .flags = GPBFieldRepeated,
1714 .dataType = GPBDataTypeMessage,
1715 .offset = offsetof(GPBFieldOptions__storage_, uninterpretedOptionArray),
1716 .defaultValue.valueMessage = nil,
1717 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1718 .fieldOptions = NULL,
1719 },
1720 };
1721 static GPBMessageEnumDescription enums[] = {
1722 { .enumDescriptorFunc = GPBFieldOptions_CType_EnumDescriptor },
1723 { .enumDescriptorFunc = GPBFieldOptions_JSType_EnumDescriptor },
1724 };
1725 static GPBExtensionRange ranges[] = {
1726 { .start = 1000, .end = 536870912 },
1727 };
1728 GPBDescriptor *localDescriptor =
1729 [GPBDescriptor allocDescriptorForClass:[GPBFieldOptions class]
1730 rootClass:[GPBDescriptorRoot class]
1731 file:GPBDescriptorRoot_FileDescriptor( )
1732 fields:fields
1733 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1734 oneofs:NULL
1735 oneofCount:0
1736 enums:enums
1737 enumCount:sizeof(enums) / sizeof(GPBMessage EnumDescription)
1738 ranges:ranges
1739 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1740 storageSize:sizeof(GPBFieldOptions__storage_)
1741 wireFormat:NO];
1742 NSAssert(descriptor == nil, @"Startup recursed!");
1743 descriptor = localDescriptor;
1744 }
1745 return descriptor;
1746 }
1747
1748 @end
1749
1750 #pragma mark - Enum GPBFieldOptions_CType
1751
1752 GPBEnumDescriptor *GPBFieldOptions_CType_EnumDescriptor(void) {
1753 static GPBEnumDescriptor *descriptor = NULL;
1754 if (!descriptor) {
1755 static GPBMessageEnumValueDescription values[] = {
1756 { .name = "String", .number = GPBFieldOptions_CType_String },
1757 { .name = "Cord", .number = GPBFieldOptions_CType_Cord },
1758 { .name = "StringPiece", .number = GPBFieldOptions_CType_StringPiece },
1759 };
1760 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldOptions_CType)
1761 values:values
1762 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
1763 enumVerifier:GPBFieldOptions_CType_ IsValidValue];
1764 }
1765 return descriptor;
1766 }
1767
1768 BOOL GPBFieldOptions_CType_IsValidValue(int32_t value__) {
1769 switch (value__) {
1770 case GPBFieldOptions_CType_String:
1771 case GPBFieldOptions_CType_Cord:
1772 case GPBFieldOptions_CType_StringPiece:
1773 return YES;
1774 default:
1775 return NO;
1776 }
1777 }
1778
1779 #pragma mark - Enum GPBFieldOptions_JSType
1780
1781 GPBEnumDescriptor *GPBFieldOptions_JSType_EnumDescriptor(void) {
1782 static GPBEnumDescriptor *descriptor = NULL;
1783 if (!descriptor) {
1784 static GPBMessageEnumValueDescription values[] = {
1785 { .name = "JsNormal", .number = GPBFieldOptions_JSType_JsNormal },
1786 { .name = "JsString", .number = GPBFieldOptions_JSType_JsString },
1787 { .name = "JsNumber", .number = GPBFieldOptions_JSType_JsNumber },
1788 };
1789 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldOptions_JSType)
1790 values:values
1791 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
1792 enumVerifier:GPBFieldOptions_JSType _IsValidValue];
1793 }
1794 return descriptor;
1795 }
1796
1797 BOOL GPBFieldOptions_JSType_IsValidValue(int32_t value__) {
1798 switch (value__) {
1799 case GPBFieldOptions_JSType_JsNormal:
1800 case GPBFieldOptions_JSType_JsString:
1801 case GPBFieldOptions_JSType_JsNumber:
1802 return YES;
1803 default:
1804 return NO;
1805 }
1806 }
1807
1808 #pragma mark - GPBEnumOptions
1809
1810 @implementation GPBEnumOptions
1811
1812 @dynamic hasAllowAlias, allowAlias;
1813 @dynamic hasDeprecated, deprecated;
1814 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1815
1816 typedef struct GPBEnumOptions__storage_ {
1817 uint32_t _has_storage_[1];
1818 BOOL allowAlias;
1819 BOOL deprecated;
1820 NSMutableArray *uninterpretedOptionArray;
1821 } GPBEnumOptions__storage_;
1822
1823 // This method is threadsafe because it is initially called
1824 // in +initialize for each subclass.
1825 + (GPBDescriptor *)descriptor {
1826 static GPBDescriptor *descriptor = nil;
1827 if (!descriptor) {
1828 static GPBMessageFieldDescription fields[] = {
1829 {
1830 .name = "allowAlias",
1831 .number = GPBEnumOptions_FieldNumber_AllowAlias,
1832 .hasIndex = 0,
1833 .flags = GPBFieldOptional,
1834 .dataType = GPBDataTypeBool,
1835 .offset = offsetof(GPBEnumOptions__storage_, allowAlias),
1836 .defaultValue.valueBool = NO,
1837 .dataTypeSpecific.className = NULL,
1838 .fieldOptions = NULL,
1839 },
1840 {
1841 .name = "deprecated",
1842 .number = GPBEnumOptions_FieldNumber_Deprecated,
1843 .hasIndex = 1,
1844 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1845 .dataType = GPBDataTypeBool,
1846 .offset = offsetof(GPBEnumOptions__storage_, deprecated),
1847 .defaultValue.valueBool = NO,
1848 .dataTypeSpecific.className = NULL,
1849 .fieldOptions = NULL,
1850 },
1851 {
1852 .name = "uninterpretedOptionArray",
1853 .number = GPBEnumOptions_FieldNumber_UninterpretedOptionArray,
1854 .hasIndex = GPBNoHasBit,
1855 .flags = GPBFieldRepeated,
1856 .dataType = GPBDataTypeMessage,
1857 .offset = offsetof(GPBEnumOptions__storage_, uninterpretedOptionArray),
1858 .defaultValue.valueMessage = nil,
1859 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1860 .fieldOptions = NULL,
1861 },
1862 };
1863 static GPBExtensionRange ranges[] = {
1864 { .start = 1000, .end = 536870912 },
1865 };
1866 GPBDescriptor *localDescriptor =
1867 [GPBDescriptor allocDescriptorForClass:[GPBEnumOptions class]
1868 rootClass:[GPBDescriptorRoot class]
1869 file:GPBDescriptorRoot_FileDescriptor( )
1870 fields:fields
1871 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1872 oneofs:NULL
1873 oneofCount:0
1874 enums:NULL
1875 enumCount:0
1876 ranges:ranges
1877 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1878 storageSize:sizeof(GPBEnumOptions__storage_)
1879 wireFormat:NO];
1880 NSAssert(descriptor == nil, @"Startup recursed!");
1881 descriptor = localDescriptor;
1882 }
1883 return descriptor;
1884 }
1885
1886 @end
1887
1888 #pragma mark - GPBEnumValueOptions
1889
1890 @implementation GPBEnumValueOptions
1891
1892 @dynamic hasDeprecated, deprecated;
1893 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1894
1895 typedef struct GPBEnumValueOptions__storage_ {
1896 uint32_t _has_storage_[1];
1897 BOOL deprecated;
1898 NSMutableArray *uninterpretedOptionArray;
1899 } GPBEnumValueOptions__storage_;
1900
1901 // This method is threadsafe because it is initially called
1902 // in +initialize for each subclass.
1903 + (GPBDescriptor *)descriptor {
1904 static GPBDescriptor *descriptor = nil;
1905 if (!descriptor) {
1906 static GPBMessageFieldDescription fields[] = {
1907 {
1908 .name = "deprecated",
1909 .number = GPBEnumValueOptions_FieldNumber_Deprecated,
1910 .hasIndex = 0,
1911 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1912 .dataType = GPBDataTypeBool,
1913 .offset = offsetof(GPBEnumValueOptions__storage_, deprecated),
1914 .defaultValue.valueBool = NO,
1915 .dataTypeSpecific.className = NULL,
1916 .fieldOptions = NULL,
1917 },
1918 {
1919 .name = "uninterpretedOptionArray",
1920 .number = GPBEnumValueOptions_FieldNumber_UninterpretedOptionArray,
1921 .hasIndex = GPBNoHasBit,
1922 .flags = GPBFieldRepeated,
1923 .dataType = GPBDataTypeMessage,
1924 .offset = offsetof(GPBEnumValueOptions__storage_, uninterpretedOptionArr ay),
1925 .defaultValue.valueMessage = nil,
1926 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1927 .fieldOptions = NULL,
1928 },
1929 };
1930 static GPBExtensionRange ranges[] = {
1931 { .start = 1000, .end = 536870912 },
1932 };
1933 GPBDescriptor *localDescriptor =
1934 [GPBDescriptor allocDescriptorForClass:[GPBEnumValueOptions class]
1935 rootClass:[GPBDescriptorRoot class]
1936 file:GPBDescriptorRoot_FileDescriptor( )
1937 fields:fields
1938 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1939 oneofs:NULL
1940 oneofCount:0
1941 enums:NULL
1942 enumCount:0
1943 ranges:ranges
1944 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1945 storageSize:sizeof(GPBEnumValueOptions__stora ge_)
1946 wireFormat:NO];
1947 NSAssert(descriptor == nil, @"Startup recursed!");
1948 descriptor = localDescriptor;
1949 }
1950 return descriptor;
1951 }
1952
1953 @end
1954
1955 #pragma mark - GPBServiceOptions
1956
1957 @implementation GPBServiceOptions
1958
1959 @dynamic hasDeprecated, deprecated;
1960 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1961
1962 typedef struct GPBServiceOptions__storage_ {
1963 uint32_t _has_storage_[1];
1964 BOOL deprecated;
1965 NSMutableArray *uninterpretedOptionArray;
1966 } GPBServiceOptions__storage_;
1967
1968 // This method is threadsafe because it is initially called
1969 // in +initialize for each subclass.
1970 + (GPBDescriptor *)descriptor {
1971 static GPBDescriptor *descriptor = nil;
1972 if (!descriptor) {
1973 static GPBMessageFieldDescription fields[] = {
1974 {
1975 .name = "deprecated",
1976 .number = GPBServiceOptions_FieldNumber_Deprecated,
1977 .hasIndex = 0,
1978 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1979 .dataType = GPBDataTypeBool,
1980 .offset = offsetof(GPBServiceOptions__storage_, deprecated),
1981 .defaultValue.valueBool = NO,
1982 .dataTypeSpecific.className = NULL,
1983 .fieldOptions = NULL,
1984 },
1985 {
1986 .name = "uninterpretedOptionArray",
1987 .number = GPBServiceOptions_FieldNumber_UninterpretedOptionArray,
1988 .hasIndex = GPBNoHasBit,
1989 .flags = GPBFieldRepeated,
1990 .dataType = GPBDataTypeMessage,
1991 .offset = offsetof(GPBServiceOptions__storage_, uninterpretedOptionArray ),
1992 .defaultValue.valueMessage = nil,
1993 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1994 .fieldOptions = NULL,
1995 },
1996 };
1997 static GPBExtensionRange ranges[] = {
1998 { .start = 1000, .end = 536870912 },
1999 };
2000 GPBDescriptor *localDescriptor =
2001 [GPBDescriptor allocDescriptorForClass:[GPBServiceOptions class]
2002 rootClass:[GPBDescriptorRoot class]
2003 file:GPBDescriptorRoot_FileDescriptor( )
2004 fields:fields
2005 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2006 oneofs:NULL
2007 oneofCount:0
2008 enums:NULL
2009 enumCount:0
2010 ranges:ranges
2011 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
2012 storageSize:sizeof(GPBServiceOptions__storage _)
2013 wireFormat:NO];
2014 NSAssert(descriptor == nil, @"Startup recursed!");
2015 descriptor = localDescriptor;
2016 }
2017 return descriptor;
2018 }
2019
2020 @end
2021
2022 #pragma mark - GPBMethodOptions
2023
2024 @implementation GPBMethodOptions
2025
2026 @dynamic hasDeprecated, deprecated;
2027 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
2028
2029 typedef struct GPBMethodOptions__storage_ {
2030 uint32_t _has_storage_[1];
2031 BOOL deprecated;
2032 NSMutableArray *uninterpretedOptionArray;
2033 } GPBMethodOptions__storage_;
2034
2035 // This method is threadsafe because it is initially called
2036 // in +initialize for each subclass.
2037 + (GPBDescriptor *)descriptor {
2038 static GPBDescriptor *descriptor = nil;
2039 if (!descriptor) {
2040 static GPBMessageFieldDescription fields[] = {
2041 {
2042 .name = "deprecated",
2043 .number = GPBMethodOptions_FieldNumber_Deprecated,
2044 .hasIndex = 0,
2045 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
2046 .dataType = GPBDataTypeBool,
2047 .offset = offsetof(GPBMethodOptions__storage_, deprecated),
2048 .defaultValue.valueBool = NO,
2049 .dataTypeSpecific.className = NULL,
2050 .fieldOptions = NULL,
2051 },
2052 {
2053 .name = "uninterpretedOptionArray",
2054 .number = GPBMethodOptions_FieldNumber_UninterpretedOptionArray,
2055 .hasIndex = GPBNoHasBit,
2056 .flags = GPBFieldRepeated,
2057 .dataType = GPBDataTypeMessage,
2058 .offset = offsetof(GPBMethodOptions__storage_, uninterpretedOptionArray) ,
2059 .defaultValue.valueMessage = nil,
2060 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
2061 .fieldOptions = NULL,
2062 },
2063 };
2064 static GPBExtensionRange ranges[] = {
2065 { .start = 1000, .end = 536870912 },
2066 };
2067 GPBDescriptor *localDescriptor =
2068 [GPBDescriptor allocDescriptorForClass:[GPBMethodOptions class]
2069 rootClass:[GPBDescriptorRoot class]
2070 file:GPBDescriptorRoot_FileDescriptor( )
2071 fields:fields
2072 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2073 oneofs:NULL
2074 oneofCount:0
2075 enums:NULL
2076 enumCount:0
2077 ranges:ranges
2078 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
2079 storageSize:sizeof(GPBMethodOptions__storage_ )
2080 wireFormat:NO];
2081 NSAssert(descriptor == nil, @"Startup recursed!");
2082 descriptor = localDescriptor;
2083 }
2084 return descriptor;
2085 }
2086
2087 @end
2088
2089 #pragma mark - GPBUninterpretedOption
2090
2091 @implementation GPBUninterpretedOption
2092
2093 @dynamic nameArray, nameArray_Count;
2094 @dynamic hasIdentifierValue, identifierValue;
2095 @dynamic hasPositiveIntValue, positiveIntValue;
2096 @dynamic hasNegativeIntValue, negativeIntValue;
2097 @dynamic hasDoubleValue, doubleValue;
2098 @dynamic hasStringValue, stringValue;
2099 @dynamic hasAggregateValue, aggregateValue;
2100
2101 typedef struct GPBUninterpretedOption__storage_ {
2102 uint32_t _has_storage_[1];
2103 NSMutableArray *nameArray;
2104 NSString *identifierValue;
2105 NSData *stringValue;
2106 NSString *aggregateValue;
2107 uint64_t positiveIntValue;
2108 int64_t negativeIntValue;
2109 double doubleValue;
2110 } GPBUninterpretedOption__storage_;
2111
2112 // This method is threadsafe because it is initially called
2113 // in +initialize for each subclass.
2114 + (GPBDescriptor *)descriptor {
2115 static GPBDescriptor *descriptor = nil;
2116 if (!descriptor) {
2117 static GPBMessageFieldDescription fields[] = {
2118 {
2119 .name = "nameArray",
2120 .number = GPBUninterpretedOption_FieldNumber_NameArray,
2121 .hasIndex = GPBNoHasBit,
2122 .flags = GPBFieldRepeated,
2123 .dataType = GPBDataTypeMessage,
2124 .offset = offsetof(GPBUninterpretedOption__storage_, nameArray),
2125 .defaultValue.valueMessage = nil,
2126 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption_ NamePart),
2127 .fieldOptions = NULL,
2128 },
2129 {
2130 .name = "identifierValue",
2131 .number = GPBUninterpretedOption_FieldNumber_IdentifierValue,
2132 .hasIndex = 1,
2133 .flags = GPBFieldOptional,
2134 .dataType = GPBDataTypeString,
2135 .offset = offsetof(GPBUninterpretedOption__storage_, identifierValue),
2136 .defaultValue.valueString = nil,
2137 .dataTypeSpecific.className = NULL,
2138 .fieldOptions = NULL,
2139 },
2140 {
2141 .name = "positiveIntValue",
2142 .number = GPBUninterpretedOption_FieldNumber_PositiveIntValue,
2143 .hasIndex = 2,
2144 .flags = GPBFieldOptional,
2145 .dataType = GPBDataTypeUInt64,
2146 .offset = offsetof(GPBUninterpretedOption__storage_, positiveIntValue),
2147 .defaultValue.valueUInt64 = 0ULL,
2148 .dataTypeSpecific.className = NULL,
2149 .fieldOptions = NULL,
2150 },
2151 {
2152 .name = "negativeIntValue",
2153 .number = GPBUninterpretedOption_FieldNumber_NegativeIntValue,
2154 .hasIndex = 3,
2155 .flags = GPBFieldOptional,
2156 .dataType = GPBDataTypeInt64,
2157 .offset = offsetof(GPBUninterpretedOption__storage_, negativeIntValue),
2158 .defaultValue.valueInt64 = 0LL,
2159 .dataTypeSpecific.className = NULL,
2160 .fieldOptions = NULL,
2161 },
2162 {
2163 .name = "doubleValue",
2164 .number = GPBUninterpretedOption_FieldNumber_DoubleValue,
2165 .hasIndex = 4,
2166 .flags = GPBFieldOptional,
2167 .dataType = GPBDataTypeDouble,
2168 .offset = offsetof(GPBUninterpretedOption__storage_, doubleValue),
2169 .defaultValue.valueDouble = 0,
2170 .dataTypeSpecific.className = NULL,
2171 .fieldOptions = NULL,
2172 },
2173 {
2174 .name = "stringValue",
2175 .number = GPBUninterpretedOption_FieldNumber_StringValue,
2176 .hasIndex = 5,
2177 .flags = GPBFieldOptional,
2178 .dataType = GPBDataTypeBytes,
2179 .offset = offsetof(GPBUninterpretedOption__storage_, stringValue),
2180 .defaultValue.valueData = nil,
2181 .dataTypeSpecific.className = NULL,
2182 .fieldOptions = NULL,
2183 },
2184 {
2185 .name = "aggregateValue",
2186 .number = GPBUninterpretedOption_FieldNumber_AggregateValue,
2187 .hasIndex = 6,
2188 .flags = GPBFieldOptional,
2189 .dataType = GPBDataTypeString,
2190 .offset = offsetof(GPBUninterpretedOption__storage_, aggregateValue),
2191 .defaultValue.valueString = nil,
2192 .dataTypeSpecific.className = NULL,
2193 .fieldOptions = NULL,
2194 },
2195 };
2196 GPBDescriptor *localDescriptor =
2197 [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption class]
2198 rootClass:[GPBDescriptorRoot class]
2199 file:GPBDescriptorRoot_FileDescriptor( )
2200 fields:fields
2201 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2202 oneofs:NULL
2203 oneofCount:0
2204 enums:NULL
2205 enumCount:0
2206 ranges:NULL
2207 rangeCount:0
2208 storageSize:sizeof(GPBUninterpretedOption__st orage_)
2209 wireFormat:NO];
2210 NSAssert(descriptor == nil, @"Startup recursed!");
2211 descriptor = localDescriptor;
2212 }
2213 return descriptor;
2214 }
2215
2216 @end
2217
2218 #pragma mark - GPBUninterpretedOption_NamePart
2219
2220 @implementation GPBUninterpretedOption_NamePart
2221
2222 @dynamic hasNamePart, namePart;
2223 @dynamic hasIsExtension, isExtension;
2224
2225 typedef struct GPBUninterpretedOption_NamePart__storage_ {
2226 uint32_t _has_storage_[1];
2227 BOOL isExtension;
2228 NSString *namePart;
2229 } GPBUninterpretedOption_NamePart__storage_;
2230
2231 // This method is threadsafe because it is initially called
2232 // in +initialize for each subclass.
2233 + (GPBDescriptor *)descriptor {
2234 static GPBDescriptor *descriptor = nil;
2235 if (!descriptor) {
2236 static GPBMessageFieldDescription fields[] = {
2237 {
2238 .name = "namePart",
2239 .number = GPBUninterpretedOption_NamePart_FieldNumber_NamePart,
2240 .hasIndex = 0,
2241 .flags = GPBFieldRequired,
2242 .dataType = GPBDataTypeString,
2243 .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, namePart),
2244 .defaultValue.valueString = nil,
2245 .dataTypeSpecific.className = NULL,
2246 .fieldOptions = NULL,
2247 },
2248 {
2249 .name = "isExtension",
2250 .number = GPBUninterpretedOption_NamePart_FieldNumber_IsExtension,
2251 .hasIndex = 1,
2252 .flags = GPBFieldRequired,
2253 .dataType = GPBDataTypeBool,
2254 .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, isExtensio n),
2255 .defaultValue.valueBool = NO,
2256 .dataTypeSpecific.className = NULL,
2257 .fieldOptions = NULL,
2258 },
2259 };
2260 GPBDescriptor *localDescriptor =
2261 [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption_NamePart class]
2262 rootClass:[GPBDescriptorRoot class]
2263 file:GPBDescriptorRoot_FileDescriptor( )
2264 fields:fields
2265 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2266 oneofs:NULL
2267 oneofCount:0
2268 enums:NULL
2269 enumCount:0
2270 ranges:NULL
2271 rangeCount:0
2272 storageSize:sizeof(GPBUninterpretedOption_Nam ePart__storage_)
2273 wireFormat:NO];
2274 NSAssert(descriptor == nil, @"Startup recursed!");
2275 descriptor = localDescriptor;
2276 }
2277 return descriptor;
2278 }
2279
2280 @end
2281
2282 #pragma mark - GPBSourceCodeInfo
2283
2284 @implementation GPBSourceCodeInfo
2285
2286 @dynamic locationArray, locationArray_Count;
2287
2288 typedef struct GPBSourceCodeInfo__storage_ {
2289 uint32_t _has_storage_[1];
2290 NSMutableArray *locationArray;
2291 } GPBSourceCodeInfo__storage_;
2292
2293 // This method is threadsafe because it is initially called
2294 // in +initialize for each subclass.
2295 + (GPBDescriptor *)descriptor {
2296 static GPBDescriptor *descriptor = nil;
2297 if (!descriptor) {
2298 static GPBMessageFieldDescription fields[] = {
2299 {
2300 .name = "locationArray",
2301 .number = GPBSourceCodeInfo_FieldNumber_LocationArray,
2302 .hasIndex = GPBNoHasBit,
2303 .flags = GPBFieldRepeated,
2304 .dataType = GPBDataTypeMessage,
2305 .offset = offsetof(GPBSourceCodeInfo__storage_, locationArray),
2306 .defaultValue.valueMessage = nil,
2307 .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo_Locat ion),
2308 .fieldOptions = NULL,
2309 },
2310 };
2311 GPBDescriptor *localDescriptor =
2312 [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo class]
2313 rootClass:[GPBDescriptorRoot class]
2314 file:GPBDescriptorRoot_FileDescriptor( )
2315 fields:fields
2316 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2317 oneofs:NULL
2318 oneofCount:0
2319 enums:NULL
2320 enumCount:0
2321 ranges:NULL
2322 rangeCount:0
2323 storageSize:sizeof(GPBSourceCodeInfo__storage _)
2324 wireFormat:NO];
2325 NSAssert(descriptor == nil, @"Startup recursed!");
2326 descriptor = localDescriptor;
2327 }
2328 return descriptor;
2329 }
2330
2331 @end
2332
2333 #pragma mark - GPBSourceCodeInfo_Location
2334
2335 @implementation GPBSourceCodeInfo_Location
2336
2337 @dynamic pathArray, pathArray_Count;
2338 @dynamic spanArray, spanArray_Count;
2339 @dynamic hasLeadingComments, leadingComments;
2340 @dynamic hasTrailingComments, trailingComments;
2341 @dynamic leadingDetachedCommentsArray, leadingDetachedCommentsArray_Count;
2342
2343 typedef struct GPBSourceCodeInfo_Location__storage_ {
2344 uint32_t _has_storage_[1];
2345 GPBInt32Array *pathArray;
2346 GPBInt32Array *spanArray;
2347 NSString *leadingComments;
2348 NSString *trailingComments;
2349 NSMutableArray *leadingDetachedCommentsArray;
2350 } GPBSourceCodeInfo_Location__storage_;
2351
2352 // This method is threadsafe because it is initially called
2353 // in +initialize for each subclass.
2354 + (GPBDescriptor *)descriptor {
2355 static GPBDescriptor *descriptor = nil;
2356 if (!descriptor) {
2357 static GPBMessageFieldDescription fields[] = {
2358 {
2359 .name = "pathArray",
2360 .number = GPBSourceCodeInfo_Location_FieldNumber_PathArray,
2361 .hasIndex = GPBNoHasBit,
2362 .flags = GPBFieldRepeated | GPBFieldPacked,
2363 .dataType = GPBDataTypeInt32,
2364 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, pathArray),
2365 .defaultValue.valueMessage = nil,
2366 .dataTypeSpecific.className = NULL,
2367 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2368 .fieldOptions = "\000\000\000\002\020\001",
2369 #else
2370 .fieldOptions = NULL,
2371 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2372 },
2373 {
2374 .name = "spanArray",
2375 .number = GPBSourceCodeInfo_Location_FieldNumber_SpanArray,
2376 .hasIndex = GPBNoHasBit,
2377 .flags = GPBFieldRepeated | GPBFieldPacked,
2378 .dataType = GPBDataTypeInt32,
2379 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, spanArray),
2380 .defaultValue.valueMessage = nil,
2381 .dataTypeSpecific.className = NULL,
2382 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2383 .fieldOptions = "\000\000\000\002\020\001",
2384 #else
2385 .fieldOptions = NULL,
2386 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2387 },
2388 {
2389 .name = "leadingComments",
2390 .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingComments,
2391 .hasIndex = 2,
2392 .flags = GPBFieldOptional,
2393 .dataType = GPBDataTypeString,
2394 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingComments ),
2395 .defaultValue.valueString = nil,
2396 .dataTypeSpecific.className = NULL,
2397 .fieldOptions = NULL,
2398 },
2399 {
2400 .name = "trailingComments",
2401 .number = GPBSourceCodeInfo_Location_FieldNumber_TrailingComments,
2402 .hasIndex = 3,
2403 .flags = GPBFieldOptional,
2404 .dataType = GPBDataTypeString,
2405 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, trailingComment s),
2406 .defaultValue.valueString = nil,
2407 .dataTypeSpecific.className = NULL,
2408 .fieldOptions = NULL,
2409 },
2410 {
2411 .name = "leadingDetachedCommentsArray",
2412 .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingDetachedComments Array,
2413 .hasIndex = GPBNoHasBit,
2414 .flags = GPBFieldRepeated,
2415 .dataType = GPBDataTypeString,
2416 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingDetached CommentsArray),
2417 .defaultValue.valueMessage = nil,
2418 .dataTypeSpecific.className = NULL,
2419 .fieldOptions = NULL,
2420 },
2421 };
2422 GPBDescriptor *localDescriptor =
2423 [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo_Location class ]
2424 rootClass:[GPBDescriptorRoot class]
2425 file:GPBDescriptorRoot_FileDescriptor( )
2426 fields:fields
2427 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2428 oneofs:NULL
2429 oneofCount:0
2430 enums:NULL
2431 enumCount:0
2432 ranges:NULL
2433 rangeCount:0
2434 storageSize:sizeof(GPBSourceCodeInfo_Location __storage_)
2435 wireFormat:NO];
2436 NSAssert(descriptor == nil, @"Startup recursed!");
2437 descriptor = localDescriptor;
2438 }
2439 return descriptor;
2440 }
2441
2442 @end
2443
2444
2445 // @@protoc_insertion_point(global_scope)
OLDNEW
« third_party/protobuf/README.chromium ('K') | « third_party/protobuf/objectivec/google/protobuf/Descriptor.pbobjc.h ('k') | third_party/protobuf/objectivec/google/protobuf/Duration.pbobjc.h » ('j') | third_party/protobuf/patches/0002-remove-support-for-unnecessary-languages.patch » ('J')

Powered by Google App Engine
This is Rietveld 408576698