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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 3 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
« no previous file with comments | « third_party/protobuf/objectivec/google/protobuf/Descriptor.pbobjc.h ('k') | third_party/protobuf/objectivec/google/protobuf/Duration.pbobjc.h » ('j') | no next file with comments »
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 hasOptions, options;
582
583 typedef struct GPBFieldDescriptorProto__storage_ {
584 uint32_t _has_storage_[1];
585 int32_t number;
586 GPBFieldDescriptorProto_Label label;
587 GPBFieldDescriptorProto_Type type;
588 int32_t oneofIndex;
589 NSString *name;
590 NSString *extendee;
591 NSString *typeName;
592 NSString *defaultValue;
593 GPBFieldOptions *options;
594 } GPBFieldDescriptorProto__storage_;
595
596 // This method is threadsafe because it is initially called
597 // in +initialize for each subclass.
598 + (GPBDescriptor *)descriptor {
599 static GPBDescriptor *descriptor = nil;
600 if (!descriptor) {
601 static GPBMessageFieldDescription fields[] = {
602 {
603 .name = "name",
604 .number = GPBFieldDescriptorProto_FieldNumber_Name,
605 .hasIndex = 0,
606 .flags = GPBFieldOptional,
607 .dataType = GPBDataTypeString,
608 .offset = offsetof(GPBFieldDescriptorProto__storage_, name),
609 .defaultValue.valueString = nil,
610 .dataTypeSpecific.className = NULL,
611 .fieldOptions = NULL,
612 },
613 {
614 .name = "extendee",
615 .number = GPBFieldDescriptorProto_FieldNumber_Extendee,
616 .hasIndex = 5,
617 .flags = GPBFieldOptional,
618 .dataType = GPBDataTypeString,
619 .offset = offsetof(GPBFieldDescriptorProto__storage_, extendee),
620 .defaultValue.valueString = nil,
621 .dataTypeSpecific.className = NULL,
622 .fieldOptions = NULL,
623 },
624 {
625 .name = "number",
626 .number = GPBFieldDescriptorProto_FieldNumber_Number,
627 .hasIndex = 1,
628 .flags = GPBFieldOptional,
629 .dataType = GPBDataTypeInt32,
630 .offset = offsetof(GPBFieldDescriptorProto__storage_, number),
631 .defaultValue.valueInt32 = 0,
632 .dataTypeSpecific.className = NULL,
633 .fieldOptions = NULL,
634 },
635 {
636 .name = "label",
637 .number = GPBFieldDescriptorProto_FieldNumber_Label,
638 .hasIndex = 2,
639 .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
640 .dataType = GPBDataTypeEnum,
641 .offset = offsetof(GPBFieldDescriptorProto__storage_, label),
642 .defaultValue.valueEnum = GPBFieldDescriptorProto_Label_LabelOptional,
643 .dataTypeSpecific.enumDescFunc = GPBFieldDescriptorProto_Label_EnumDescr iptor,
644 .fieldOptions = NULL,
645 },
646 {
647 .name = "type",
648 .number = GPBFieldDescriptorProto_FieldNumber_Type,
649 .hasIndex = 3,
650 .flags = GPBFieldOptional | GPBFieldHasEnumDescriptor,
651 .dataType = GPBDataTypeEnum,
652 .offset = offsetof(GPBFieldDescriptorProto__storage_, type),
653 .defaultValue.valueEnum = GPBFieldDescriptorProto_Type_TypeDouble,
654 .dataTypeSpecific.enumDescFunc = GPBFieldDescriptorProto_Type_EnumDescri ptor,
655 .fieldOptions = NULL,
656 },
657 {
658 .name = "typeName",
659 .number = GPBFieldDescriptorProto_FieldNumber_TypeName,
660 .hasIndex = 4,
661 .flags = GPBFieldOptional,
662 .dataType = GPBDataTypeString,
663 .offset = offsetof(GPBFieldDescriptorProto__storage_, typeName),
664 .defaultValue.valueString = nil,
665 .dataTypeSpecific.className = NULL,
666 .fieldOptions = NULL,
667 },
668 {
669 .name = "defaultValue",
670 .number = GPBFieldDescriptorProto_FieldNumber_DefaultValue,
671 .hasIndex = 6,
672 .flags = GPBFieldOptional,
673 .dataType = GPBDataTypeString,
674 .offset = offsetof(GPBFieldDescriptorProto__storage_, defaultValue),
675 .defaultValue.valueString = nil,
676 .dataTypeSpecific.className = NULL,
677 .fieldOptions = NULL,
678 },
679 {
680 .name = "options",
681 .number = GPBFieldDescriptorProto_FieldNumber_Options,
682 .hasIndex = 8,
683 .flags = GPBFieldOptional,
684 .dataType = GPBDataTypeMessage,
685 .offset = offsetof(GPBFieldDescriptorProto__storage_, options),
686 .defaultValue.valueMessage = nil,
687 .dataTypeSpecific.className = GPBStringifySymbol(GPBFieldOptions),
688 .fieldOptions = NULL,
689 },
690 {
691 .name = "oneofIndex",
692 .number = GPBFieldDescriptorProto_FieldNumber_OneofIndex,
693 .hasIndex = 7,
694 .flags = GPBFieldOptional,
695 .dataType = GPBDataTypeInt32,
696 .offset = offsetof(GPBFieldDescriptorProto__storage_, oneofIndex),
697 .defaultValue.valueInt32 = 0,
698 .dataTypeSpecific.className = NULL,
699 .fieldOptions = NULL,
700 },
701 };
702 static GPBMessageEnumDescription enums[] = {
703 { .enumDescriptorFunc = GPBFieldDescriptorProto_Type_EnumDescriptor },
704 { .enumDescriptorFunc = GPBFieldDescriptorProto_Label_EnumDescriptor },
705 };
706 GPBDescriptor *localDescriptor =
707 [GPBDescriptor allocDescriptorForClass:[GPBFieldDescriptorProto class]
708 rootClass:[GPBDescriptorRoot class]
709 file:GPBDescriptorRoot_FileDescriptor( )
710 fields:fields
711 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
712 oneofs:NULL
713 oneofCount:0
714 enums:enums
715 enumCount:sizeof(enums) / sizeof(GPBMessage EnumDescription)
716 ranges:NULL
717 rangeCount:0
718 storageSize:sizeof(GPBFieldDescriptorProto__s torage_)
719 wireFormat:NO];
720 NSAssert(descriptor == nil, @"Startup recursed!");
721 descriptor = localDescriptor;
722 }
723 return descriptor;
724 }
725
726 @end
727
728 #pragma mark - Enum GPBFieldDescriptorProto_Type
729
730 GPBEnumDescriptor *GPBFieldDescriptorProto_Type_EnumDescriptor(void) {
731 static GPBEnumDescriptor *descriptor = NULL;
732 if (!descriptor) {
733 static GPBMessageEnumValueDescription values[] = {
734 { .name = "TypeDouble", .number = GPBFieldDescriptorProto_Type_TypeDouble },
735 { .name = "TypeFloat", .number = GPBFieldDescriptorProto_Type_TypeFloat },
736 { .name = "TypeInt64", .number = GPBFieldDescriptorProto_Type_TypeInt64 },
737 { .name = "TypeUint64", .number = GPBFieldDescriptorProto_Type_TypeUint64 },
738 { .name = "TypeInt32", .number = GPBFieldDescriptorProto_Type_TypeInt32 },
739 { .name = "TypeFixed64", .number = GPBFieldDescriptorProto_Type_TypeFixed6 4 },
740 { .name = "TypeFixed32", .number = GPBFieldDescriptorProto_Type_TypeFixed3 2 },
741 { .name = "TypeBool", .number = GPBFieldDescriptorProto_Type_TypeBool },
742 { .name = "TypeString", .number = GPBFieldDescriptorProto_Type_TypeString },
743 { .name = "TypeGroup", .number = GPBFieldDescriptorProto_Type_TypeGroup },
744 { .name = "TypeMessage", .number = GPBFieldDescriptorProto_Type_TypeMessag e },
745 { .name = "TypeBytes", .number = GPBFieldDescriptorProto_Type_TypeBytes },
746 { .name = "TypeUint32", .number = GPBFieldDescriptorProto_Type_TypeUint32 },
747 { .name = "TypeEnum", .number = GPBFieldDescriptorProto_Type_TypeEnum },
748 { .name = "TypeSfixed32", .number = GPBFieldDescriptorProto_Type_TypeSfixe d32 },
749 { .name = "TypeSfixed64", .number = GPBFieldDescriptorProto_Type_TypeSfixe d64 },
750 { .name = "TypeSint32", .number = GPBFieldDescriptorProto_Type_TypeSint32 },
751 { .name = "TypeSint64", .number = GPBFieldDescriptorProto_Type_TypeSint64 },
752 };
753 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldDescriptorProto_Type)
754 values:values
755 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
756 enumVerifier:GPBFieldDescriptorProt o_Type_IsValidValue];
757 }
758 return descriptor;
759 }
760
761 BOOL GPBFieldDescriptorProto_Type_IsValidValue(int32_t value__) {
762 switch (value__) {
763 case GPBFieldDescriptorProto_Type_TypeDouble:
764 case GPBFieldDescriptorProto_Type_TypeFloat:
765 case GPBFieldDescriptorProto_Type_TypeInt64:
766 case GPBFieldDescriptorProto_Type_TypeUint64:
767 case GPBFieldDescriptorProto_Type_TypeInt32:
768 case GPBFieldDescriptorProto_Type_TypeFixed64:
769 case GPBFieldDescriptorProto_Type_TypeFixed32:
770 case GPBFieldDescriptorProto_Type_TypeBool:
771 case GPBFieldDescriptorProto_Type_TypeString:
772 case GPBFieldDescriptorProto_Type_TypeGroup:
773 case GPBFieldDescriptorProto_Type_TypeMessage:
774 case GPBFieldDescriptorProto_Type_TypeBytes:
775 case GPBFieldDescriptorProto_Type_TypeUint32:
776 case GPBFieldDescriptorProto_Type_TypeEnum:
777 case GPBFieldDescriptorProto_Type_TypeSfixed32:
778 case GPBFieldDescriptorProto_Type_TypeSfixed64:
779 case GPBFieldDescriptorProto_Type_TypeSint32:
780 case GPBFieldDescriptorProto_Type_TypeSint64:
781 return YES;
782 default:
783 return NO;
784 }
785 }
786
787 #pragma mark - Enum GPBFieldDescriptorProto_Label
788
789 GPBEnumDescriptor *GPBFieldDescriptorProto_Label_EnumDescriptor(void) {
790 static GPBEnumDescriptor *descriptor = NULL;
791 if (!descriptor) {
792 static GPBMessageEnumValueDescription values[] = {
793 { .name = "LabelOptional", .number = GPBFieldDescriptorProto_Label_LabelOp tional },
794 { .name = "LabelRequired", .number = GPBFieldDescriptorProto_Label_LabelRe quired },
795 { .name = "LabelRepeated", .number = GPBFieldDescriptorProto_Label_LabelRe peated },
796 };
797 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldDescriptorProto_Label)
798 values:values
799 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
800 enumVerifier:GPBFieldDescriptorProt o_Label_IsValidValue];
801 }
802 return descriptor;
803 }
804
805 BOOL GPBFieldDescriptorProto_Label_IsValidValue(int32_t value__) {
806 switch (value__) {
807 case GPBFieldDescriptorProto_Label_LabelOptional:
808 case GPBFieldDescriptorProto_Label_LabelRequired:
809 case GPBFieldDescriptorProto_Label_LabelRepeated:
810 return YES;
811 default:
812 return NO;
813 }
814 }
815
816 #pragma mark - GPBOneofDescriptorProto
817
818 @implementation GPBOneofDescriptorProto
819
820 @dynamic hasName, name;
821
822 typedef struct GPBOneofDescriptorProto__storage_ {
823 uint32_t _has_storage_[1];
824 NSString *name;
825 } GPBOneofDescriptorProto__storage_;
826
827 // This method is threadsafe because it is initially called
828 // in +initialize for each subclass.
829 + (GPBDescriptor *)descriptor {
830 static GPBDescriptor *descriptor = nil;
831 if (!descriptor) {
832 static GPBMessageFieldDescription fields[] = {
833 {
834 .name = "name",
835 .number = GPBOneofDescriptorProto_FieldNumber_Name,
836 .hasIndex = 0,
837 .flags = GPBFieldOptional,
838 .dataType = GPBDataTypeString,
839 .offset = offsetof(GPBOneofDescriptorProto__storage_, name),
840 .defaultValue.valueString = nil,
841 .dataTypeSpecific.className = NULL,
842 .fieldOptions = NULL,
843 },
844 };
845 GPBDescriptor *localDescriptor =
846 [GPBDescriptor allocDescriptorForClass:[GPBOneofDescriptorProto class]
847 rootClass:[GPBDescriptorRoot class]
848 file:GPBDescriptorRoot_FileDescriptor( )
849 fields:fields
850 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
851 oneofs:NULL
852 oneofCount:0
853 enums:NULL
854 enumCount:0
855 ranges:NULL
856 rangeCount:0
857 storageSize:sizeof(GPBOneofDescriptorProto__s torage_)
858 wireFormat:NO];
859 NSAssert(descriptor == nil, @"Startup recursed!");
860 descriptor = localDescriptor;
861 }
862 return descriptor;
863 }
864
865 @end
866
867 #pragma mark - GPBEnumDescriptorProto
868
869 @implementation GPBEnumDescriptorProto
870
871 @dynamic hasName, name;
872 @dynamic valueArray, valueArray_Count;
873 @dynamic hasOptions, options;
874
875 typedef struct GPBEnumDescriptorProto__storage_ {
876 uint32_t _has_storage_[1];
877 NSString *name;
878 NSMutableArray *valueArray;
879 GPBEnumOptions *options;
880 } GPBEnumDescriptorProto__storage_;
881
882 // This method is threadsafe because it is initially called
883 // in +initialize for each subclass.
884 + (GPBDescriptor *)descriptor {
885 static GPBDescriptor *descriptor = nil;
886 if (!descriptor) {
887 static GPBMessageFieldDescription fields[] = {
888 {
889 .name = "name",
890 .number = GPBEnumDescriptorProto_FieldNumber_Name,
891 .hasIndex = 0,
892 .flags = GPBFieldOptional,
893 .dataType = GPBDataTypeString,
894 .offset = offsetof(GPBEnumDescriptorProto__storage_, name),
895 .defaultValue.valueString = nil,
896 .dataTypeSpecific.className = NULL,
897 .fieldOptions = NULL,
898 },
899 {
900 .name = "valueArray",
901 .number = GPBEnumDescriptorProto_FieldNumber_ValueArray,
902 .hasIndex = GPBNoHasBit,
903 .flags = GPBFieldRepeated,
904 .dataType = GPBDataTypeMessage,
905 .offset = offsetof(GPBEnumDescriptorProto__storage_, valueArray),
906 .defaultValue.valueMessage = nil,
907 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumValueDescriptorP roto),
908 .fieldOptions = NULL,
909 },
910 {
911 .name = "options",
912 .number = GPBEnumDescriptorProto_FieldNumber_Options,
913 .hasIndex = 2,
914 .flags = GPBFieldOptional,
915 .dataType = GPBDataTypeMessage,
916 .offset = offsetof(GPBEnumDescriptorProto__storage_, options),
917 .defaultValue.valueMessage = nil,
918 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumOptions),
919 .fieldOptions = NULL,
920 },
921 };
922 GPBDescriptor *localDescriptor =
923 [GPBDescriptor allocDescriptorForClass:[GPBEnumDescriptorProto class]
924 rootClass:[GPBDescriptorRoot class]
925 file:GPBDescriptorRoot_FileDescriptor( )
926 fields:fields
927 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
928 oneofs:NULL
929 oneofCount:0
930 enums:NULL
931 enumCount:0
932 ranges:NULL
933 rangeCount:0
934 storageSize:sizeof(GPBEnumDescriptorProto__st orage_)
935 wireFormat:NO];
936 NSAssert(descriptor == nil, @"Startup recursed!");
937 descriptor = localDescriptor;
938 }
939 return descriptor;
940 }
941
942 @end
943
944 #pragma mark - GPBEnumValueDescriptorProto
945
946 @implementation GPBEnumValueDescriptorProto
947
948 @dynamic hasName, name;
949 @dynamic hasNumber, number;
950 @dynamic hasOptions, options;
951
952 typedef struct GPBEnumValueDescriptorProto__storage_ {
953 uint32_t _has_storage_[1];
954 int32_t number;
955 NSString *name;
956 GPBEnumValueOptions *options;
957 } GPBEnumValueDescriptorProto__storage_;
958
959 // This method is threadsafe because it is initially called
960 // in +initialize for each subclass.
961 + (GPBDescriptor *)descriptor {
962 static GPBDescriptor *descriptor = nil;
963 if (!descriptor) {
964 static GPBMessageFieldDescription fields[] = {
965 {
966 .name = "name",
967 .number = GPBEnumValueDescriptorProto_FieldNumber_Name,
968 .hasIndex = 0,
969 .flags = GPBFieldOptional,
970 .dataType = GPBDataTypeString,
971 .offset = offsetof(GPBEnumValueDescriptorProto__storage_, name),
972 .defaultValue.valueString = nil,
973 .dataTypeSpecific.className = NULL,
974 .fieldOptions = NULL,
975 },
976 {
977 .name = "number",
978 .number = GPBEnumValueDescriptorProto_FieldNumber_Number,
979 .hasIndex = 1,
980 .flags = GPBFieldOptional,
981 .dataType = GPBDataTypeInt32,
982 .offset = offsetof(GPBEnumValueDescriptorProto__storage_, number),
983 .defaultValue.valueInt32 = 0,
984 .dataTypeSpecific.className = NULL,
985 .fieldOptions = NULL,
986 },
987 {
988 .name = "options",
989 .number = GPBEnumValueDescriptorProto_FieldNumber_Options,
990 .hasIndex = 2,
991 .flags = GPBFieldOptional,
992 .dataType = GPBDataTypeMessage,
993 .offset = offsetof(GPBEnumValueDescriptorProto__storage_, options),
994 .defaultValue.valueMessage = nil,
995 .dataTypeSpecific.className = GPBStringifySymbol(GPBEnumValueOptions),
996 .fieldOptions = NULL,
997 },
998 };
999 GPBDescriptor *localDescriptor =
1000 [GPBDescriptor allocDescriptorForClass:[GPBEnumValueDescriptorProto clas s]
1001 rootClass:[GPBDescriptorRoot class]
1002 file:GPBDescriptorRoot_FileDescriptor( )
1003 fields:fields
1004 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1005 oneofs:NULL
1006 oneofCount:0
1007 enums:NULL
1008 enumCount:0
1009 ranges:NULL
1010 rangeCount:0
1011 storageSize:sizeof(GPBEnumValueDescriptorProt o__storage_)
1012 wireFormat:NO];
1013 NSAssert(descriptor == nil, @"Startup recursed!");
1014 descriptor = localDescriptor;
1015 }
1016 return descriptor;
1017 }
1018
1019 @end
1020
1021 #pragma mark - GPBServiceDescriptorProto
1022
1023 @implementation GPBServiceDescriptorProto
1024
1025 @dynamic hasName, name;
1026 @dynamic methodArray, methodArray_Count;
1027 @dynamic hasOptions, options;
1028
1029 typedef struct GPBServiceDescriptorProto__storage_ {
1030 uint32_t _has_storage_[1];
1031 NSString *name;
1032 NSMutableArray *methodArray;
1033 GPBServiceOptions *options;
1034 } GPBServiceDescriptorProto__storage_;
1035
1036 // This method is threadsafe because it is initially called
1037 // in +initialize for each subclass.
1038 + (GPBDescriptor *)descriptor {
1039 static GPBDescriptor *descriptor = nil;
1040 if (!descriptor) {
1041 static GPBMessageFieldDescription fields[] = {
1042 {
1043 .name = "name",
1044 .number = GPBServiceDescriptorProto_FieldNumber_Name,
1045 .hasIndex = 0,
1046 .flags = GPBFieldOptional,
1047 .dataType = GPBDataTypeString,
1048 .offset = offsetof(GPBServiceDescriptorProto__storage_, name),
1049 .defaultValue.valueString = nil,
1050 .dataTypeSpecific.className = NULL,
1051 .fieldOptions = NULL,
1052 },
1053 {
1054 .name = "methodArray",
1055 .number = GPBServiceDescriptorProto_FieldNumber_MethodArray,
1056 .hasIndex = GPBNoHasBit,
1057 .flags = GPBFieldRepeated,
1058 .dataType = GPBDataTypeMessage,
1059 .offset = offsetof(GPBServiceDescriptorProto__storage_, methodArray),
1060 .defaultValue.valueMessage = nil,
1061 .dataTypeSpecific.className = GPBStringifySymbol(GPBMethodDescriptorProt o),
1062 .fieldOptions = NULL,
1063 },
1064 {
1065 .name = "options",
1066 .number = GPBServiceDescriptorProto_FieldNumber_Options,
1067 .hasIndex = 2,
1068 .flags = GPBFieldOptional,
1069 .dataType = GPBDataTypeMessage,
1070 .offset = offsetof(GPBServiceDescriptorProto__storage_, options),
1071 .defaultValue.valueMessage = nil,
1072 .dataTypeSpecific.className = GPBStringifySymbol(GPBServiceOptions),
1073 .fieldOptions = NULL,
1074 },
1075 };
1076 GPBDescriptor *localDescriptor =
1077 [GPBDescriptor allocDescriptorForClass:[GPBServiceDescriptorProto class]
1078 rootClass:[GPBDescriptorRoot class]
1079 file:GPBDescriptorRoot_FileDescriptor( )
1080 fields:fields
1081 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1082 oneofs:NULL
1083 oneofCount:0
1084 enums:NULL
1085 enumCount:0
1086 ranges:NULL
1087 rangeCount:0
1088 storageSize:sizeof(GPBServiceDescriptorProto_ _storage_)
1089 wireFormat:NO];
1090 NSAssert(descriptor == nil, @"Startup recursed!");
1091 descriptor = localDescriptor;
1092 }
1093 return descriptor;
1094 }
1095
1096 @end
1097
1098 #pragma mark - GPBMethodDescriptorProto
1099
1100 @implementation GPBMethodDescriptorProto
1101
1102 @dynamic hasName, name;
1103 @dynamic hasInputType, inputType;
1104 @dynamic hasOutputType, outputType;
1105 @dynamic hasOptions, options;
1106 @dynamic hasClientStreaming, clientStreaming;
1107 @dynamic hasServerStreaming, serverStreaming;
1108
1109 typedef struct GPBMethodDescriptorProto__storage_ {
1110 uint32_t _has_storage_[1];
1111 BOOL clientStreaming;
1112 BOOL serverStreaming;
1113 NSString *name;
1114 NSString *inputType;
1115 NSString *outputType;
1116 GPBMethodOptions *options;
1117 } GPBMethodDescriptorProto__storage_;
1118
1119 // This method is threadsafe because it is initially called
1120 // in +initialize for each subclass.
1121 + (GPBDescriptor *)descriptor {
1122 static GPBDescriptor *descriptor = nil;
1123 if (!descriptor) {
1124 static GPBMessageFieldDescription fields[] = {
1125 {
1126 .name = "name",
1127 .number = GPBMethodDescriptorProto_FieldNumber_Name,
1128 .hasIndex = 0,
1129 .flags = GPBFieldOptional,
1130 .dataType = GPBDataTypeString,
1131 .offset = offsetof(GPBMethodDescriptorProto__storage_, name),
1132 .defaultValue.valueString = nil,
1133 .dataTypeSpecific.className = NULL,
1134 .fieldOptions = NULL,
1135 },
1136 {
1137 .name = "inputType",
1138 .number = GPBMethodDescriptorProto_FieldNumber_InputType,
1139 .hasIndex = 1,
1140 .flags = GPBFieldOptional,
1141 .dataType = GPBDataTypeString,
1142 .offset = offsetof(GPBMethodDescriptorProto__storage_, inputType),
1143 .defaultValue.valueString = nil,
1144 .dataTypeSpecific.className = NULL,
1145 .fieldOptions = NULL,
1146 },
1147 {
1148 .name = "outputType",
1149 .number = GPBMethodDescriptorProto_FieldNumber_OutputType,
1150 .hasIndex = 2,
1151 .flags = GPBFieldOptional,
1152 .dataType = GPBDataTypeString,
1153 .offset = offsetof(GPBMethodDescriptorProto__storage_, outputType),
1154 .defaultValue.valueString = nil,
1155 .dataTypeSpecific.className = NULL,
1156 .fieldOptions = NULL,
1157 },
1158 {
1159 .name = "options",
1160 .number = GPBMethodDescriptorProto_FieldNumber_Options,
1161 .hasIndex = 3,
1162 .flags = GPBFieldOptional,
1163 .dataType = GPBDataTypeMessage,
1164 .offset = offsetof(GPBMethodDescriptorProto__storage_, options),
1165 .defaultValue.valueMessage = nil,
1166 .dataTypeSpecific.className = GPBStringifySymbol(GPBMethodOptions),
1167 .fieldOptions = NULL,
1168 },
1169 {
1170 .name = "clientStreaming",
1171 .number = GPBMethodDescriptorProto_FieldNumber_ClientStreaming,
1172 .hasIndex = 4,
1173 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1174 .dataType = GPBDataTypeBool,
1175 .offset = offsetof(GPBMethodDescriptorProto__storage_, clientStreaming),
1176 .defaultValue.valueBool = NO,
1177 .dataTypeSpecific.className = NULL,
1178 .fieldOptions = NULL,
1179 },
1180 {
1181 .name = "serverStreaming",
1182 .number = GPBMethodDescriptorProto_FieldNumber_ServerStreaming,
1183 .hasIndex = 5,
1184 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1185 .dataType = GPBDataTypeBool,
1186 .offset = offsetof(GPBMethodDescriptorProto__storage_, serverStreaming),
1187 .defaultValue.valueBool = NO,
1188 .dataTypeSpecific.className = NULL,
1189 .fieldOptions = NULL,
1190 },
1191 };
1192 GPBDescriptor *localDescriptor =
1193 [GPBDescriptor allocDescriptorForClass:[GPBMethodDescriptorProto class]
1194 rootClass:[GPBDescriptorRoot class]
1195 file:GPBDescriptorRoot_FileDescriptor( )
1196 fields:fields
1197 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1198 oneofs:NULL
1199 oneofCount:0
1200 enums:NULL
1201 enumCount:0
1202 ranges:NULL
1203 rangeCount:0
1204 storageSize:sizeof(GPBMethodDescriptorProto__ storage_)
1205 wireFormat:NO];
1206 NSAssert(descriptor == nil, @"Startup recursed!");
1207 descriptor = localDescriptor;
1208 }
1209 return descriptor;
1210 }
1211
1212 @end
1213
1214 #pragma mark - GPBFileOptions
1215
1216 @implementation GPBFileOptions
1217
1218 @dynamic hasJavaPackage, javaPackage;
1219 @dynamic hasJavaOuterClassname, javaOuterClassname;
1220 @dynamic hasJavaMultipleFiles, javaMultipleFiles;
1221 @dynamic hasJavaGenerateEqualsAndHash, javaGenerateEqualsAndHash;
1222 @dynamic hasJavaStringCheckUtf8, javaStringCheckUtf8;
1223 @dynamic hasOptimizeFor, optimizeFor;
1224 @dynamic hasGoPackage, goPackage;
1225 @dynamic hasCcGenericServices, ccGenericServices;
1226 @dynamic hasJavaGenericServices, javaGenericServices;
1227 @dynamic hasPyGenericServices, pyGenericServices;
1228 @dynamic hasDeprecated, deprecated;
1229 @dynamic hasCcEnableArenas, ccEnableArenas;
1230 @dynamic hasObjcClassPrefix, objcClassPrefix;
1231 @dynamic hasCsharpNamespace, csharpNamespace;
1232 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1233
1234 typedef struct GPBFileOptions__storage_ {
1235 uint32_t _has_storage_[1];
1236 BOOL javaMultipleFiles;
1237 BOOL ccGenericServices;
1238 BOOL javaGenericServices;
1239 BOOL pyGenericServices;
1240 BOOL javaGenerateEqualsAndHash;
1241 BOOL deprecated;
1242 BOOL javaStringCheckUtf8;
1243 BOOL ccEnableArenas;
1244 GPBFileOptions_OptimizeMode optimizeFor;
1245 NSString *javaPackage;
1246 NSString *javaOuterClassname;
1247 NSString *goPackage;
1248 NSString *objcClassPrefix;
1249 NSString *csharpNamespace;
1250 NSMutableArray *uninterpretedOptionArray;
1251 } GPBFileOptions__storage_;
1252
1253 // This method is threadsafe because it is initially called
1254 // in +initialize for each subclass.
1255 + (GPBDescriptor *)descriptor {
1256 static GPBDescriptor *descriptor = nil;
1257 if (!descriptor) {
1258 static GPBMessageFieldDescription fields[] = {
1259 {
1260 .name = "javaPackage",
1261 .number = GPBFileOptions_FieldNumber_JavaPackage,
1262 .hasIndex = 0,
1263 .flags = GPBFieldOptional,
1264 .dataType = GPBDataTypeString,
1265 .offset = offsetof(GPBFileOptions__storage_, javaPackage),
1266 .defaultValue.valueString = nil,
1267 .dataTypeSpecific.className = NULL,
1268 .fieldOptions = NULL,
1269 },
1270 {
1271 .name = "javaOuterClassname",
1272 .number = GPBFileOptions_FieldNumber_JavaOuterClassname,
1273 .hasIndex = 1,
1274 .flags = GPBFieldOptional,
1275 .dataType = GPBDataTypeString,
1276 .offset = offsetof(GPBFileOptions__storage_, javaOuterClassname),
1277 .defaultValue.valueString = nil,
1278 .dataTypeSpecific.className = NULL,
1279 .fieldOptions = NULL,
1280 },
1281 {
1282 .name = "optimizeFor",
1283 .number = GPBFileOptions_FieldNumber_OptimizeFor,
1284 .hasIndex = 5,
1285 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDes criptor,
1286 .dataType = GPBDataTypeEnum,
1287 .offset = offsetof(GPBFileOptions__storage_, optimizeFor),
1288 .defaultValue.valueEnum = GPBFileOptions_OptimizeMode_Speed,
1289 .dataTypeSpecific.enumDescFunc = GPBFileOptions_OptimizeMode_EnumDescrip tor,
1290 .fieldOptions = NULL,
1291 },
1292 {
1293 .name = "javaMultipleFiles",
1294 .number = GPBFileOptions_FieldNumber_JavaMultipleFiles,
1295 .hasIndex = 2,
1296 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1297 .dataType = GPBDataTypeBool,
1298 .offset = offsetof(GPBFileOptions__storage_, javaMultipleFiles),
1299 .defaultValue.valueBool = NO,
1300 .dataTypeSpecific.className = NULL,
1301 .fieldOptions = NULL,
1302 },
1303 {
1304 .name = "goPackage",
1305 .number = GPBFileOptions_FieldNumber_GoPackage,
1306 .hasIndex = 6,
1307 .flags = GPBFieldOptional,
1308 .dataType = GPBDataTypeString,
1309 .offset = offsetof(GPBFileOptions__storage_, goPackage),
1310 .defaultValue.valueString = nil,
1311 .dataTypeSpecific.className = NULL,
1312 .fieldOptions = NULL,
1313 },
1314 {
1315 .name = "ccGenericServices",
1316 .number = GPBFileOptions_FieldNumber_CcGenericServices,
1317 .hasIndex = 7,
1318 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1319 .dataType = GPBDataTypeBool,
1320 .offset = offsetof(GPBFileOptions__storage_, ccGenericServices),
1321 .defaultValue.valueBool = NO,
1322 .dataTypeSpecific.className = NULL,
1323 .fieldOptions = NULL,
1324 },
1325 {
1326 .name = "javaGenericServices",
1327 .number = GPBFileOptions_FieldNumber_JavaGenericServices,
1328 .hasIndex = 8,
1329 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1330 .dataType = GPBDataTypeBool,
1331 .offset = offsetof(GPBFileOptions__storage_, javaGenericServices),
1332 .defaultValue.valueBool = NO,
1333 .dataTypeSpecific.className = NULL,
1334 .fieldOptions = NULL,
1335 },
1336 {
1337 .name = "pyGenericServices",
1338 .number = GPBFileOptions_FieldNumber_PyGenericServices,
1339 .hasIndex = 9,
1340 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1341 .dataType = GPBDataTypeBool,
1342 .offset = offsetof(GPBFileOptions__storage_, pyGenericServices),
1343 .defaultValue.valueBool = NO,
1344 .dataTypeSpecific.className = NULL,
1345 .fieldOptions = NULL,
1346 },
1347 {
1348 .name = "javaGenerateEqualsAndHash",
1349 .number = GPBFileOptions_FieldNumber_JavaGenerateEqualsAndHash,
1350 .hasIndex = 3,
1351 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1352 .dataType = GPBDataTypeBool,
1353 .offset = offsetof(GPBFileOptions__storage_, javaGenerateEqualsAndHash),
1354 .defaultValue.valueBool = NO,
1355 .dataTypeSpecific.className = NULL,
1356 .fieldOptions = NULL,
1357 },
1358 {
1359 .name = "deprecated",
1360 .number = GPBFileOptions_FieldNumber_Deprecated,
1361 .hasIndex = 10,
1362 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1363 .dataType = GPBDataTypeBool,
1364 .offset = offsetof(GPBFileOptions__storage_, deprecated),
1365 .defaultValue.valueBool = NO,
1366 .dataTypeSpecific.className = NULL,
1367 .fieldOptions = NULL,
1368 },
1369 {
1370 .name = "javaStringCheckUtf8",
1371 .number = GPBFileOptions_FieldNumber_JavaStringCheckUtf8,
1372 .hasIndex = 4,
1373 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1374 .dataType = GPBDataTypeBool,
1375 .offset = offsetof(GPBFileOptions__storage_, javaStringCheckUtf8),
1376 .defaultValue.valueBool = NO,
1377 .dataTypeSpecific.className = NULL,
1378 .fieldOptions = NULL,
1379 },
1380 {
1381 .name = "ccEnableArenas",
1382 .number = GPBFileOptions_FieldNumber_CcEnableArenas,
1383 .hasIndex = 11,
1384 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1385 .dataType = GPBDataTypeBool,
1386 .offset = offsetof(GPBFileOptions__storage_, ccEnableArenas),
1387 .defaultValue.valueBool = NO,
1388 .dataTypeSpecific.className = NULL,
1389 .fieldOptions = NULL,
1390 },
1391 {
1392 .name = "objcClassPrefix",
1393 .number = GPBFileOptions_FieldNumber_ObjcClassPrefix,
1394 .hasIndex = 12,
1395 .flags = GPBFieldOptional,
1396 .dataType = GPBDataTypeString,
1397 .offset = offsetof(GPBFileOptions__storage_, objcClassPrefix),
1398 .defaultValue.valueString = nil,
1399 .dataTypeSpecific.className = NULL,
1400 .fieldOptions = NULL,
1401 },
1402 {
1403 .name = "csharpNamespace",
1404 .number = GPBFileOptions_FieldNumber_CsharpNamespace,
1405 .hasIndex = 13,
1406 .flags = GPBFieldOptional,
1407 .dataType = GPBDataTypeString,
1408 .offset = offsetof(GPBFileOptions__storage_, csharpNamespace),
1409 .defaultValue.valueString = nil,
1410 .dataTypeSpecific.className = NULL,
1411 .fieldOptions = NULL,
1412 },
1413 {
1414 .name = "uninterpretedOptionArray",
1415 .number = GPBFileOptions_FieldNumber_UninterpretedOptionArray,
1416 .hasIndex = GPBNoHasBit,
1417 .flags = GPBFieldRepeated,
1418 .dataType = GPBDataTypeMessage,
1419 .offset = offsetof(GPBFileOptions__storage_, uninterpretedOptionArray),
1420 .defaultValue.valueMessage = nil,
1421 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1422 .fieldOptions = NULL,
1423 },
1424 };
1425 static GPBMessageEnumDescription enums[] = {
1426 { .enumDescriptorFunc = GPBFileOptions_OptimizeMode_EnumDescriptor },
1427 };
1428 static GPBExtensionRange ranges[] = {
1429 { .start = 1000, .end = 536870912 },
1430 };
1431 GPBDescriptor *localDescriptor =
1432 [GPBDescriptor allocDescriptorForClass:[GPBFileOptions class]
1433 rootClass:[GPBDescriptorRoot class]
1434 file:GPBDescriptorRoot_FileDescriptor( )
1435 fields:fields
1436 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1437 oneofs:NULL
1438 oneofCount:0
1439 enums:enums
1440 enumCount:sizeof(enums) / sizeof(GPBMessage EnumDescription)
1441 ranges:ranges
1442 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1443 storageSize:sizeof(GPBFileOptions__storage_)
1444 wireFormat:NO];
1445 NSAssert(descriptor == nil, @"Startup recursed!");
1446 descriptor = localDescriptor;
1447 }
1448 return descriptor;
1449 }
1450
1451 @end
1452
1453 #pragma mark - Enum GPBFileOptions_OptimizeMode
1454
1455 GPBEnumDescriptor *GPBFileOptions_OptimizeMode_EnumDescriptor(void) {
1456 static GPBEnumDescriptor *descriptor = NULL;
1457 if (!descriptor) {
1458 static GPBMessageEnumValueDescription values[] = {
1459 { .name = "Speed", .number = GPBFileOptions_OptimizeMode_Speed },
1460 { .name = "CodeSize", .number = GPBFileOptions_OptimizeMode_CodeSize },
1461 { .name = "LiteRuntime", .number = GPBFileOptions_OptimizeMode_LiteRuntime },
1462 };
1463 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFileOptions_OptimizeMode)
1464 values:values
1465 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
1466 enumVerifier:GPBFileOptions_Optimiz eMode_IsValidValue];
1467 }
1468 return descriptor;
1469 }
1470
1471 BOOL GPBFileOptions_OptimizeMode_IsValidValue(int32_t value__) {
1472 switch (value__) {
1473 case GPBFileOptions_OptimizeMode_Speed:
1474 case GPBFileOptions_OptimizeMode_CodeSize:
1475 case GPBFileOptions_OptimizeMode_LiteRuntime:
1476 return YES;
1477 default:
1478 return NO;
1479 }
1480 }
1481
1482 #pragma mark - GPBMessageOptions
1483
1484 @implementation GPBMessageOptions
1485
1486 @dynamic hasMessageSetWireFormat, messageSetWireFormat;
1487 @dynamic hasNoStandardDescriptorAccessor, noStandardDescriptorAccessor;
1488 @dynamic hasDeprecated, deprecated;
1489 @dynamic hasMapEntry, mapEntry;
1490 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1491
1492 typedef struct GPBMessageOptions__storage_ {
1493 uint32_t _has_storage_[1];
1494 BOOL messageSetWireFormat;
1495 BOOL noStandardDescriptorAccessor;
1496 BOOL deprecated;
1497 BOOL mapEntry;
1498 NSMutableArray *uninterpretedOptionArray;
1499 } GPBMessageOptions__storage_;
1500
1501 // This method is threadsafe because it is initially called
1502 // in +initialize for each subclass.
1503 + (GPBDescriptor *)descriptor {
1504 static GPBDescriptor *descriptor = nil;
1505 if (!descriptor) {
1506 static GPBMessageFieldDescription fields[] = {
1507 {
1508 .name = "messageSetWireFormat",
1509 .number = GPBMessageOptions_FieldNumber_MessageSetWireFormat,
1510 .hasIndex = 0,
1511 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1512 .dataType = GPBDataTypeBool,
1513 .offset = offsetof(GPBMessageOptions__storage_, messageSetWireFormat),
1514 .defaultValue.valueBool = NO,
1515 .dataTypeSpecific.className = NULL,
1516 .fieldOptions = NULL,
1517 },
1518 {
1519 .name = "noStandardDescriptorAccessor",
1520 .number = GPBMessageOptions_FieldNumber_NoStandardDescriptorAccessor,
1521 .hasIndex = 1,
1522 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1523 .dataType = GPBDataTypeBool,
1524 .offset = offsetof(GPBMessageOptions__storage_, noStandardDescriptorAcce ssor),
1525 .defaultValue.valueBool = NO,
1526 .dataTypeSpecific.className = NULL,
1527 .fieldOptions = NULL,
1528 },
1529 {
1530 .name = "deprecated",
1531 .number = GPBMessageOptions_FieldNumber_Deprecated,
1532 .hasIndex = 2,
1533 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1534 .dataType = GPBDataTypeBool,
1535 .offset = offsetof(GPBMessageOptions__storage_, deprecated),
1536 .defaultValue.valueBool = NO,
1537 .dataTypeSpecific.className = NULL,
1538 .fieldOptions = NULL,
1539 },
1540 {
1541 .name = "mapEntry",
1542 .number = GPBMessageOptions_FieldNumber_MapEntry,
1543 .hasIndex = 3,
1544 .flags = GPBFieldOptional,
1545 .dataType = GPBDataTypeBool,
1546 .offset = offsetof(GPBMessageOptions__storage_, mapEntry),
1547 .defaultValue.valueBool = NO,
1548 .dataTypeSpecific.className = NULL,
1549 .fieldOptions = NULL,
1550 },
1551 {
1552 .name = "uninterpretedOptionArray",
1553 .number = GPBMessageOptions_FieldNumber_UninterpretedOptionArray,
1554 .hasIndex = GPBNoHasBit,
1555 .flags = GPBFieldRepeated,
1556 .dataType = GPBDataTypeMessage,
1557 .offset = offsetof(GPBMessageOptions__storage_, uninterpretedOptionArray ),
1558 .defaultValue.valueMessage = nil,
1559 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1560 .fieldOptions = NULL,
1561 },
1562 };
1563 static GPBExtensionRange ranges[] = {
1564 { .start = 1000, .end = 536870912 },
1565 };
1566 GPBDescriptor *localDescriptor =
1567 [GPBDescriptor allocDescriptorForClass:[GPBMessageOptions class]
1568 rootClass:[GPBDescriptorRoot class]
1569 file:GPBDescriptorRoot_FileDescriptor( )
1570 fields:fields
1571 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1572 oneofs:NULL
1573 oneofCount:0
1574 enums:NULL
1575 enumCount:0
1576 ranges:ranges
1577 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1578 storageSize:sizeof(GPBMessageOptions__storage _)
1579 wireFormat:NO];
1580 NSAssert(descriptor == nil, @"Startup recursed!");
1581 descriptor = localDescriptor;
1582 }
1583 return descriptor;
1584 }
1585
1586 @end
1587
1588 #pragma mark - GPBFieldOptions
1589
1590 @implementation GPBFieldOptions
1591
1592 @dynamic hasCtype, ctype;
1593 @dynamic hasPacked, packed;
1594 @dynamic hasJstype, jstype;
1595 @dynamic hasLazy, lazy;
1596 @dynamic hasDeprecated, deprecated;
1597 @dynamic hasWeak, weak;
1598 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1599
1600 typedef struct GPBFieldOptions__storage_ {
1601 uint32_t _has_storage_[1];
1602 BOOL packed;
1603 BOOL deprecated;
1604 BOOL lazy;
1605 BOOL weak;
1606 GPBFieldOptions_CType ctype;
1607 GPBFieldOptions_JSType jstype;
1608 NSMutableArray *uninterpretedOptionArray;
1609 } GPBFieldOptions__storage_;
1610
1611 // This method is threadsafe because it is initially called
1612 // in +initialize for each subclass.
1613 + (GPBDescriptor *)descriptor {
1614 static GPBDescriptor *descriptor = nil;
1615 if (!descriptor) {
1616 static GPBMessageFieldDescription fields[] = {
1617 {
1618 .name = "ctype",
1619 .number = GPBFieldOptions_FieldNumber_Ctype,
1620 .hasIndex = 0,
1621 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDes criptor,
1622 .dataType = GPBDataTypeEnum,
1623 .offset = offsetof(GPBFieldOptions__storage_, ctype),
1624 .defaultValue.valueEnum = GPBFieldOptions_CType_String,
1625 .dataTypeSpecific.enumDescFunc = GPBFieldOptions_CType_EnumDescriptor,
1626 .fieldOptions = NULL,
1627 },
1628 {
1629 .name = "packed",
1630 .number = GPBFieldOptions_FieldNumber_Packed,
1631 .hasIndex = 1,
1632 .flags = GPBFieldOptional,
1633 .dataType = GPBDataTypeBool,
1634 .offset = offsetof(GPBFieldOptions__storage_, packed),
1635 .defaultValue.valueBool = NO,
1636 .dataTypeSpecific.className = NULL,
1637 .fieldOptions = NULL,
1638 },
1639 {
1640 .name = "deprecated",
1641 .number = GPBFieldOptions_FieldNumber_Deprecated,
1642 .hasIndex = 4,
1643 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1644 .dataType = GPBDataTypeBool,
1645 .offset = offsetof(GPBFieldOptions__storage_, deprecated),
1646 .defaultValue.valueBool = NO,
1647 .dataTypeSpecific.className = NULL,
1648 .fieldOptions = NULL,
1649 },
1650 {
1651 .name = "lazy",
1652 .number = GPBFieldOptions_FieldNumber_Lazy,
1653 .hasIndex = 3,
1654 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1655 .dataType = GPBDataTypeBool,
1656 .offset = offsetof(GPBFieldOptions__storage_, lazy),
1657 .defaultValue.valueBool = NO,
1658 .dataTypeSpecific.className = NULL,
1659 .fieldOptions = NULL,
1660 },
1661 {
1662 .name = "jstype",
1663 .number = GPBFieldOptions_FieldNumber_Jstype,
1664 .hasIndex = 2,
1665 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDes criptor,
1666 .dataType = GPBDataTypeEnum,
1667 .offset = offsetof(GPBFieldOptions__storage_, jstype),
1668 .defaultValue.valueEnum = GPBFieldOptions_JSType_JsNormal,
1669 .dataTypeSpecific.enumDescFunc = GPBFieldOptions_JSType_EnumDescriptor,
1670 .fieldOptions = NULL,
1671 },
1672 {
1673 .name = "weak",
1674 .number = GPBFieldOptions_FieldNumber_Weak,
1675 .hasIndex = 5,
1676 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1677 .dataType = GPBDataTypeBool,
1678 .offset = offsetof(GPBFieldOptions__storage_, weak),
1679 .defaultValue.valueBool = NO,
1680 .dataTypeSpecific.className = NULL,
1681 .fieldOptions = NULL,
1682 },
1683 {
1684 .name = "uninterpretedOptionArray",
1685 .number = GPBFieldOptions_FieldNumber_UninterpretedOptionArray,
1686 .hasIndex = GPBNoHasBit,
1687 .flags = GPBFieldRepeated,
1688 .dataType = GPBDataTypeMessage,
1689 .offset = offsetof(GPBFieldOptions__storage_, uninterpretedOptionArray),
1690 .defaultValue.valueMessage = nil,
1691 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1692 .fieldOptions = NULL,
1693 },
1694 };
1695 static GPBMessageEnumDescription enums[] = {
1696 { .enumDescriptorFunc = GPBFieldOptions_CType_EnumDescriptor },
1697 { .enumDescriptorFunc = GPBFieldOptions_JSType_EnumDescriptor },
1698 };
1699 static GPBExtensionRange ranges[] = {
1700 { .start = 1000, .end = 536870912 },
1701 };
1702 GPBDescriptor *localDescriptor =
1703 [GPBDescriptor allocDescriptorForClass:[GPBFieldOptions class]
1704 rootClass:[GPBDescriptorRoot class]
1705 file:GPBDescriptorRoot_FileDescriptor( )
1706 fields:fields
1707 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1708 oneofs:NULL
1709 oneofCount:0
1710 enums:enums
1711 enumCount:sizeof(enums) / sizeof(GPBMessage EnumDescription)
1712 ranges:ranges
1713 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1714 storageSize:sizeof(GPBFieldOptions__storage_)
1715 wireFormat:NO];
1716 NSAssert(descriptor == nil, @"Startup recursed!");
1717 descriptor = localDescriptor;
1718 }
1719 return descriptor;
1720 }
1721
1722 @end
1723
1724 #pragma mark - Enum GPBFieldOptions_CType
1725
1726 GPBEnumDescriptor *GPBFieldOptions_CType_EnumDescriptor(void) {
1727 static GPBEnumDescriptor *descriptor = NULL;
1728 if (!descriptor) {
1729 static GPBMessageEnumValueDescription values[] = {
1730 { .name = "String", .number = GPBFieldOptions_CType_String },
1731 { .name = "Cord", .number = GPBFieldOptions_CType_Cord },
1732 { .name = "StringPiece", .number = GPBFieldOptions_CType_StringPiece },
1733 };
1734 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldOptions_CType)
1735 values:values
1736 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
1737 enumVerifier:GPBFieldOptions_CType_ IsValidValue];
1738 }
1739 return descriptor;
1740 }
1741
1742 BOOL GPBFieldOptions_CType_IsValidValue(int32_t value__) {
1743 switch (value__) {
1744 case GPBFieldOptions_CType_String:
1745 case GPBFieldOptions_CType_Cord:
1746 case GPBFieldOptions_CType_StringPiece:
1747 return YES;
1748 default:
1749 return NO;
1750 }
1751 }
1752
1753 #pragma mark - Enum GPBFieldOptions_JSType
1754
1755 GPBEnumDescriptor *GPBFieldOptions_JSType_EnumDescriptor(void) {
1756 static GPBEnumDescriptor *descriptor = NULL;
1757 if (!descriptor) {
1758 static GPBMessageEnumValueDescription values[] = {
1759 { .name = "JsNormal", .number = GPBFieldOptions_JSType_JsNormal },
1760 { .name = "JsString", .number = GPBFieldOptions_JSType_JsString },
1761 { .name = "JsNumber", .number = GPBFieldOptions_JSType_JsNumber },
1762 };
1763 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol( GPBFieldOptions_JSType)
1764 values:values
1765 valueCount:sizeof(values) / sizeo f(GPBMessageEnumValueDescription)
1766 enumVerifier:GPBFieldOptions_JSType _IsValidValue];
1767 }
1768 return descriptor;
1769 }
1770
1771 BOOL GPBFieldOptions_JSType_IsValidValue(int32_t value__) {
1772 switch (value__) {
1773 case GPBFieldOptions_JSType_JsNormal:
1774 case GPBFieldOptions_JSType_JsString:
1775 case GPBFieldOptions_JSType_JsNumber:
1776 return YES;
1777 default:
1778 return NO;
1779 }
1780 }
1781
1782 #pragma mark - GPBEnumOptions
1783
1784 @implementation GPBEnumOptions
1785
1786 @dynamic hasAllowAlias, allowAlias;
1787 @dynamic hasDeprecated, deprecated;
1788 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1789
1790 typedef struct GPBEnumOptions__storage_ {
1791 uint32_t _has_storage_[1];
1792 BOOL allowAlias;
1793 BOOL deprecated;
1794 NSMutableArray *uninterpretedOptionArray;
1795 } GPBEnumOptions__storage_;
1796
1797 // This method is threadsafe because it is initially called
1798 // in +initialize for each subclass.
1799 + (GPBDescriptor *)descriptor {
1800 static GPBDescriptor *descriptor = nil;
1801 if (!descriptor) {
1802 static GPBMessageFieldDescription fields[] = {
1803 {
1804 .name = "allowAlias",
1805 .number = GPBEnumOptions_FieldNumber_AllowAlias,
1806 .hasIndex = 0,
1807 .flags = GPBFieldOptional,
1808 .dataType = GPBDataTypeBool,
1809 .offset = offsetof(GPBEnumOptions__storage_, allowAlias),
1810 .defaultValue.valueBool = NO,
1811 .dataTypeSpecific.className = NULL,
1812 .fieldOptions = NULL,
1813 },
1814 {
1815 .name = "deprecated",
1816 .number = GPBEnumOptions_FieldNumber_Deprecated,
1817 .hasIndex = 1,
1818 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1819 .dataType = GPBDataTypeBool,
1820 .offset = offsetof(GPBEnumOptions__storage_, deprecated),
1821 .defaultValue.valueBool = NO,
1822 .dataTypeSpecific.className = NULL,
1823 .fieldOptions = NULL,
1824 },
1825 {
1826 .name = "uninterpretedOptionArray",
1827 .number = GPBEnumOptions_FieldNumber_UninterpretedOptionArray,
1828 .hasIndex = GPBNoHasBit,
1829 .flags = GPBFieldRepeated,
1830 .dataType = GPBDataTypeMessage,
1831 .offset = offsetof(GPBEnumOptions__storage_, uninterpretedOptionArray),
1832 .defaultValue.valueMessage = nil,
1833 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1834 .fieldOptions = NULL,
1835 },
1836 };
1837 static GPBExtensionRange ranges[] = {
1838 { .start = 1000, .end = 536870912 },
1839 };
1840 GPBDescriptor *localDescriptor =
1841 [GPBDescriptor allocDescriptorForClass:[GPBEnumOptions class]
1842 rootClass:[GPBDescriptorRoot class]
1843 file:GPBDescriptorRoot_FileDescriptor( )
1844 fields:fields
1845 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1846 oneofs:NULL
1847 oneofCount:0
1848 enums:NULL
1849 enumCount:0
1850 ranges:ranges
1851 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1852 storageSize:sizeof(GPBEnumOptions__storage_)
1853 wireFormat:NO];
1854 NSAssert(descriptor == nil, @"Startup recursed!");
1855 descriptor = localDescriptor;
1856 }
1857 return descriptor;
1858 }
1859
1860 @end
1861
1862 #pragma mark - GPBEnumValueOptions
1863
1864 @implementation GPBEnumValueOptions
1865
1866 @dynamic hasDeprecated, deprecated;
1867 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1868
1869 typedef struct GPBEnumValueOptions__storage_ {
1870 uint32_t _has_storage_[1];
1871 BOOL deprecated;
1872 NSMutableArray *uninterpretedOptionArray;
1873 } GPBEnumValueOptions__storage_;
1874
1875 // This method is threadsafe because it is initially called
1876 // in +initialize for each subclass.
1877 + (GPBDescriptor *)descriptor {
1878 static GPBDescriptor *descriptor = nil;
1879 if (!descriptor) {
1880 static GPBMessageFieldDescription fields[] = {
1881 {
1882 .name = "deprecated",
1883 .number = GPBEnumValueOptions_FieldNumber_Deprecated,
1884 .hasIndex = 0,
1885 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1886 .dataType = GPBDataTypeBool,
1887 .offset = offsetof(GPBEnumValueOptions__storage_, deprecated),
1888 .defaultValue.valueBool = NO,
1889 .dataTypeSpecific.className = NULL,
1890 .fieldOptions = NULL,
1891 },
1892 {
1893 .name = "uninterpretedOptionArray",
1894 .number = GPBEnumValueOptions_FieldNumber_UninterpretedOptionArray,
1895 .hasIndex = GPBNoHasBit,
1896 .flags = GPBFieldRepeated,
1897 .dataType = GPBDataTypeMessage,
1898 .offset = offsetof(GPBEnumValueOptions__storage_, uninterpretedOptionArr ay),
1899 .defaultValue.valueMessage = nil,
1900 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1901 .fieldOptions = NULL,
1902 },
1903 };
1904 static GPBExtensionRange ranges[] = {
1905 { .start = 1000, .end = 536870912 },
1906 };
1907 GPBDescriptor *localDescriptor =
1908 [GPBDescriptor allocDescriptorForClass:[GPBEnumValueOptions class]
1909 rootClass:[GPBDescriptorRoot class]
1910 file:GPBDescriptorRoot_FileDescriptor( )
1911 fields:fields
1912 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1913 oneofs:NULL
1914 oneofCount:0
1915 enums:NULL
1916 enumCount:0
1917 ranges:ranges
1918 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1919 storageSize:sizeof(GPBEnumValueOptions__stora ge_)
1920 wireFormat:NO];
1921 NSAssert(descriptor == nil, @"Startup recursed!");
1922 descriptor = localDescriptor;
1923 }
1924 return descriptor;
1925 }
1926
1927 @end
1928
1929 #pragma mark - GPBServiceOptions
1930
1931 @implementation GPBServiceOptions
1932
1933 @dynamic hasDeprecated, deprecated;
1934 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1935
1936 typedef struct GPBServiceOptions__storage_ {
1937 uint32_t _has_storage_[1];
1938 BOOL deprecated;
1939 NSMutableArray *uninterpretedOptionArray;
1940 } GPBServiceOptions__storage_;
1941
1942 // This method is threadsafe because it is initially called
1943 // in +initialize for each subclass.
1944 + (GPBDescriptor *)descriptor {
1945 static GPBDescriptor *descriptor = nil;
1946 if (!descriptor) {
1947 static GPBMessageFieldDescription fields[] = {
1948 {
1949 .name = "deprecated",
1950 .number = GPBServiceOptions_FieldNumber_Deprecated,
1951 .hasIndex = 0,
1952 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1953 .dataType = GPBDataTypeBool,
1954 .offset = offsetof(GPBServiceOptions__storage_, deprecated),
1955 .defaultValue.valueBool = NO,
1956 .dataTypeSpecific.className = NULL,
1957 .fieldOptions = NULL,
1958 },
1959 {
1960 .name = "uninterpretedOptionArray",
1961 .number = GPBServiceOptions_FieldNumber_UninterpretedOptionArray,
1962 .hasIndex = GPBNoHasBit,
1963 .flags = GPBFieldRepeated,
1964 .dataType = GPBDataTypeMessage,
1965 .offset = offsetof(GPBServiceOptions__storage_, uninterpretedOptionArray ),
1966 .defaultValue.valueMessage = nil,
1967 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
1968 .fieldOptions = NULL,
1969 },
1970 };
1971 static GPBExtensionRange ranges[] = {
1972 { .start = 1000, .end = 536870912 },
1973 };
1974 GPBDescriptor *localDescriptor =
1975 [GPBDescriptor allocDescriptorForClass:[GPBServiceOptions class]
1976 rootClass:[GPBDescriptorRoot class]
1977 file:GPBDescriptorRoot_FileDescriptor( )
1978 fields:fields
1979 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
1980 oneofs:NULL
1981 oneofCount:0
1982 enums:NULL
1983 enumCount:0
1984 ranges:ranges
1985 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
1986 storageSize:sizeof(GPBServiceOptions__storage _)
1987 wireFormat:NO];
1988 NSAssert(descriptor == nil, @"Startup recursed!");
1989 descriptor = localDescriptor;
1990 }
1991 return descriptor;
1992 }
1993
1994 @end
1995
1996 #pragma mark - GPBMethodOptions
1997
1998 @implementation GPBMethodOptions
1999
2000 @dynamic hasDeprecated, deprecated;
2001 @dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
2002
2003 typedef struct GPBMethodOptions__storage_ {
2004 uint32_t _has_storage_[1];
2005 BOOL deprecated;
2006 NSMutableArray *uninterpretedOptionArray;
2007 } GPBMethodOptions__storage_;
2008
2009 // This method is threadsafe because it is initially called
2010 // in +initialize for each subclass.
2011 + (GPBDescriptor *)descriptor {
2012 static GPBDescriptor *descriptor = nil;
2013 if (!descriptor) {
2014 static GPBMessageFieldDescription fields[] = {
2015 {
2016 .name = "deprecated",
2017 .number = GPBMethodOptions_FieldNumber_Deprecated,
2018 .hasIndex = 0,
2019 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
2020 .dataType = GPBDataTypeBool,
2021 .offset = offsetof(GPBMethodOptions__storage_, deprecated),
2022 .defaultValue.valueBool = NO,
2023 .dataTypeSpecific.className = NULL,
2024 .fieldOptions = NULL,
2025 },
2026 {
2027 .name = "uninterpretedOptionArray",
2028 .number = GPBMethodOptions_FieldNumber_UninterpretedOptionArray,
2029 .hasIndex = GPBNoHasBit,
2030 .flags = GPBFieldRepeated,
2031 .dataType = GPBDataTypeMessage,
2032 .offset = offsetof(GPBMethodOptions__storage_, uninterpretedOptionArray) ,
2033 .defaultValue.valueMessage = nil,
2034 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption) ,
2035 .fieldOptions = NULL,
2036 },
2037 };
2038 static GPBExtensionRange ranges[] = {
2039 { .start = 1000, .end = 536870912 },
2040 };
2041 GPBDescriptor *localDescriptor =
2042 [GPBDescriptor allocDescriptorForClass:[GPBMethodOptions class]
2043 rootClass:[GPBDescriptorRoot class]
2044 file:GPBDescriptorRoot_FileDescriptor( )
2045 fields:fields
2046 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2047 oneofs:NULL
2048 oneofCount:0
2049 enums:NULL
2050 enumCount:0
2051 ranges:ranges
2052 rangeCount:sizeof(ranges) / sizeof(GPBExtens ionRange)
2053 storageSize:sizeof(GPBMethodOptions__storage_ )
2054 wireFormat:NO];
2055 NSAssert(descriptor == nil, @"Startup recursed!");
2056 descriptor = localDescriptor;
2057 }
2058 return descriptor;
2059 }
2060
2061 @end
2062
2063 #pragma mark - GPBUninterpretedOption
2064
2065 @implementation GPBUninterpretedOption
2066
2067 @dynamic nameArray, nameArray_Count;
2068 @dynamic hasIdentifierValue, identifierValue;
2069 @dynamic hasPositiveIntValue, positiveIntValue;
2070 @dynamic hasNegativeIntValue, negativeIntValue;
2071 @dynamic hasDoubleValue, doubleValue;
2072 @dynamic hasStringValue, stringValue;
2073 @dynamic hasAggregateValue, aggregateValue;
2074
2075 typedef struct GPBUninterpretedOption__storage_ {
2076 uint32_t _has_storage_[1];
2077 NSMutableArray *nameArray;
2078 NSString *identifierValue;
2079 NSData *stringValue;
2080 NSString *aggregateValue;
2081 uint64_t positiveIntValue;
2082 int64_t negativeIntValue;
2083 double doubleValue;
2084 } GPBUninterpretedOption__storage_;
2085
2086 // This method is threadsafe because it is initially called
2087 // in +initialize for each subclass.
2088 + (GPBDescriptor *)descriptor {
2089 static GPBDescriptor *descriptor = nil;
2090 if (!descriptor) {
2091 static GPBMessageFieldDescription fields[] = {
2092 {
2093 .name = "nameArray",
2094 .number = GPBUninterpretedOption_FieldNumber_NameArray,
2095 .hasIndex = GPBNoHasBit,
2096 .flags = GPBFieldRepeated,
2097 .dataType = GPBDataTypeMessage,
2098 .offset = offsetof(GPBUninterpretedOption__storage_, nameArray),
2099 .defaultValue.valueMessage = nil,
2100 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption_ NamePart),
2101 .fieldOptions = NULL,
2102 },
2103 {
2104 .name = "identifierValue",
2105 .number = GPBUninterpretedOption_FieldNumber_IdentifierValue,
2106 .hasIndex = 1,
2107 .flags = GPBFieldOptional,
2108 .dataType = GPBDataTypeString,
2109 .offset = offsetof(GPBUninterpretedOption__storage_, identifierValue),
2110 .defaultValue.valueString = nil,
2111 .dataTypeSpecific.className = NULL,
2112 .fieldOptions = NULL,
2113 },
2114 {
2115 .name = "positiveIntValue",
2116 .number = GPBUninterpretedOption_FieldNumber_PositiveIntValue,
2117 .hasIndex = 2,
2118 .flags = GPBFieldOptional,
2119 .dataType = GPBDataTypeUInt64,
2120 .offset = offsetof(GPBUninterpretedOption__storage_, positiveIntValue),
2121 .defaultValue.valueUInt64 = 0ULL,
2122 .dataTypeSpecific.className = NULL,
2123 .fieldOptions = NULL,
2124 },
2125 {
2126 .name = "negativeIntValue",
2127 .number = GPBUninterpretedOption_FieldNumber_NegativeIntValue,
2128 .hasIndex = 3,
2129 .flags = GPBFieldOptional,
2130 .dataType = GPBDataTypeInt64,
2131 .offset = offsetof(GPBUninterpretedOption__storage_, negativeIntValue),
2132 .defaultValue.valueInt64 = 0LL,
2133 .dataTypeSpecific.className = NULL,
2134 .fieldOptions = NULL,
2135 },
2136 {
2137 .name = "doubleValue",
2138 .number = GPBUninterpretedOption_FieldNumber_DoubleValue,
2139 .hasIndex = 4,
2140 .flags = GPBFieldOptional,
2141 .dataType = GPBDataTypeDouble,
2142 .offset = offsetof(GPBUninterpretedOption__storage_, doubleValue),
2143 .defaultValue.valueDouble = 0,
2144 .dataTypeSpecific.className = NULL,
2145 .fieldOptions = NULL,
2146 },
2147 {
2148 .name = "stringValue",
2149 .number = GPBUninterpretedOption_FieldNumber_StringValue,
2150 .hasIndex = 5,
2151 .flags = GPBFieldOptional,
2152 .dataType = GPBDataTypeBytes,
2153 .offset = offsetof(GPBUninterpretedOption__storage_, stringValue),
2154 .defaultValue.valueData = nil,
2155 .dataTypeSpecific.className = NULL,
2156 .fieldOptions = NULL,
2157 },
2158 {
2159 .name = "aggregateValue",
2160 .number = GPBUninterpretedOption_FieldNumber_AggregateValue,
2161 .hasIndex = 6,
2162 .flags = GPBFieldOptional,
2163 .dataType = GPBDataTypeString,
2164 .offset = offsetof(GPBUninterpretedOption__storage_, aggregateValue),
2165 .defaultValue.valueString = nil,
2166 .dataTypeSpecific.className = NULL,
2167 .fieldOptions = NULL,
2168 },
2169 };
2170 GPBDescriptor *localDescriptor =
2171 [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption class]
2172 rootClass:[GPBDescriptorRoot class]
2173 file:GPBDescriptorRoot_FileDescriptor( )
2174 fields:fields
2175 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2176 oneofs:NULL
2177 oneofCount:0
2178 enums:NULL
2179 enumCount:0
2180 ranges:NULL
2181 rangeCount:0
2182 storageSize:sizeof(GPBUninterpretedOption__st orage_)
2183 wireFormat:NO];
2184 NSAssert(descriptor == nil, @"Startup recursed!");
2185 descriptor = localDescriptor;
2186 }
2187 return descriptor;
2188 }
2189
2190 @end
2191
2192 #pragma mark - GPBUninterpretedOption_NamePart
2193
2194 @implementation GPBUninterpretedOption_NamePart
2195
2196 @dynamic hasNamePart, namePart;
2197 @dynamic hasIsExtension, isExtension;
2198
2199 typedef struct GPBUninterpretedOption_NamePart__storage_ {
2200 uint32_t _has_storage_[1];
2201 BOOL isExtension;
2202 NSString *namePart;
2203 } GPBUninterpretedOption_NamePart__storage_;
2204
2205 // This method is threadsafe because it is initially called
2206 // in +initialize for each subclass.
2207 + (GPBDescriptor *)descriptor {
2208 static GPBDescriptor *descriptor = nil;
2209 if (!descriptor) {
2210 static GPBMessageFieldDescription fields[] = {
2211 {
2212 .name = "namePart",
2213 .number = GPBUninterpretedOption_NamePart_FieldNumber_NamePart,
2214 .hasIndex = 0,
2215 .flags = GPBFieldRequired,
2216 .dataType = GPBDataTypeString,
2217 .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, namePart),
2218 .defaultValue.valueString = nil,
2219 .dataTypeSpecific.className = NULL,
2220 .fieldOptions = NULL,
2221 },
2222 {
2223 .name = "isExtension",
2224 .number = GPBUninterpretedOption_NamePart_FieldNumber_IsExtension,
2225 .hasIndex = 1,
2226 .flags = GPBFieldRequired,
2227 .dataType = GPBDataTypeBool,
2228 .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, isExtensio n),
2229 .defaultValue.valueBool = NO,
2230 .dataTypeSpecific.className = NULL,
2231 .fieldOptions = NULL,
2232 },
2233 };
2234 GPBDescriptor *localDescriptor =
2235 [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption_NamePart class]
2236 rootClass:[GPBDescriptorRoot class]
2237 file:GPBDescriptorRoot_FileDescriptor( )
2238 fields:fields
2239 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2240 oneofs:NULL
2241 oneofCount:0
2242 enums:NULL
2243 enumCount:0
2244 ranges:NULL
2245 rangeCount:0
2246 storageSize:sizeof(GPBUninterpretedOption_Nam ePart__storage_)
2247 wireFormat:NO];
2248 NSAssert(descriptor == nil, @"Startup recursed!");
2249 descriptor = localDescriptor;
2250 }
2251 return descriptor;
2252 }
2253
2254 @end
2255
2256 #pragma mark - GPBSourceCodeInfo
2257
2258 @implementation GPBSourceCodeInfo
2259
2260 @dynamic locationArray, locationArray_Count;
2261
2262 typedef struct GPBSourceCodeInfo__storage_ {
2263 uint32_t _has_storage_[1];
2264 NSMutableArray *locationArray;
2265 } GPBSourceCodeInfo__storage_;
2266
2267 // This method is threadsafe because it is initially called
2268 // in +initialize for each subclass.
2269 + (GPBDescriptor *)descriptor {
2270 static GPBDescriptor *descriptor = nil;
2271 if (!descriptor) {
2272 static GPBMessageFieldDescription fields[] = {
2273 {
2274 .name = "locationArray",
2275 .number = GPBSourceCodeInfo_FieldNumber_LocationArray,
2276 .hasIndex = GPBNoHasBit,
2277 .flags = GPBFieldRepeated,
2278 .dataType = GPBDataTypeMessage,
2279 .offset = offsetof(GPBSourceCodeInfo__storage_, locationArray),
2280 .defaultValue.valueMessage = nil,
2281 .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo_Locat ion),
2282 .fieldOptions = NULL,
2283 },
2284 };
2285 GPBDescriptor *localDescriptor =
2286 [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo class]
2287 rootClass:[GPBDescriptorRoot class]
2288 file:GPBDescriptorRoot_FileDescriptor( )
2289 fields:fields
2290 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2291 oneofs:NULL
2292 oneofCount:0
2293 enums:NULL
2294 enumCount:0
2295 ranges:NULL
2296 rangeCount:0
2297 storageSize:sizeof(GPBSourceCodeInfo__storage _)
2298 wireFormat:NO];
2299 NSAssert(descriptor == nil, @"Startup recursed!");
2300 descriptor = localDescriptor;
2301 }
2302 return descriptor;
2303 }
2304
2305 @end
2306
2307 #pragma mark - GPBSourceCodeInfo_Location
2308
2309 @implementation GPBSourceCodeInfo_Location
2310
2311 @dynamic pathArray, pathArray_Count;
2312 @dynamic spanArray, spanArray_Count;
2313 @dynamic hasLeadingComments, leadingComments;
2314 @dynamic hasTrailingComments, trailingComments;
2315 @dynamic leadingDetachedCommentsArray, leadingDetachedCommentsArray_Count;
2316
2317 typedef struct GPBSourceCodeInfo_Location__storage_ {
2318 uint32_t _has_storage_[1];
2319 GPBInt32Array *pathArray;
2320 GPBInt32Array *spanArray;
2321 NSString *leadingComments;
2322 NSString *trailingComments;
2323 NSMutableArray *leadingDetachedCommentsArray;
2324 } GPBSourceCodeInfo_Location__storage_;
2325
2326 // This method is threadsafe because it is initially called
2327 // in +initialize for each subclass.
2328 + (GPBDescriptor *)descriptor {
2329 static GPBDescriptor *descriptor = nil;
2330 if (!descriptor) {
2331 static GPBMessageFieldDescription fields[] = {
2332 {
2333 .name = "pathArray",
2334 .number = GPBSourceCodeInfo_Location_FieldNumber_PathArray,
2335 .hasIndex = GPBNoHasBit,
2336 .flags = GPBFieldRepeated | GPBFieldPacked,
2337 .dataType = GPBDataTypeInt32,
2338 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, pathArray),
2339 .defaultValue.valueMessage = nil,
2340 .dataTypeSpecific.className = NULL,
2341 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2342 .fieldOptions = "\000\000\000\002\020\001",
2343 #else
2344 .fieldOptions = NULL,
2345 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2346 },
2347 {
2348 .name = "spanArray",
2349 .number = GPBSourceCodeInfo_Location_FieldNumber_SpanArray,
2350 .hasIndex = GPBNoHasBit,
2351 .flags = GPBFieldRepeated | GPBFieldPacked,
2352 .dataType = GPBDataTypeInt32,
2353 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, spanArray),
2354 .defaultValue.valueMessage = nil,
2355 .dataTypeSpecific.className = NULL,
2356 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2357 .fieldOptions = "\000\000\000\002\020\001",
2358 #else
2359 .fieldOptions = NULL,
2360 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2361 },
2362 {
2363 .name = "leadingComments",
2364 .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingComments,
2365 .hasIndex = 2,
2366 .flags = GPBFieldOptional,
2367 .dataType = GPBDataTypeString,
2368 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingComments ),
2369 .defaultValue.valueString = nil,
2370 .dataTypeSpecific.className = NULL,
2371 .fieldOptions = NULL,
2372 },
2373 {
2374 .name = "trailingComments",
2375 .number = GPBSourceCodeInfo_Location_FieldNumber_TrailingComments,
2376 .hasIndex = 3,
2377 .flags = GPBFieldOptional,
2378 .dataType = GPBDataTypeString,
2379 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, trailingComment s),
2380 .defaultValue.valueString = nil,
2381 .dataTypeSpecific.className = NULL,
2382 .fieldOptions = NULL,
2383 },
2384 {
2385 .name = "leadingDetachedCommentsArray",
2386 .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingDetachedComments Array,
2387 .hasIndex = GPBNoHasBit,
2388 .flags = GPBFieldRepeated,
2389 .dataType = GPBDataTypeString,
2390 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingDetached CommentsArray),
2391 .defaultValue.valueMessage = nil,
2392 .dataTypeSpecific.className = NULL,
2393 .fieldOptions = NULL,
2394 },
2395 };
2396 GPBDescriptor *localDescriptor =
2397 [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo_Location class ]
2398 rootClass:[GPBDescriptorRoot class]
2399 file:GPBDescriptorRoot_FileDescriptor( )
2400 fields:fields
2401 fieldCount:sizeof(fields) / sizeof(GPBMessag eFieldDescription)
2402 oneofs:NULL
2403 oneofCount:0
2404 enums:NULL
2405 enumCount:0
2406 ranges:NULL
2407 rangeCount:0
2408 storageSize:sizeof(GPBSourceCodeInfo_Location __storage_)
2409 wireFormat:NO];
2410 NSAssert(descriptor == nil, @"Startup recursed!");
2411 descriptor = localDescriptor;
2412 }
2413 return descriptor;
2414 }
2415
2416 @end
2417
2418
2419 // @@protoc_insertion_point(global_scope)
OLDNEW
« no previous file with comments | « third_party/protobuf/objectivec/google/protobuf/Descriptor.pbobjc.h ('k') | third_party/protobuf/objectivec/google/protobuf/Duration.pbobjc.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698