Gitiles
Code Review Sign In
realtimeroboticsgroup.org / RealtimeRoboticsGroup / test / 9c614bcb2f399e89b34ef2de7df2834e904c493e / . / objectivec / google / protobuf / Descriptor.pbobjc.m
blob: 4030989310c3e7b7a6c8527209c275c4cb792d34 [file] [log] [blame]
Brian Silverman9c614bc2016-02-15 20:20:02 -0500[diff] [blame^]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
16static 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
34typedef 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(GPBMessageFieldDescription)
63 oneofs:NULL
64 oneofCount:0
65 enums:NULL
66 enumCount:0
67 ranges:NULL
68 rangeCount:0
69 storageSize:sizeof(GPBFileDescriptorSet__storage_)
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
96typedef 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(GPBServiceDescriptorProto),
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_, publicDependencyArray),
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(GPBMessageFieldDescription)
257 oneofs:NULL
258 oneofCount:0
259 enums:NULL
260 enumCount:0
261 ranges:NULL
262 rangeCount:0
263 storageSize:sizeof(GPBFileDescriptorProto__storage_)
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
288typedef 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_ExtensionRange),
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_ReservedRange),
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(GPBMessageFieldDescription)
425 oneofs:NULL
426 oneofCount:0
427 enums:NULL
428 enumCount:0
429 ranges:NULL
430 rangeCount:0
431 storageSize:sizeof(GPBDescriptorProto__storage_)
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
448typedef 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_ExtensionRange class]
485 rootClass:[GPBDescriptorRoot class]
486 file:GPBDescriptorRoot_FileDescriptor()
487 fields:fields
488 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
489 oneofs:NULL
490 oneofCount:0
491 enums:NULL
492 enumCount:0
493 ranges:NULL
494 rangeCount:0
495 storageSize:sizeof(GPBDescriptorProto_ExtensionRange__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
512typedef 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(GPBMessageFieldDescription)
553 oneofs:NULL
554 oneofCount:0
555 enums:NULL
556 enumCount:0
557 ranges:NULL
558 rangeCount:0
559 storageSize:sizeof(GPBDescriptorProto_ReservedRange__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
584typedef 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_EnumDescriptor,
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_EnumDescriptor,
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(GPBMessageFieldDescription)
725 oneofs:NULL
726 oneofCount:0
727 enums:enums
728 enumCount:sizeof(enums) / sizeof(GPBMessageEnumDescription)
729 ranges:NULL
730 rangeCount:0
731 storageSize:sizeof(GPBFieldDescriptorProto__storage_)
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
743GPBEnumDescriptor *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_TypeFixed64 },
753 { .name = "TypeFixed32", .number = GPBFieldDescriptorProto_Type_TypeFixed32 },
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_TypeMessage },
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_TypeSfixed32 },
762 { .name = "TypeSfixed64", .number = GPBFieldDescriptorProto_Type_TypeSfixed64 },
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) / sizeof(GPBMessageEnumValueDescription)
769 enumVerifier:GPBFieldDescriptorProto_Type_IsValidValue];
770 }
771 return descriptor;
772}
773
774BOOL 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
802GPBEnumDescriptor *GPBFieldDescriptorProto_Label_EnumDescriptor(void) {
803 static GPBEnumDescriptor *descriptor = NULL;
804 if (!descriptor) {
805 static GPBMessageEnumValueDescription values[] = {
806 { .name = "LabelOptional", .number = GPBFieldDescriptorProto_Label_LabelOptional },
807 { .name = "LabelRequired", .number = GPBFieldDescriptorProto_Label_LabelRequired },
808 { .name = "LabelRepeated", .number = GPBFieldDescriptorProto_Label_LabelRepeated },
809 };
810 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldDescriptorProto_Label)
811 values:values
812 valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
813 enumVerifier:GPBFieldDescriptorProto_Label_IsValidValue];
814 }
815 return descriptor;
816}
817
818BOOL 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
835typedef 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(GPBMessageFieldDescription)
864 oneofs:NULL
865 oneofCount:0
866 enums:NULL
867 enumCount:0
868 ranges:NULL
869 rangeCount:0
870 storageSize:sizeof(GPBOneofDescriptorProto__storage_)
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
888typedef 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(GPBEnumValueDescriptorProto),
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(GPBMessageFieldDescription)
941 oneofs:NULL
942 oneofCount:0
943 enums:NULL
944 enumCount:0
945 ranges:NULL
946 rangeCount:0
947 storageSize:sizeof(GPBEnumDescriptorProto__storage_)
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
965typedef 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 class]
1014 rootClass:[GPBDescriptorRoot class]
1015 file:GPBDescriptorRoot_FileDescriptor()
1016 fields:fields
1017 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
1018 oneofs:NULL
1019 oneofCount:0
1020 enums:NULL
1021 enumCount:0
1022 ranges:NULL
1023 rangeCount:0
1024 storageSize:sizeof(GPBEnumValueDescriptorProto__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
1042typedef 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(GPBMethodDescriptorProto),
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(GPBMessageFieldDescription)
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
1122typedef 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(GPBMessageFieldDescription)
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
1248typedef 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 | GPBFieldHasEnumDescriptor,
1301 .dataType = GPBDataTypeEnum,
1302 .offset = offsetof(GPBFileOptions__storage_, optimizeFor),
1303 .defaultValue.valueEnum = GPBFileOptions_OptimizeMode_Speed,
1304 .dataTypeSpecific.enumDescFunc = GPBFileOptions_OptimizeMode_EnumDescriptor,
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_, javananoUseDeprecatedPackage),
1435 .defaultValue.valueBool = NO,
1436 .dataTypeSpecific.className = NULL,
1437 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
1438 .fieldOptions = "\000\000\000\002\030\001",
1439 #else
1440 .fieldOptions = NULL,
1441 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
1442 },
1443 {
1444 .name = "uninterpretedOptionArray",
1445 .number = GPBFileOptions_FieldNumber_UninterpretedOptionArray,
1446 .hasIndex = GPBNoHasBit,
1447 .flags = GPBFieldRepeated,
1448 .dataType = GPBDataTypeMessage,
1449 .offset = offsetof(GPBFileOptions__storage_, uninterpretedOptionArray),
1450 .defaultValue.valueMessage = nil,
1451 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
1452 .fieldOptions = NULL,
1453 },
1454 };
1455 static GPBMessageEnumDescription enums[] = {
1456 { .enumDescriptorFunc = GPBFileOptions_OptimizeMode_EnumDescriptor },
1457 };
1458 static GPBExtensionRange ranges[] = {
1459 { .start = 1000, .end = 536870912 },
1460 };
1461 GPBDescriptor *localDescriptor =
1462 [GPBDescriptor allocDescriptorForClass:[GPBFileOptions class]
1463 rootClass:[GPBDescriptorRoot class]
1464 file:GPBDescriptorRoot_FileDescriptor()
1465 fields:fields
1466 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
1467 oneofs:NULL
1468 oneofCount:0
1469 enums:enums
1470 enumCount:sizeof(enums) / sizeof(GPBMessageEnumDescription)
1471 ranges:ranges
1472 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
1473 storageSize:sizeof(GPBFileOptions__storage_)
1474 wireFormat:NO];
1475 NSAssert(descriptor == nil, @"Startup recursed!");
1476 descriptor = localDescriptor;
1477 }
1478 return descriptor;
1479}
1480
1481@end
1482
1483#pragma mark - Enum GPBFileOptions_OptimizeMode
1484
1485GPBEnumDescriptor *GPBFileOptions_OptimizeMode_EnumDescriptor(void) {
1486 static GPBEnumDescriptor *descriptor = NULL;
1487 if (!descriptor) {
1488 static GPBMessageEnumValueDescription values[] = {
1489 { .name = "Speed", .number = GPBFileOptions_OptimizeMode_Speed },
1490 { .name = "CodeSize", .number = GPBFileOptions_OptimizeMode_CodeSize },
1491 { .name = "LiteRuntime", .number = GPBFileOptions_OptimizeMode_LiteRuntime },
1492 };
1493 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFileOptions_OptimizeMode)
1494 values:values
1495 valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
1496 enumVerifier:GPBFileOptions_OptimizeMode_IsValidValue];
1497 }
1498 return descriptor;
1499}
1500
1501BOOL GPBFileOptions_OptimizeMode_IsValidValue(int32_t value__) {
1502 switch (value__) {
1503 case GPBFileOptions_OptimizeMode_Speed:
1504 case GPBFileOptions_OptimizeMode_CodeSize:
1505 case GPBFileOptions_OptimizeMode_LiteRuntime:
1506 return YES;
1507 default:
1508 return NO;
1509 }
1510}
1511
1512#pragma mark - GPBMessageOptions
1513
1514@implementation GPBMessageOptions
1515
1516@dynamic hasMessageSetWireFormat, messageSetWireFormat;
1517@dynamic hasNoStandardDescriptorAccessor, noStandardDescriptorAccessor;
1518@dynamic hasDeprecated, deprecated;
1519@dynamic hasMapEntry, mapEntry;
1520@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1521
1522typedef struct GPBMessageOptions__storage_ {
1523 uint32_t _has_storage_[1];
1524 BOOL messageSetWireFormat;
1525 BOOL noStandardDescriptorAccessor;
1526 BOOL deprecated;
1527 BOOL mapEntry;
1528 NSMutableArray *uninterpretedOptionArray;
1529} GPBMessageOptions__storage_;
1530
1531// This method is threadsafe because it is initially called
1532// in +initialize for each subclass.
1533+ (GPBDescriptor *)descriptor {
1534 static GPBDescriptor *descriptor = nil;
1535 if (!descriptor) {
1536 static GPBMessageFieldDescription fields[] = {
1537 {
1538 .name = "messageSetWireFormat",
1539 .number = GPBMessageOptions_FieldNumber_MessageSetWireFormat,
1540 .hasIndex = 0,
1541 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1542 .dataType = GPBDataTypeBool,
1543 .offset = offsetof(GPBMessageOptions__storage_, messageSetWireFormat),
1544 .defaultValue.valueBool = NO,
1545 .dataTypeSpecific.className = NULL,
1546 .fieldOptions = NULL,
1547 },
1548 {
1549 .name = "noStandardDescriptorAccessor",
1550 .number = GPBMessageOptions_FieldNumber_NoStandardDescriptorAccessor,
1551 .hasIndex = 1,
1552 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1553 .dataType = GPBDataTypeBool,
1554 .offset = offsetof(GPBMessageOptions__storage_, noStandardDescriptorAccessor),
1555 .defaultValue.valueBool = NO,
1556 .dataTypeSpecific.className = NULL,
1557 .fieldOptions = NULL,
1558 },
1559 {
1560 .name = "deprecated",
1561 .number = GPBMessageOptions_FieldNumber_Deprecated,
1562 .hasIndex = 2,
1563 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1564 .dataType = GPBDataTypeBool,
1565 .offset = offsetof(GPBMessageOptions__storage_, deprecated),
1566 .defaultValue.valueBool = NO,
1567 .dataTypeSpecific.className = NULL,
1568 .fieldOptions = NULL,
1569 },
1570 {
1571 .name = "mapEntry",
1572 .number = GPBMessageOptions_FieldNumber_MapEntry,
1573 .hasIndex = 3,
1574 .flags = GPBFieldOptional,
1575 .dataType = GPBDataTypeBool,
1576 .offset = offsetof(GPBMessageOptions__storage_, mapEntry),
1577 .defaultValue.valueBool = NO,
1578 .dataTypeSpecific.className = NULL,
1579 .fieldOptions = NULL,
1580 },
1581 {
1582 .name = "uninterpretedOptionArray",
1583 .number = GPBMessageOptions_FieldNumber_UninterpretedOptionArray,
1584 .hasIndex = GPBNoHasBit,
1585 .flags = GPBFieldRepeated,
1586 .dataType = GPBDataTypeMessage,
1587 .offset = offsetof(GPBMessageOptions__storage_, uninterpretedOptionArray),
1588 .defaultValue.valueMessage = nil,
1589 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
1590 .fieldOptions = NULL,
1591 },
1592 };
1593 static GPBExtensionRange ranges[] = {
1594 { .start = 1000, .end = 536870912 },
1595 };
1596 GPBDescriptor *localDescriptor =
1597 [GPBDescriptor allocDescriptorForClass:[GPBMessageOptions class]
1598 rootClass:[GPBDescriptorRoot class]
1599 file:GPBDescriptorRoot_FileDescriptor()
1600 fields:fields
1601 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
1602 oneofs:NULL
1603 oneofCount:0
1604 enums:NULL
1605 enumCount:0
1606 ranges:ranges
1607 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
1608 storageSize:sizeof(GPBMessageOptions__storage_)
1609 wireFormat:NO];
1610 NSAssert(descriptor == nil, @"Startup recursed!");
1611 descriptor = localDescriptor;
1612 }
1613 return descriptor;
1614}
1615
1616@end
1617
1618#pragma mark - GPBFieldOptions
1619
1620@implementation GPBFieldOptions
1621
1622@dynamic hasCtype, ctype;
1623@dynamic hasPacked, packed;
1624@dynamic hasJstype, jstype;
1625@dynamic hasLazy, lazy;
1626@dynamic hasDeprecated, deprecated;
1627@dynamic hasWeak, weak;
1628@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1629
1630typedef struct GPBFieldOptions__storage_ {
1631 uint32_t _has_storage_[1];
1632 BOOL packed;
1633 BOOL deprecated;
1634 BOOL lazy;
1635 BOOL weak;
1636 GPBFieldOptions_CType ctype;
1637 GPBFieldOptions_JSType jstype;
1638 NSMutableArray *uninterpretedOptionArray;
1639} GPBFieldOptions__storage_;
1640
1641// This method is threadsafe because it is initially called
1642// in +initialize for each subclass.
1643+ (GPBDescriptor *)descriptor {
1644 static GPBDescriptor *descriptor = nil;
1645 if (!descriptor) {
1646 static GPBMessageFieldDescription fields[] = {
1647 {
1648 .name = "ctype",
1649 .number = GPBFieldOptions_FieldNumber_Ctype,
1650 .hasIndex = 0,
1651 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
1652 .dataType = GPBDataTypeEnum,
1653 .offset = offsetof(GPBFieldOptions__storage_, ctype),
1654 .defaultValue.valueEnum = GPBFieldOptions_CType_String,
1655 .dataTypeSpecific.enumDescFunc = GPBFieldOptions_CType_EnumDescriptor,
1656 .fieldOptions = NULL,
1657 },
1658 {
1659 .name = "packed",
1660 .number = GPBFieldOptions_FieldNumber_Packed,
1661 .hasIndex = 1,
1662 .flags = GPBFieldOptional,
1663 .dataType = GPBDataTypeBool,
1664 .offset = offsetof(GPBFieldOptions__storage_, packed),
1665 .defaultValue.valueBool = NO,
1666 .dataTypeSpecific.className = NULL,
1667 .fieldOptions = NULL,
1668 },
1669 {
1670 .name = "deprecated",
1671 .number = GPBFieldOptions_FieldNumber_Deprecated,
1672 .hasIndex = 4,
1673 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1674 .dataType = GPBDataTypeBool,
1675 .offset = offsetof(GPBFieldOptions__storage_, deprecated),
1676 .defaultValue.valueBool = NO,
1677 .dataTypeSpecific.className = NULL,
1678 .fieldOptions = NULL,
1679 },
1680 {
1681 .name = "lazy",
1682 .number = GPBFieldOptions_FieldNumber_Lazy,
1683 .hasIndex = 3,
1684 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1685 .dataType = GPBDataTypeBool,
1686 .offset = offsetof(GPBFieldOptions__storage_, lazy),
1687 .defaultValue.valueBool = NO,
1688 .dataTypeSpecific.className = NULL,
1689 .fieldOptions = NULL,
1690 },
1691 {
1692 .name = "jstype",
1693 .number = GPBFieldOptions_FieldNumber_Jstype,
1694 .hasIndex = 2,
1695 .flags = GPBFieldOptional | GPBFieldHasDefaultValue | GPBFieldHasEnumDescriptor,
1696 .dataType = GPBDataTypeEnum,
1697 .offset = offsetof(GPBFieldOptions__storage_, jstype),
1698 .defaultValue.valueEnum = GPBFieldOptions_JSType_JsNormal,
1699 .dataTypeSpecific.enumDescFunc = GPBFieldOptions_JSType_EnumDescriptor,
1700 .fieldOptions = NULL,
1701 },
1702 {
1703 .name = "weak",
1704 .number = GPBFieldOptions_FieldNumber_Weak,
1705 .hasIndex = 5,
1706 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1707 .dataType = GPBDataTypeBool,
1708 .offset = offsetof(GPBFieldOptions__storage_, weak),
1709 .defaultValue.valueBool = NO,
1710 .dataTypeSpecific.className = NULL,
1711 .fieldOptions = NULL,
1712 },
1713 {
1714 .name = "uninterpretedOptionArray",
1715 .number = GPBFieldOptions_FieldNumber_UninterpretedOptionArray,
1716 .hasIndex = GPBNoHasBit,
1717 .flags = GPBFieldRepeated,
1718 .dataType = GPBDataTypeMessage,
1719 .offset = offsetof(GPBFieldOptions__storage_, uninterpretedOptionArray),
1720 .defaultValue.valueMessage = nil,
1721 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
1722 .fieldOptions = NULL,
1723 },
1724 };
1725 static GPBMessageEnumDescription enums[] = {
1726 { .enumDescriptorFunc = GPBFieldOptions_CType_EnumDescriptor },
1727 { .enumDescriptorFunc = GPBFieldOptions_JSType_EnumDescriptor },
1728 };
1729 static GPBExtensionRange ranges[] = {
1730 { .start = 1000, .end = 536870912 },
1731 };
1732 GPBDescriptor *localDescriptor =
1733 [GPBDescriptor allocDescriptorForClass:[GPBFieldOptions class]
1734 rootClass:[GPBDescriptorRoot class]
1735 file:GPBDescriptorRoot_FileDescriptor()
1736 fields:fields
1737 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
1738 oneofs:NULL
1739 oneofCount:0
1740 enums:enums
1741 enumCount:sizeof(enums) / sizeof(GPBMessageEnumDescription)
1742 ranges:ranges
1743 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
1744 storageSize:sizeof(GPBFieldOptions__storage_)
1745 wireFormat:NO];
1746 NSAssert(descriptor == nil, @"Startup recursed!");
1747 descriptor = localDescriptor;
1748 }
1749 return descriptor;
1750}
1751
1752@end
1753
1754#pragma mark - Enum GPBFieldOptions_CType
1755
1756GPBEnumDescriptor *GPBFieldOptions_CType_EnumDescriptor(void) {
1757 static GPBEnumDescriptor *descriptor = NULL;
1758 if (!descriptor) {
1759 static GPBMessageEnumValueDescription values[] = {
1760 { .name = "String", .number = GPBFieldOptions_CType_String },
1761 { .name = "Cord", .number = GPBFieldOptions_CType_Cord },
1762 { .name = "StringPiece", .number = GPBFieldOptions_CType_StringPiece },
1763 };
1764 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldOptions_CType)
1765 values:values
1766 valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
1767 enumVerifier:GPBFieldOptions_CType_IsValidValue];
1768 }
1769 return descriptor;
1770}
1771
1772BOOL GPBFieldOptions_CType_IsValidValue(int32_t value__) {
1773 switch (value__) {
1774 case GPBFieldOptions_CType_String:
1775 case GPBFieldOptions_CType_Cord:
1776 case GPBFieldOptions_CType_StringPiece:
1777 return YES;
1778 default:
1779 return NO;
1780 }
1781}
1782
1783#pragma mark - Enum GPBFieldOptions_JSType
1784
1785GPBEnumDescriptor *GPBFieldOptions_JSType_EnumDescriptor(void) {
1786 static GPBEnumDescriptor *descriptor = NULL;
1787 if (!descriptor) {
1788 static GPBMessageEnumValueDescription values[] = {
1789 { .name = "JsNormal", .number = GPBFieldOptions_JSType_JsNormal },
1790 { .name = "JsString", .number = GPBFieldOptions_JSType_JsString },
1791 { .name = "JsNumber", .number = GPBFieldOptions_JSType_JsNumber },
1792 };
1793 descriptor = [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBFieldOptions_JSType)
1794 values:values
1795 valueCount:sizeof(values) / sizeof(GPBMessageEnumValueDescription)
1796 enumVerifier:GPBFieldOptions_JSType_IsValidValue];
1797 }
1798 return descriptor;
1799}
1800
1801BOOL GPBFieldOptions_JSType_IsValidValue(int32_t value__) {
1802 switch (value__) {
1803 case GPBFieldOptions_JSType_JsNormal:
1804 case GPBFieldOptions_JSType_JsString:
1805 case GPBFieldOptions_JSType_JsNumber:
1806 return YES;
1807 default:
1808 return NO;
1809 }
1810}
1811
1812#pragma mark - GPBEnumOptions
1813
1814@implementation GPBEnumOptions
1815
1816@dynamic hasAllowAlias, allowAlias;
1817@dynamic hasDeprecated, deprecated;
1818@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1819
1820typedef struct GPBEnumOptions__storage_ {
1821 uint32_t _has_storage_[1];
1822 BOOL allowAlias;
1823 BOOL deprecated;
1824 NSMutableArray *uninterpretedOptionArray;
1825} GPBEnumOptions__storage_;
1826
1827// This method is threadsafe because it is initially called
1828// in +initialize for each subclass.
1829+ (GPBDescriptor *)descriptor {
1830 static GPBDescriptor *descriptor = nil;
1831 if (!descriptor) {
1832 static GPBMessageFieldDescription fields[] = {
1833 {
1834 .name = "allowAlias",
1835 .number = GPBEnumOptions_FieldNumber_AllowAlias,
1836 .hasIndex = 0,
1837 .flags = GPBFieldOptional,
1838 .dataType = GPBDataTypeBool,
1839 .offset = offsetof(GPBEnumOptions__storage_, allowAlias),
1840 .defaultValue.valueBool = NO,
1841 .dataTypeSpecific.className = NULL,
1842 .fieldOptions = NULL,
1843 },
1844 {
1845 .name = "deprecated",
1846 .number = GPBEnumOptions_FieldNumber_Deprecated,
1847 .hasIndex = 1,
1848 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1849 .dataType = GPBDataTypeBool,
1850 .offset = offsetof(GPBEnumOptions__storage_, deprecated),
1851 .defaultValue.valueBool = NO,
1852 .dataTypeSpecific.className = NULL,
1853 .fieldOptions = NULL,
1854 },
1855 {
1856 .name = "uninterpretedOptionArray",
1857 .number = GPBEnumOptions_FieldNumber_UninterpretedOptionArray,
1858 .hasIndex = GPBNoHasBit,
1859 .flags = GPBFieldRepeated,
1860 .dataType = GPBDataTypeMessage,
1861 .offset = offsetof(GPBEnumOptions__storage_, uninterpretedOptionArray),
1862 .defaultValue.valueMessage = nil,
1863 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
1864 .fieldOptions = NULL,
1865 },
1866 };
1867 static GPBExtensionRange ranges[] = {
1868 { .start = 1000, .end = 536870912 },
1869 };
1870 GPBDescriptor *localDescriptor =
1871 [GPBDescriptor allocDescriptorForClass:[GPBEnumOptions class]
1872 rootClass:[GPBDescriptorRoot class]
1873 file:GPBDescriptorRoot_FileDescriptor()
1874 fields:fields
1875 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
1876 oneofs:NULL
1877 oneofCount:0
1878 enums:NULL
1879 enumCount:0
1880 ranges:ranges
1881 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
1882 storageSize:sizeof(GPBEnumOptions__storage_)
1883 wireFormat:NO];
1884 NSAssert(descriptor == nil, @"Startup recursed!");
1885 descriptor = localDescriptor;
1886 }
1887 return descriptor;
1888}
1889
1890@end
1891
1892#pragma mark - GPBEnumValueOptions
1893
1894@implementation GPBEnumValueOptions
1895
1896@dynamic hasDeprecated, deprecated;
1897@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1898
1899typedef struct GPBEnumValueOptions__storage_ {
1900 uint32_t _has_storage_[1];
1901 BOOL deprecated;
1902 NSMutableArray *uninterpretedOptionArray;
1903} GPBEnumValueOptions__storage_;
1904
1905// This method is threadsafe because it is initially called
1906// in +initialize for each subclass.
1907+ (GPBDescriptor *)descriptor {
1908 static GPBDescriptor *descriptor = nil;
1909 if (!descriptor) {
1910 static GPBMessageFieldDescription fields[] = {
1911 {
1912 .name = "deprecated",
1913 .number = GPBEnumValueOptions_FieldNumber_Deprecated,
1914 .hasIndex = 0,
1915 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1916 .dataType = GPBDataTypeBool,
1917 .offset = offsetof(GPBEnumValueOptions__storage_, deprecated),
1918 .defaultValue.valueBool = NO,
1919 .dataTypeSpecific.className = NULL,
1920 .fieldOptions = NULL,
1921 },
1922 {
1923 .name = "uninterpretedOptionArray",
1924 .number = GPBEnumValueOptions_FieldNumber_UninterpretedOptionArray,
1925 .hasIndex = GPBNoHasBit,
1926 .flags = GPBFieldRepeated,
1927 .dataType = GPBDataTypeMessage,
1928 .offset = offsetof(GPBEnumValueOptions__storage_, uninterpretedOptionArray),
1929 .defaultValue.valueMessage = nil,
1930 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
1931 .fieldOptions = NULL,
1932 },
1933 };
1934 static GPBExtensionRange ranges[] = {
1935 { .start = 1000, .end = 536870912 },
1936 };
1937 GPBDescriptor *localDescriptor =
1938 [GPBDescriptor allocDescriptorForClass:[GPBEnumValueOptions class]
1939 rootClass:[GPBDescriptorRoot class]
1940 file:GPBDescriptorRoot_FileDescriptor()
1941 fields:fields
1942 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
1943 oneofs:NULL
1944 oneofCount:0
1945 enums:NULL
1946 enumCount:0
1947 ranges:ranges
1948 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
1949 storageSize:sizeof(GPBEnumValueOptions__storage_)
1950 wireFormat:NO];
1951 NSAssert(descriptor == nil, @"Startup recursed!");
1952 descriptor = localDescriptor;
1953 }
1954 return descriptor;
1955}
1956
1957@end
1958
1959#pragma mark - GPBServiceOptions
1960
1961@implementation GPBServiceOptions
1962
1963@dynamic hasDeprecated, deprecated;
1964@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
1965
1966typedef struct GPBServiceOptions__storage_ {
1967 uint32_t _has_storage_[1];
1968 BOOL deprecated;
1969 NSMutableArray *uninterpretedOptionArray;
1970} GPBServiceOptions__storage_;
1971
1972// This method is threadsafe because it is initially called
1973// in +initialize for each subclass.
1974+ (GPBDescriptor *)descriptor {
1975 static GPBDescriptor *descriptor = nil;
1976 if (!descriptor) {
1977 static GPBMessageFieldDescription fields[] = {
1978 {
1979 .name = "deprecated",
1980 .number = GPBServiceOptions_FieldNumber_Deprecated,
1981 .hasIndex = 0,
1982 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
1983 .dataType = GPBDataTypeBool,
1984 .offset = offsetof(GPBServiceOptions__storage_, deprecated),
1985 .defaultValue.valueBool = NO,
1986 .dataTypeSpecific.className = NULL,
1987 .fieldOptions = NULL,
1988 },
1989 {
1990 .name = "uninterpretedOptionArray",
1991 .number = GPBServiceOptions_FieldNumber_UninterpretedOptionArray,
1992 .hasIndex = GPBNoHasBit,
1993 .flags = GPBFieldRepeated,
1994 .dataType = GPBDataTypeMessage,
1995 .offset = offsetof(GPBServiceOptions__storage_, uninterpretedOptionArray),
1996 .defaultValue.valueMessage = nil,
1997 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
1998 .fieldOptions = NULL,
1999 },
2000 };
2001 static GPBExtensionRange ranges[] = {
2002 { .start = 1000, .end = 536870912 },
2003 };
2004 GPBDescriptor *localDescriptor =
2005 [GPBDescriptor allocDescriptorForClass:[GPBServiceOptions class]
2006 rootClass:[GPBDescriptorRoot class]
2007 file:GPBDescriptorRoot_FileDescriptor()
2008 fields:fields
2009 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2010 oneofs:NULL
2011 oneofCount:0
2012 enums:NULL
2013 enumCount:0
2014 ranges:ranges
2015 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
2016 storageSize:sizeof(GPBServiceOptions__storage_)
2017 wireFormat:NO];
2018 NSAssert(descriptor == nil, @"Startup recursed!");
2019 descriptor = localDescriptor;
2020 }
2021 return descriptor;
2022}
2023
2024@end
2025
2026#pragma mark - GPBMethodOptions
2027
2028@implementation GPBMethodOptions
2029
2030@dynamic hasDeprecated, deprecated;
2031@dynamic uninterpretedOptionArray, uninterpretedOptionArray_Count;
2032
2033typedef struct GPBMethodOptions__storage_ {
2034 uint32_t _has_storage_[1];
2035 BOOL deprecated;
2036 NSMutableArray *uninterpretedOptionArray;
2037} GPBMethodOptions__storage_;
2038
2039// This method is threadsafe because it is initially called
2040// in +initialize for each subclass.
2041+ (GPBDescriptor *)descriptor {
2042 static GPBDescriptor *descriptor = nil;
2043 if (!descriptor) {
2044 static GPBMessageFieldDescription fields[] = {
2045 {
2046 .name = "deprecated",
2047 .number = GPBMethodOptions_FieldNumber_Deprecated,
2048 .hasIndex = 0,
2049 .flags = GPBFieldOptional | GPBFieldHasDefaultValue,
2050 .dataType = GPBDataTypeBool,
2051 .offset = offsetof(GPBMethodOptions__storage_, deprecated),
2052 .defaultValue.valueBool = NO,
2053 .dataTypeSpecific.className = NULL,
2054 .fieldOptions = NULL,
2055 },
2056 {
2057 .name = "uninterpretedOptionArray",
2058 .number = GPBMethodOptions_FieldNumber_UninterpretedOptionArray,
2059 .hasIndex = GPBNoHasBit,
2060 .flags = GPBFieldRepeated,
2061 .dataType = GPBDataTypeMessage,
2062 .offset = offsetof(GPBMethodOptions__storage_, uninterpretedOptionArray),
2063 .defaultValue.valueMessage = nil,
2064 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption),
2065 .fieldOptions = NULL,
2066 },
2067 };
2068 static GPBExtensionRange ranges[] = {
2069 { .start = 1000, .end = 536870912 },
2070 };
2071 GPBDescriptor *localDescriptor =
2072 [GPBDescriptor allocDescriptorForClass:[GPBMethodOptions class]
2073 rootClass:[GPBDescriptorRoot class]
2074 file:GPBDescriptorRoot_FileDescriptor()
2075 fields:fields
2076 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2077 oneofs:NULL
2078 oneofCount:0
2079 enums:NULL
2080 enumCount:0
2081 ranges:ranges
2082 rangeCount:sizeof(ranges) / sizeof(GPBExtensionRange)
2083 storageSize:sizeof(GPBMethodOptions__storage_)
2084 wireFormat:NO];
2085 NSAssert(descriptor == nil, @"Startup recursed!");
2086 descriptor = localDescriptor;
2087 }
2088 return descriptor;
2089}
2090
2091@end
2092
2093#pragma mark - GPBUninterpretedOption
2094
2095@implementation GPBUninterpretedOption
2096
2097@dynamic nameArray, nameArray_Count;
2098@dynamic hasIdentifierValue, identifierValue;
2099@dynamic hasPositiveIntValue, positiveIntValue;
2100@dynamic hasNegativeIntValue, negativeIntValue;
2101@dynamic hasDoubleValue, doubleValue;
2102@dynamic hasStringValue, stringValue;
2103@dynamic hasAggregateValue, aggregateValue;
2104
2105typedef struct GPBUninterpretedOption__storage_ {
2106 uint32_t _has_storage_[1];
2107 NSMutableArray *nameArray;
2108 NSString *identifierValue;
2109 NSData *stringValue;
2110 NSString *aggregateValue;
2111 uint64_t positiveIntValue;
2112 int64_t negativeIntValue;
2113 double doubleValue;
2114} GPBUninterpretedOption__storage_;
2115
2116// This method is threadsafe because it is initially called
2117// in +initialize for each subclass.
2118+ (GPBDescriptor *)descriptor {
2119 static GPBDescriptor *descriptor = nil;
2120 if (!descriptor) {
2121 static GPBMessageFieldDescription fields[] = {
2122 {
2123 .name = "nameArray",
2124 .number = GPBUninterpretedOption_FieldNumber_NameArray,
2125 .hasIndex = GPBNoHasBit,
2126 .flags = GPBFieldRepeated,
2127 .dataType = GPBDataTypeMessage,
2128 .offset = offsetof(GPBUninterpretedOption__storage_, nameArray),
2129 .defaultValue.valueMessage = nil,
2130 .dataTypeSpecific.className = GPBStringifySymbol(GPBUninterpretedOption_NamePart),
2131 .fieldOptions = NULL,
2132 },
2133 {
2134 .name = "identifierValue",
2135 .number = GPBUninterpretedOption_FieldNumber_IdentifierValue,
2136 .hasIndex = 1,
2137 .flags = GPBFieldOptional,
2138 .dataType = GPBDataTypeString,
2139 .offset = offsetof(GPBUninterpretedOption__storage_, identifierValue),
2140 .defaultValue.valueString = nil,
2141 .dataTypeSpecific.className = NULL,
2142 .fieldOptions = NULL,
2143 },
2144 {
2145 .name = "positiveIntValue",
2146 .number = GPBUninterpretedOption_FieldNumber_PositiveIntValue,
2147 .hasIndex = 2,
2148 .flags = GPBFieldOptional,
2149 .dataType = GPBDataTypeUInt64,
2150 .offset = offsetof(GPBUninterpretedOption__storage_, positiveIntValue),
2151 .defaultValue.valueUInt64 = 0ULL,
2152 .dataTypeSpecific.className = NULL,
2153 .fieldOptions = NULL,
2154 },
2155 {
2156 .name = "negativeIntValue",
2157 .number = GPBUninterpretedOption_FieldNumber_NegativeIntValue,
2158 .hasIndex = 3,
2159 .flags = GPBFieldOptional,
2160 .dataType = GPBDataTypeInt64,
2161 .offset = offsetof(GPBUninterpretedOption__storage_, negativeIntValue),
2162 .defaultValue.valueInt64 = 0LL,
2163 .dataTypeSpecific.className = NULL,
2164 .fieldOptions = NULL,
2165 },
2166 {
2167 .name = "doubleValue",
2168 .number = GPBUninterpretedOption_FieldNumber_DoubleValue,
2169 .hasIndex = 4,
2170 .flags = GPBFieldOptional,
2171 .dataType = GPBDataTypeDouble,
2172 .offset = offsetof(GPBUninterpretedOption__storage_, doubleValue),
2173 .defaultValue.valueDouble = 0,
2174 .dataTypeSpecific.className = NULL,
2175 .fieldOptions = NULL,
2176 },
2177 {
2178 .name = "stringValue",
2179 .number = GPBUninterpretedOption_FieldNumber_StringValue,
2180 .hasIndex = 5,
2181 .flags = GPBFieldOptional,
2182 .dataType = GPBDataTypeBytes,
2183 .offset = offsetof(GPBUninterpretedOption__storage_, stringValue),
2184 .defaultValue.valueData = nil,
2185 .dataTypeSpecific.className = NULL,
2186 .fieldOptions = NULL,
2187 },
2188 {
2189 .name = "aggregateValue",
2190 .number = GPBUninterpretedOption_FieldNumber_AggregateValue,
2191 .hasIndex = 6,
2192 .flags = GPBFieldOptional,
2193 .dataType = GPBDataTypeString,
2194 .offset = offsetof(GPBUninterpretedOption__storage_, aggregateValue),
2195 .defaultValue.valueString = nil,
2196 .dataTypeSpecific.className = NULL,
2197 .fieldOptions = NULL,
2198 },
2199 };
2200 GPBDescriptor *localDescriptor =
2201 [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption class]
2202 rootClass:[GPBDescriptorRoot class]
2203 file:GPBDescriptorRoot_FileDescriptor()
2204 fields:fields
2205 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2206 oneofs:NULL
2207 oneofCount:0
2208 enums:NULL
2209 enumCount:0
2210 ranges:NULL
2211 rangeCount:0
2212 storageSize:sizeof(GPBUninterpretedOption__storage_)
2213 wireFormat:NO];
2214 NSAssert(descriptor == nil, @"Startup recursed!");
2215 descriptor = localDescriptor;
2216 }
2217 return descriptor;
2218}
2219
2220@end
2221
2222#pragma mark - GPBUninterpretedOption_NamePart
2223
2224@implementation GPBUninterpretedOption_NamePart
2225
2226@dynamic hasNamePart, namePart;
2227@dynamic hasIsExtension, isExtension;
2228
2229typedef struct GPBUninterpretedOption_NamePart__storage_ {
2230 uint32_t _has_storage_[1];
2231 BOOL isExtension;
2232 NSString *namePart;
2233} GPBUninterpretedOption_NamePart__storage_;
2234
2235// This method is threadsafe because it is initially called
2236// in +initialize for each subclass.
2237+ (GPBDescriptor *)descriptor {
2238 static GPBDescriptor *descriptor = nil;
2239 if (!descriptor) {
2240 static GPBMessageFieldDescription fields[] = {
2241 {
2242 .name = "namePart",
2243 .number = GPBUninterpretedOption_NamePart_FieldNumber_NamePart,
2244 .hasIndex = 0,
2245 .flags = GPBFieldRequired,
2246 .dataType = GPBDataTypeString,
2247 .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, namePart),
2248 .defaultValue.valueString = nil,
2249 .dataTypeSpecific.className = NULL,
2250 .fieldOptions = NULL,
2251 },
2252 {
2253 .name = "isExtension",
2254 .number = GPBUninterpretedOption_NamePart_FieldNumber_IsExtension,
2255 .hasIndex = 1,
2256 .flags = GPBFieldRequired,
2257 .dataType = GPBDataTypeBool,
2258 .offset = offsetof(GPBUninterpretedOption_NamePart__storage_, isExtension),
2259 .defaultValue.valueBool = NO,
2260 .dataTypeSpecific.className = NULL,
2261 .fieldOptions = NULL,
2262 },
2263 };
2264 GPBDescriptor *localDescriptor =
2265 [GPBDescriptor allocDescriptorForClass:[GPBUninterpretedOption_NamePart class]
2266 rootClass:[GPBDescriptorRoot class]
2267 file:GPBDescriptorRoot_FileDescriptor()
2268 fields:fields
2269 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2270 oneofs:NULL
2271 oneofCount:0
2272 enums:NULL
2273 enumCount:0
2274 ranges:NULL
2275 rangeCount:0
2276 storageSize:sizeof(GPBUninterpretedOption_NamePart__storage_)
2277 wireFormat:NO];
2278 NSAssert(descriptor == nil, @"Startup recursed!");
2279 descriptor = localDescriptor;
2280 }
2281 return descriptor;
2282}
2283
2284@end
2285
2286#pragma mark - GPBSourceCodeInfo
2287
2288@implementation GPBSourceCodeInfo
2289
2290@dynamic locationArray, locationArray_Count;
2291
2292typedef struct GPBSourceCodeInfo__storage_ {
2293 uint32_t _has_storage_[1];
2294 NSMutableArray *locationArray;
2295} GPBSourceCodeInfo__storage_;
2296
2297// This method is threadsafe because it is initially called
2298// in +initialize for each subclass.
2299+ (GPBDescriptor *)descriptor {
2300 static GPBDescriptor *descriptor = nil;
2301 if (!descriptor) {
2302 static GPBMessageFieldDescription fields[] = {
2303 {
2304 .name = "locationArray",
2305 .number = GPBSourceCodeInfo_FieldNumber_LocationArray,
2306 .hasIndex = GPBNoHasBit,
2307 .flags = GPBFieldRepeated,
2308 .dataType = GPBDataTypeMessage,
2309 .offset = offsetof(GPBSourceCodeInfo__storage_, locationArray),
2310 .defaultValue.valueMessage = nil,
2311 .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceCodeInfo_Location),
2312 .fieldOptions = NULL,
2313 },
2314 };
2315 GPBDescriptor *localDescriptor =
2316 [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo class]
2317 rootClass:[GPBDescriptorRoot class]
2318 file:GPBDescriptorRoot_FileDescriptor()
2319 fields:fields
2320 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2321 oneofs:NULL
2322 oneofCount:0
2323 enums:NULL
2324 enumCount:0
2325 ranges:NULL
2326 rangeCount:0
2327 storageSize:sizeof(GPBSourceCodeInfo__storage_)
2328 wireFormat:NO];
2329 NSAssert(descriptor == nil, @"Startup recursed!");
2330 descriptor = localDescriptor;
2331 }
2332 return descriptor;
2333}
2334
2335@end
2336
2337#pragma mark - GPBSourceCodeInfo_Location
2338
2339@implementation GPBSourceCodeInfo_Location
2340
2341@dynamic pathArray, pathArray_Count;
2342@dynamic spanArray, spanArray_Count;
2343@dynamic hasLeadingComments, leadingComments;
2344@dynamic hasTrailingComments, trailingComments;
2345@dynamic leadingDetachedCommentsArray, leadingDetachedCommentsArray_Count;
2346
2347typedef struct GPBSourceCodeInfo_Location__storage_ {
2348 uint32_t _has_storage_[1];
2349 GPBInt32Array *pathArray;
2350 GPBInt32Array *spanArray;
2351 NSString *leadingComments;
2352 NSString *trailingComments;
2353 NSMutableArray *leadingDetachedCommentsArray;
2354} GPBSourceCodeInfo_Location__storage_;
2355
2356// This method is threadsafe because it is initially called
2357// in +initialize for each subclass.
2358+ (GPBDescriptor *)descriptor {
2359 static GPBDescriptor *descriptor = nil;
2360 if (!descriptor) {
2361 static GPBMessageFieldDescription fields[] = {
2362 {
2363 .name = "pathArray",
2364 .number = GPBSourceCodeInfo_Location_FieldNumber_PathArray,
2365 .hasIndex = GPBNoHasBit,
2366 .flags = GPBFieldRepeated | GPBFieldPacked,
2367 .dataType = GPBDataTypeInt32,
2368 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, pathArray),
2369 .defaultValue.valueMessage = nil,
2370 .dataTypeSpecific.className = NULL,
2371 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2372 .fieldOptions = "\000\000\000\002\020\001",
2373 #else
2374 .fieldOptions = NULL,
2375 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2376 },
2377 {
2378 .name = "spanArray",
2379 .number = GPBSourceCodeInfo_Location_FieldNumber_SpanArray,
2380 .hasIndex = GPBNoHasBit,
2381 .flags = GPBFieldRepeated | GPBFieldPacked,
2382 .dataType = GPBDataTypeInt32,
2383 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, spanArray),
2384 .defaultValue.valueMessage = nil,
2385 .dataTypeSpecific.className = NULL,
2386 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2387 .fieldOptions = "\000\000\000\002\020\001",
2388 #else
2389 .fieldOptions = NULL,
2390 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2391 },
2392 {
2393 .name = "leadingComments",
2394 .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingComments,
2395 .hasIndex = 2,
2396 .flags = GPBFieldOptional,
2397 .dataType = GPBDataTypeString,
2398 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingComments),
2399 .defaultValue.valueString = nil,
2400 .dataTypeSpecific.className = NULL,
2401 .fieldOptions = NULL,
2402 },
2403 {
2404 .name = "trailingComments",
2405 .number = GPBSourceCodeInfo_Location_FieldNumber_TrailingComments,
2406 .hasIndex = 3,
2407 .flags = GPBFieldOptional,
2408 .dataType = GPBDataTypeString,
2409 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, trailingComments),
2410 .defaultValue.valueString = nil,
2411 .dataTypeSpecific.className = NULL,
2412 .fieldOptions = NULL,
2413 },
2414 {
2415 .name = "leadingDetachedCommentsArray",
2416 .number = GPBSourceCodeInfo_Location_FieldNumber_LeadingDetachedCommentsArray,
2417 .hasIndex = GPBNoHasBit,
2418 .flags = GPBFieldRepeated,
2419 .dataType = GPBDataTypeString,
2420 .offset = offsetof(GPBSourceCodeInfo_Location__storage_, leadingDetachedCommentsArray),
2421 .defaultValue.valueMessage = nil,
2422 .dataTypeSpecific.className = NULL,
2423 .fieldOptions = NULL,
2424 },
2425 };
2426 GPBDescriptor *localDescriptor =
2427 [GPBDescriptor allocDescriptorForClass:[GPBSourceCodeInfo_Location class]
2428 rootClass:[GPBDescriptorRoot class]
2429 file:GPBDescriptorRoot_FileDescriptor()
2430 fields:fields
2431 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2432 oneofs:NULL
2433 oneofCount:0
2434 enums:NULL
2435 enumCount:0
2436 ranges:NULL
2437 rangeCount:0
2438 storageSize:sizeof(GPBSourceCodeInfo_Location__storage_)
2439 wireFormat:NO];
2440 NSAssert(descriptor == nil, @"Startup recursed!");
2441 descriptor = localDescriptor;
2442 }
2443 return descriptor;
2444}
2445
2446@end
2447
2448#pragma mark - GPBGeneratedCodeInfo
2449
2450@implementation GPBGeneratedCodeInfo
2451
2452@dynamic annotationArray, annotationArray_Count;
2453
2454typedef struct GPBGeneratedCodeInfo__storage_ {
2455 uint32_t _has_storage_[1];
2456 NSMutableArray *annotationArray;
2457} GPBGeneratedCodeInfo__storage_;
2458
2459// This method is threadsafe because it is initially called
2460// in +initialize for each subclass.
2461+ (GPBDescriptor *)descriptor {
2462 static GPBDescriptor *descriptor = nil;
2463 if (!descriptor) {
2464 static GPBMessageFieldDescription fields[] = {
2465 {
2466 .name = "annotationArray",
2467 .number = GPBGeneratedCodeInfo_FieldNumber_AnnotationArray,
2468 .hasIndex = GPBNoHasBit,
2469 .flags = GPBFieldRepeated,
2470 .dataType = GPBDataTypeMessage,
2471 .offset = offsetof(GPBGeneratedCodeInfo__storage_, annotationArray),
2472 .defaultValue.valueMessage = nil,
2473 .dataTypeSpecific.className = GPBStringifySymbol(GPBGeneratedCodeInfo_Annotation),
2474 .fieldOptions = NULL,
2475 },
2476 };
2477 GPBDescriptor *localDescriptor =
2478 [GPBDescriptor allocDescriptorForClass:[GPBGeneratedCodeInfo class]
2479 rootClass:[GPBDescriptorRoot class]
2480 file:GPBDescriptorRoot_FileDescriptor()
2481 fields:fields
2482 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2483 oneofs:NULL
2484 oneofCount:0
2485 enums:NULL
2486 enumCount:0
2487 ranges:NULL
2488 rangeCount:0
2489 storageSize:sizeof(GPBGeneratedCodeInfo__storage_)
2490 wireFormat:NO];
2491 NSAssert(descriptor == nil, @"Startup recursed!");
2492 descriptor = localDescriptor;
2493 }
2494 return descriptor;
2495}
2496
2497@end
2498
2499#pragma mark - GPBGeneratedCodeInfo_Annotation
2500
2501@implementation GPBGeneratedCodeInfo_Annotation
2502
2503@dynamic pathArray, pathArray_Count;
2504@dynamic hasSourceFile, sourceFile;
2505@dynamic hasBegin, begin;
2506@dynamic hasEnd, end;
2507
2508typedef struct GPBGeneratedCodeInfo_Annotation__storage_ {
2509 uint32_t _has_storage_[1];
2510 int32_t begin;
2511 int32_t end;
2512 GPBInt32Array *pathArray;
2513 NSString *sourceFile;
2514} GPBGeneratedCodeInfo_Annotation__storage_;
2515
2516// This method is threadsafe because it is initially called
2517// in +initialize for each subclass.
2518+ (GPBDescriptor *)descriptor {
2519 static GPBDescriptor *descriptor = nil;
2520 if (!descriptor) {
2521 static GPBMessageFieldDescription fields[] = {
2522 {
2523 .name = "pathArray",
2524 .number = GPBGeneratedCodeInfo_Annotation_FieldNumber_PathArray,
2525 .hasIndex = GPBNoHasBit,
2526 .flags = GPBFieldRepeated | GPBFieldPacked,
2527 .dataType = GPBDataTypeInt32,
2528 .offset = offsetof(GPBGeneratedCodeInfo_Annotation__storage_, pathArray),
2529 .defaultValue.valueMessage = nil,
2530 .dataTypeSpecific.className = NULL,
2531 #if GPBOBJC_INCLUDE_FIELD_OPTIONS
2532 .fieldOptions = "\000\000\000\002\020\001",
2533 #else
2534 .fieldOptions = NULL,
2535 #endif // GPBOBJC_INCLUDE_FIELD_OPTIONS
2536 },
2537 {
2538 .name = "sourceFile",
2539 .number = GPBGeneratedCodeInfo_Annotation_FieldNumber_SourceFile,
2540 .hasIndex = 1,
2541 .flags = GPBFieldOptional,
2542 .dataType = GPBDataTypeString,
2543 .offset = offsetof(GPBGeneratedCodeInfo_Annotation__storage_, sourceFile),
2544 .defaultValue.valueString = nil,
2545 .dataTypeSpecific.className = NULL,
2546 .fieldOptions = NULL,
2547 },
2548 {
2549 .name = "begin",
2550 .number = GPBGeneratedCodeInfo_Annotation_FieldNumber_Begin,
2551 .hasIndex = 2,
2552 .flags = GPBFieldOptional,
2553 .dataType = GPBDataTypeInt32,
2554 .offset = offsetof(GPBGeneratedCodeInfo_Annotation__storage_, begin),
2555 .defaultValue.valueInt32 = 0,
2556 .dataTypeSpecific.className = NULL,
2557 .fieldOptions = NULL,
2558 },
2559 {
2560 .name = "end",
2561 .number = GPBGeneratedCodeInfo_Annotation_FieldNumber_End,
2562 .hasIndex = 3,
2563 .flags = GPBFieldOptional,
2564 .dataType = GPBDataTypeInt32,
2565 .offset = offsetof(GPBGeneratedCodeInfo_Annotation__storage_, end),
2566 .defaultValue.valueInt32 = 0,
2567 .dataTypeSpecific.className = NULL,
2568 .fieldOptions = NULL,
2569 },
2570 };
2571 GPBDescriptor *localDescriptor =
2572 [GPBDescriptor allocDescriptorForClass:[GPBGeneratedCodeInfo_Annotation class]
2573 rootClass:[GPBDescriptorRoot class]
2574 file:GPBDescriptorRoot_FileDescriptor()
2575 fields:fields
2576 fieldCount:sizeof(fields) / sizeof(GPBMessageFieldDescription)
2577 oneofs:NULL
2578 oneofCount:0
2579 enums:NULL
2580 enumCount:0
2581 ranges:NULL
2582 rangeCount:0
2583 storageSize:sizeof(GPBGeneratedCodeInfo_Annotation__storage_)
2584 wireFormat:NO];
2585 NSAssert(descriptor == nil, @"Startup recursed!");
2586 descriptor = localDescriptor;
2587 }
2588 return descriptor;
2589}
2590
2591@end
2592
2593
2594// @@protoc_insertion_point(global_scope)