• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Generated by the protocol buffer compiler.  DO NOT EDIT!
2// NO CHECKED-IN PROTOBUF GENCODE
3// clang-format off
4// source: google/protobuf/type.proto
5
6#import "GPBProtocolBuffers_RuntimeSupport.h"
7#import "GPBType.pbobjc.h"
8
9#if GOOGLE_PROTOBUF_OBJC_VERSION < 30007
10#error This file was generated by a newer version of protoc which is incompatible with your Protocol Buffer library sources.
11#endif
12#if 30007 < GOOGLE_PROTOBUF_OBJC_MIN_SUPPORTED_VERSION
13#error This file was generated by an older version of protoc which is incompatible with your Protocol Buffer library sources.
14#endif
15
16#import <stdatomic.h>
17
18// @@protoc_insertion_point(imports)
19
20#pragma clang diagnostic push
21#pragma clang diagnostic ignored "-Wdeprecated-declarations"
22#pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"
23
24#pragma mark - Objective-C Class declarations
25// Forward declarations of Objective-C classes that we can use as
26// static values in struct initializers.
27// We don't use [Foo class] because it is not a static value.
28GPBObjCClassDeclaration(GPBAny);
29GPBObjCClassDeclaration(GPBEnum);
30GPBObjCClassDeclaration(GPBEnumValue);
31GPBObjCClassDeclaration(GPBField);
32GPBObjCClassDeclaration(GPBOption);
33GPBObjCClassDeclaration(GPBSourceContext);
34GPBObjCClassDeclaration(GPBType);
35
36#pragma mark - GPBTypeRoot
37
38@implementation GPBTypeRoot
39
40// No extensions in the file and no imports or none of the imports (direct or
41// indirect) defined extensions, so no need to generate +extensionRegistry.
42
43@end
44
45static GPBFileDescription GPBTypeRoot_FileDescription = {
46  .package = "google.protobuf",
47  .prefix = "GPB",
48  .syntax = GPBFileSyntaxProto3
49};
50
51#pragma mark - Enum GPBSyntax
52
53GPBEnumDescriptor *GPBSyntax_EnumDescriptor(void) {
54  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
55  if (!descriptor) {
56    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
57    static const char *valueNames =
58        "SyntaxProto2\000SyntaxProto3\000SyntaxEditions"
59        "\000";
60    static const int32_t values[] = {
61        GPBSyntax_SyntaxProto2,
62        GPBSyntax_SyntaxProto3,
63        GPBSyntax_SyntaxEditions,
64    };
65    GPBEnumDescriptor *worker =
66        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBSyntax)
67                                       valueNames:valueNames
68                                           values:values
69                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
70                                     enumVerifier:GPBSyntax_IsValidValue
71                                            flags:GPBEnumDescriptorInitializationFlag_None];
72    GPBEnumDescriptor *expected = nil;
73    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
74      [worker release];
75    }
76  }
77  return descriptor;
78}
79
80BOOL GPBSyntax_IsValidValue(int32_t value__) {
81  switch (value__) {
82    case GPBSyntax_SyntaxProto2:
83    case GPBSyntax_SyntaxProto3:
84    case GPBSyntax_SyntaxEditions:
85      return YES;
86    default:
87      return NO;
88  }
89}
90
91#pragma mark - Enum GPBField_Kind
92
93GPBEnumDescriptor *GPBField_Kind_EnumDescriptor(void) {
94  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
95  if (!descriptor) {
96    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
97    static const char *valueNames =
98        "TypeUnknown\000TypeDouble\000TypeFloat\000TypeInt"
99        "64\000TypeUint64\000TypeInt32\000TypeFixed64\000Type"
100        "Fixed32\000TypeBool\000TypeString\000TypeGroup\000Ty"
101        "peMessage\000TypeBytes\000TypeUint32\000TypeEnum\000"
102        "TypeSfixed32\000TypeSfixed64\000TypeSint32\000Typ"
103        "eSint64\000";
104    static const int32_t values[] = {
105        GPBField_Kind_TypeUnknown,
106        GPBField_Kind_TypeDouble,
107        GPBField_Kind_TypeFloat,
108        GPBField_Kind_TypeInt64,
109        GPBField_Kind_TypeUint64,
110        GPBField_Kind_TypeInt32,
111        GPBField_Kind_TypeFixed64,
112        GPBField_Kind_TypeFixed32,
113        GPBField_Kind_TypeBool,
114        GPBField_Kind_TypeString,
115        GPBField_Kind_TypeGroup,
116        GPBField_Kind_TypeMessage,
117        GPBField_Kind_TypeBytes,
118        GPBField_Kind_TypeUint32,
119        GPBField_Kind_TypeEnum,
120        GPBField_Kind_TypeSfixed32,
121        GPBField_Kind_TypeSfixed64,
122        GPBField_Kind_TypeSint32,
123        GPBField_Kind_TypeSint64,
124    };
125    GPBEnumDescriptor *worker =
126        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBField_Kind)
127                                       valueNames:valueNames
128                                           values:values
129                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
130                                     enumVerifier:GPBField_Kind_IsValidValue
131                                            flags:GPBEnumDescriptorInitializationFlag_None];
132    GPBEnumDescriptor *expected = nil;
133    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
134      [worker release];
135    }
136  }
137  return descriptor;
138}
139
140BOOL GPBField_Kind_IsValidValue(int32_t value__) {
141  switch (value__) {
142    case GPBField_Kind_TypeUnknown:
143    case GPBField_Kind_TypeDouble:
144    case GPBField_Kind_TypeFloat:
145    case GPBField_Kind_TypeInt64:
146    case GPBField_Kind_TypeUint64:
147    case GPBField_Kind_TypeInt32:
148    case GPBField_Kind_TypeFixed64:
149    case GPBField_Kind_TypeFixed32:
150    case GPBField_Kind_TypeBool:
151    case GPBField_Kind_TypeString:
152    case GPBField_Kind_TypeGroup:
153    case GPBField_Kind_TypeMessage:
154    case GPBField_Kind_TypeBytes:
155    case GPBField_Kind_TypeUint32:
156    case GPBField_Kind_TypeEnum:
157    case GPBField_Kind_TypeSfixed32:
158    case GPBField_Kind_TypeSfixed64:
159    case GPBField_Kind_TypeSint32:
160    case GPBField_Kind_TypeSint64:
161      return YES;
162    default:
163      return NO;
164  }
165}
166
167#pragma mark - Enum GPBField_Cardinality
168
169GPBEnumDescriptor *GPBField_Cardinality_EnumDescriptor(void) {
170  static _Atomic(GPBEnumDescriptor*) descriptor = nil;
171  if (!descriptor) {
172    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
173    static const char *valueNames =
174        "CardinalityUnknown\000CardinalityOptional\000C"
175        "ardinalityRequired\000CardinalityRepeated\000";
176    static const int32_t values[] = {
177        GPBField_Cardinality_CardinalityUnknown,
178        GPBField_Cardinality_CardinalityOptional,
179        GPBField_Cardinality_CardinalityRequired,
180        GPBField_Cardinality_CardinalityRepeated,
181    };
182    GPBEnumDescriptor *worker =
183        [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBField_Cardinality)
184                                       valueNames:valueNames
185                                           values:values
186                                            count:(uint32_t)(sizeof(values) / sizeof(int32_t))
187                                     enumVerifier:GPBField_Cardinality_IsValidValue
188                                            flags:GPBEnumDescriptorInitializationFlag_None];
189    GPBEnumDescriptor *expected = nil;
190    if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
191      [worker release];
192    }
193  }
194  return descriptor;
195}
196
197BOOL GPBField_Cardinality_IsValidValue(int32_t value__) {
198  switch (value__) {
199    case GPBField_Cardinality_CardinalityUnknown:
200    case GPBField_Cardinality_CardinalityOptional:
201    case GPBField_Cardinality_CardinalityRequired:
202    case GPBField_Cardinality_CardinalityRepeated:
203      return YES;
204    default:
205      return NO;
206  }
207}
208
209#pragma mark - GPBType
210
211@implementation GPBType
212
213@dynamic name;
214@dynamic fieldsArray, fieldsArray_Count;
215@dynamic oneofsArray, oneofsArray_Count;
216@dynamic optionsArray, optionsArray_Count;
217@dynamic hasSourceContext, sourceContext;
218@dynamic syntax;
219@dynamic edition;
220
221typedef struct GPBType__storage_ {
222  uint32_t _has_storage_[1];
223  GPBSyntax syntax;
224  NSString *name;
225  NSMutableArray *fieldsArray;
226  NSMutableArray *oneofsArray;
227  NSMutableArray *optionsArray;
228  GPBSourceContext *sourceContext;
229  NSString *edition;
230} GPBType__storage_;
231
232// This method is threadsafe because it is initially called
233// in +initialize for each subclass.
234+ (GPBDescriptor *)descriptor {
235  static GPBDescriptor *descriptor = nil;
236  if (!descriptor) {
237    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
238    static GPBMessageFieldDescription fields[] = {
239      {
240        .name = "name",
241        .dataTypeSpecific.clazz = Nil,
242        .number = GPBType_FieldNumber_Name,
243        .hasIndex = 0,
244        .offset = (uint32_t)offsetof(GPBType__storage_, name),
245        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
246        .dataType = GPBDataTypeString,
247      },
248      {
249        .name = "fieldsArray",
250        .dataTypeSpecific.clazz = GPBObjCClass(GPBField),
251        .number = GPBType_FieldNumber_FieldsArray,
252        .hasIndex = GPBNoHasBit,
253        .offset = (uint32_t)offsetof(GPBType__storage_, fieldsArray),
254        .flags = GPBFieldRepeated,
255        .dataType = GPBDataTypeMessage,
256      },
257      {
258        .name = "oneofsArray",
259        .dataTypeSpecific.clazz = Nil,
260        .number = GPBType_FieldNumber_OneofsArray,
261        .hasIndex = GPBNoHasBit,
262        .offset = (uint32_t)offsetof(GPBType__storage_, oneofsArray),
263        .flags = GPBFieldRepeated,
264        .dataType = GPBDataTypeString,
265      },
266      {
267        .name = "optionsArray",
268        .dataTypeSpecific.clazz = GPBObjCClass(GPBOption),
269        .number = GPBType_FieldNumber_OptionsArray,
270        .hasIndex = GPBNoHasBit,
271        .offset = (uint32_t)offsetof(GPBType__storage_, optionsArray),
272        .flags = GPBFieldRepeated,
273        .dataType = GPBDataTypeMessage,
274      },
275      {
276        .name = "sourceContext",
277        .dataTypeSpecific.clazz = GPBObjCClass(GPBSourceContext),
278        .number = GPBType_FieldNumber_SourceContext,
279        .hasIndex = 1,
280        .offset = (uint32_t)offsetof(GPBType__storage_, sourceContext),
281        .flags = GPBFieldOptional,
282        .dataType = GPBDataTypeMessage,
283      },
284      {
285        .name = "syntax",
286        .dataTypeSpecific.enumDescFunc = GPBSyntax_EnumDescriptor,
287        .number = GPBType_FieldNumber_Syntax,
288        .hasIndex = 2,
289        .offset = (uint32_t)offsetof(GPBType__storage_, syntax),
290        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
291        .dataType = GPBDataTypeEnum,
292      },
293      {
294        .name = "edition",
295        .dataTypeSpecific.clazz = Nil,
296        .number = GPBType_FieldNumber_Edition,
297        .hasIndex = 3,
298        .offset = (uint32_t)offsetof(GPBType__storage_, edition),
299        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
300        .dataType = GPBDataTypeString,
301      },
302    };
303    GPBDescriptor *localDescriptor =
304        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBType)
305                                   messageName:@"Type"
306                               fileDescription:&GPBTypeRoot_FileDescription
307                                        fields:fields
308                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
309                                   storageSize:sizeof(GPBType__storage_)
310                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
311    #if defined(DEBUG) && DEBUG
312      NSAssert(descriptor == nil, @"Startup recursed!");
313    #endif  // DEBUG
314    descriptor = localDescriptor;
315  }
316  return descriptor;
317}
318
319@end
320
321int32_t GPBType_Syntax_RawValue(GPBType *message) {
322  GPBDescriptor *descriptor = [GPBType descriptor];
323  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBType_FieldNumber_Syntax];
324  return GPBGetMessageRawEnumField(message, field);
325}
326
327void SetGPBType_Syntax_RawValue(GPBType *message, int32_t value) {
328  GPBDescriptor *descriptor = [GPBType descriptor];
329  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBType_FieldNumber_Syntax];
330  GPBSetMessageRawEnumField(message, field, value);
331}
332
333#pragma mark - GPBField
334
335@implementation GPBField
336
337@dynamic kind;
338@dynamic cardinality;
339@dynamic number;
340@dynamic name;
341@dynamic typeURL;
342@dynamic oneofIndex;
343@dynamic packed;
344@dynamic optionsArray, optionsArray_Count;
345@dynamic jsonName;
346@dynamic defaultValue;
347
348typedef struct GPBField__storage_ {
349  uint32_t _has_storage_[1];
350  GPBField_Kind kind;
351  GPBField_Cardinality cardinality;
352  int32_t number;
353  int32_t oneofIndex;
354  NSString *name;
355  NSString *typeURL;
356  NSMutableArray *optionsArray;
357  NSString *jsonName;
358  NSString *defaultValue;
359} GPBField__storage_;
360
361// This method is threadsafe because it is initially called
362// in +initialize for each subclass.
363+ (GPBDescriptor *)descriptor {
364  static GPBDescriptor *descriptor = nil;
365  if (!descriptor) {
366    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
367    static GPBMessageFieldDescription fields[] = {
368      {
369        .name = "kind",
370        .dataTypeSpecific.enumDescFunc = GPBField_Kind_EnumDescriptor,
371        .number = GPBField_FieldNumber_Kind,
372        .hasIndex = 0,
373        .offset = (uint32_t)offsetof(GPBField__storage_, kind),
374        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
375        .dataType = GPBDataTypeEnum,
376      },
377      {
378        .name = "cardinality",
379        .dataTypeSpecific.enumDescFunc = GPBField_Cardinality_EnumDescriptor,
380        .number = GPBField_FieldNumber_Cardinality,
381        .hasIndex = 1,
382        .offset = (uint32_t)offsetof(GPBField__storage_, cardinality),
383        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
384        .dataType = GPBDataTypeEnum,
385      },
386      {
387        .name = "number",
388        .dataTypeSpecific.clazz = Nil,
389        .number = GPBField_FieldNumber_Number,
390        .hasIndex = 2,
391        .offset = (uint32_t)offsetof(GPBField__storage_, number),
392        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
393        .dataType = GPBDataTypeInt32,
394      },
395      {
396        .name = "name",
397        .dataTypeSpecific.clazz = Nil,
398        .number = GPBField_FieldNumber_Name,
399        .hasIndex = 3,
400        .offset = (uint32_t)offsetof(GPBField__storage_, name),
401        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
402        .dataType = GPBDataTypeString,
403      },
404      {
405        .name = "typeURL",
406        .dataTypeSpecific.clazz = Nil,
407        .number = GPBField_FieldNumber_TypeURL,
408        .hasIndex = 4,
409        .offset = (uint32_t)offsetof(GPBField__storage_, typeURL),
410        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom | GPBFieldClearHasIvarOnZero),
411        .dataType = GPBDataTypeString,
412      },
413      {
414        .name = "oneofIndex",
415        .dataTypeSpecific.clazz = Nil,
416        .number = GPBField_FieldNumber_OneofIndex,
417        .hasIndex = 5,
418        .offset = (uint32_t)offsetof(GPBField__storage_, oneofIndex),
419        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
420        .dataType = GPBDataTypeInt32,
421      },
422      {
423        .name = "packed",
424        .dataTypeSpecific.clazz = Nil,
425        .number = GPBField_FieldNumber_Packed,
426        .hasIndex = 6,
427        .offset = 7,  // Stored in _has_storage_ to save space.
428        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
429        .dataType = GPBDataTypeBool,
430      },
431      {
432        .name = "optionsArray",
433        .dataTypeSpecific.clazz = GPBObjCClass(GPBOption),
434        .number = GPBField_FieldNumber_OptionsArray,
435        .hasIndex = GPBNoHasBit,
436        .offset = (uint32_t)offsetof(GPBField__storage_, optionsArray),
437        .flags = GPBFieldRepeated,
438        .dataType = GPBDataTypeMessage,
439      },
440      {
441        .name = "jsonName",
442        .dataTypeSpecific.clazz = Nil,
443        .number = GPBField_FieldNumber_JsonName,
444        .hasIndex = 8,
445        .offset = (uint32_t)offsetof(GPBField__storage_, jsonName),
446        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
447        .dataType = GPBDataTypeString,
448      },
449      {
450        .name = "defaultValue",
451        .dataTypeSpecific.clazz = Nil,
452        .number = GPBField_FieldNumber_DefaultValue,
453        .hasIndex = 9,
454        .offset = (uint32_t)offsetof(GPBField__storage_, defaultValue),
455        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
456        .dataType = GPBDataTypeString,
457      },
458    };
459    GPBDescriptor *localDescriptor =
460        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBField)
461                                   messageName:@"Field"
462                               fileDescription:&GPBTypeRoot_FileDescription
463                                        fields:fields
464                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
465                                   storageSize:sizeof(GPBField__storage_)
466                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
467    #if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
468      static const char *extraTextFormatInfo =
469        "\001\006\004\241!!\000";
470      [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
471    #endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
472    #if defined(DEBUG) && DEBUG
473      NSAssert(descriptor == nil, @"Startup recursed!");
474    #endif  // DEBUG
475    descriptor = localDescriptor;
476  }
477  return descriptor;
478}
479
480@end
481
482int32_t GPBField_Kind_RawValue(GPBField *message) {
483  GPBDescriptor *descriptor = [GPBField descriptor];
484  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBField_FieldNumber_Kind];
485  return GPBGetMessageRawEnumField(message, field);
486}
487
488void SetGPBField_Kind_RawValue(GPBField *message, int32_t value) {
489  GPBDescriptor *descriptor = [GPBField descriptor];
490  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBField_FieldNumber_Kind];
491  GPBSetMessageRawEnumField(message, field, value);
492}
493
494int32_t GPBField_Cardinality_RawValue(GPBField *message) {
495  GPBDescriptor *descriptor = [GPBField descriptor];
496  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBField_FieldNumber_Cardinality];
497  return GPBGetMessageRawEnumField(message, field);
498}
499
500void SetGPBField_Cardinality_RawValue(GPBField *message, int32_t value) {
501  GPBDescriptor *descriptor = [GPBField descriptor];
502  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBField_FieldNumber_Cardinality];
503  GPBSetMessageRawEnumField(message, field, value);
504}
505
506#pragma mark - GPBEnum
507
508@implementation GPBEnum
509
510@dynamic name;
511@dynamic enumvalueArray, enumvalueArray_Count;
512@dynamic optionsArray, optionsArray_Count;
513@dynamic hasSourceContext, sourceContext;
514@dynamic syntax;
515@dynamic edition;
516
517typedef struct GPBEnum__storage_ {
518  uint32_t _has_storage_[1];
519  GPBSyntax syntax;
520  NSString *name;
521  NSMutableArray *enumvalueArray;
522  NSMutableArray *optionsArray;
523  GPBSourceContext *sourceContext;
524  NSString *edition;
525} GPBEnum__storage_;
526
527// This method is threadsafe because it is initially called
528// in +initialize for each subclass.
529+ (GPBDescriptor *)descriptor {
530  static GPBDescriptor *descriptor = nil;
531  if (!descriptor) {
532    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
533    static GPBMessageFieldDescription fields[] = {
534      {
535        .name = "name",
536        .dataTypeSpecific.clazz = Nil,
537        .number = GPBEnum_FieldNumber_Name,
538        .hasIndex = 0,
539        .offset = (uint32_t)offsetof(GPBEnum__storage_, name),
540        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
541        .dataType = GPBDataTypeString,
542      },
543      {
544        .name = "enumvalueArray",
545        .dataTypeSpecific.clazz = GPBObjCClass(GPBEnumValue),
546        .number = GPBEnum_FieldNumber_EnumvalueArray,
547        .hasIndex = GPBNoHasBit,
548        .offset = (uint32_t)offsetof(GPBEnum__storage_, enumvalueArray),
549        .flags = GPBFieldRepeated,
550        .dataType = GPBDataTypeMessage,
551      },
552      {
553        .name = "optionsArray",
554        .dataTypeSpecific.clazz = GPBObjCClass(GPBOption),
555        .number = GPBEnum_FieldNumber_OptionsArray,
556        .hasIndex = GPBNoHasBit,
557        .offset = (uint32_t)offsetof(GPBEnum__storage_, optionsArray),
558        .flags = GPBFieldRepeated,
559        .dataType = GPBDataTypeMessage,
560      },
561      {
562        .name = "sourceContext",
563        .dataTypeSpecific.clazz = GPBObjCClass(GPBSourceContext),
564        .number = GPBEnum_FieldNumber_SourceContext,
565        .hasIndex = 1,
566        .offset = (uint32_t)offsetof(GPBEnum__storage_, sourceContext),
567        .flags = GPBFieldOptional,
568        .dataType = GPBDataTypeMessage,
569      },
570      {
571        .name = "syntax",
572        .dataTypeSpecific.enumDescFunc = GPBSyntax_EnumDescriptor,
573        .number = GPBEnum_FieldNumber_Syntax,
574        .hasIndex = 2,
575        .offset = (uint32_t)offsetof(GPBEnum__storage_, syntax),
576        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor | GPBFieldClearHasIvarOnZero),
577        .dataType = GPBDataTypeEnum,
578      },
579      {
580        .name = "edition",
581        .dataTypeSpecific.clazz = Nil,
582        .number = GPBEnum_FieldNumber_Edition,
583        .hasIndex = 3,
584        .offset = (uint32_t)offsetof(GPBEnum__storage_, edition),
585        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
586        .dataType = GPBDataTypeString,
587      },
588    };
589    GPBDescriptor *localDescriptor =
590        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBEnum)
591                                   messageName:@"Enum"
592                               fileDescription:&GPBTypeRoot_FileDescription
593                                        fields:fields
594                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
595                                   storageSize:sizeof(GPBEnum__storage_)
596                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
597    #if defined(DEBUG) && DEBUG
598      NSAssert(descriptor == nil, @"Startup recursed!");
599    #endif  // DEBUG
600    descriptor = localDescriptor;
601  }
602  return descriptor;
603}
604
605@end
606
607int32_t GPBEnum_Syntax_RawValue(GPBEnum *message) {
608  GPBDescriptor *descriptor = [GPBEnum descriptor];
609  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBEnum_FieldNumber_Syntax];
610  return GPBGetMessageRawEnumField(message, field);
611}
612
613void SetGPBEnum_Syntax_RawValue(GPBEnum *message, int32_t value) {
614  GPBDescriptor *descriptor = [GPBEnum descriptor];
615  GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBEnum_FieldNumber_Syntax];
616  GPBSetMessageRawEnumField(message, field, value);
617}
618
619#pragma mark - GPBEnumValue
620
621@implementation GPBEnumValue
622
623@dynamic name;
624@dynamic number;
625@dynamic optionsArray, optionsArray_Count;
626
627typedef struct GPBEnumValue__storage_ {
628  uint32_t _has_storage_[1];
629  int32_t number;
630  NSString *name;
631  NSMutableArray *optionsArray;
632} GPBEnumValue__storage_;
633
634// This method is threadsafe because it is initially called
635// in +initialize for each subclass.
636+ (GPBDescriptor *)descriptor {
637  static GPBDescriptor *descriptor = nil;
638  if (!descriptor) {
639    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
640    static GPBMessageFieldDescription fields[] = {
641      {
642        .name = "name",
643        .dataTypeSpecific.clazz = Nil,
644        .number = GPBEnumValue_FieldNumber_Name,
645        .hasIndex = 0,
646        .offset = (uint32_t)offsetof(GPBEnumValue__storage_, name),
647        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
648        .dataType = GPBDataTypeString,
649      },
650      {
651        .name = "number",
652        .dataTypeSpecific.clazz = Nil,
653        .number = GPBEnumValue_FieldNumber_Number,
654        .hasIndex = 1,
655        .offset = (uint32_t)offsetof(GPBEnumValue__storage_, number),
656        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
657        .dataType = GPBDataTypeInt32,
658      },
659      {
660        .name = "optionsArray",
661        .dataTypeSpecific.clazz = GPBObjCClass(GPBOption),
662        .number = GPBEnumValue_FieldNumber_OptionsArray,
663        .hasIndex = GPBNoHasBit,
664        .offset = (uint32_t)offsetof(GPBEnumValue__storage_, optionsArray),
665        .flags = GPBFieldRepeated,
666        .dataType = GPBDataTypeMessage,
667      },
668    };
669    GPBDescriptor *localDescriptor =
670        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBEnumValue)
671                                   messageName:@"EnumValue"
672                               fileDescription:&GPBTypeRoot_FileDescription
673                                        fields:fields
674                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
675                                   storageSize:sizeof(GPBEnumValue__storage_)
676                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
677    #if defined(DEBUG) && DEBUG
678      NSAssert(descriptor == nil, @"Startup recursed!");
679    #endif  // DEBUG
680    descriptor = localDescriptor;
681  }
682  return descriptor;
683}
684
685@end
686
687#pragma mark - GPBOption
688
689@implementation GPBOption
690
691@dynamic name;
692@dynamic hasValue, value;
693
694typedef struct GPBOption__storage_ {
695  uint32_t _has_storage_[1];
696  NSString *name;
697  GPBAny *value;
698} GPBOption__storage_;
699
700// This method is threadsafe because it is initially called
701// in +initialize for each subclass.
702+ (GPBDescriptor *)descriptor {
703  static GPBDescriptor *descriptor = nil;
704  if (!descriptor) {
705    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
706    static GPBMessageFieldDescription fields[] = {
707      {
708        .name = "name",
709        .dataTypeSpecific.clazz = Nil,
710        .number = GPBOption_FieldNumber_Name,
711        .hasIndex = 0,
712        .offset = (uint32_t)offsetof(GPBOption__storage_, name),
713        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
714        .dataType = GPBDataTypeString,
715      },
716      {
717        .name = "value",
718        .dataTypeSpecific.clazz = GPBObjCClass(GPBAny),
719        .number = GPBOption_FieldNumber_Value,
720        .hasIndex = 1,
721        .offset = (uint32_t)offsetof(GPBOption__storage_, value),
722        .flags = GPBFieldOptional,
723        .dataType = GPBDataTypeMessage,
724      },
725    };
726    GPBDescriptor *localDescriptor =
727        [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBOption)
728                                   messageName:@"Option"
729                               fileDescription:&GPBTypeRoot_FileDescription
730                                        fields:fields
731                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
732                                   storageSize:sizeof(GPBOption__storage_)
733                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
734    #if defined(DEBUG) && DEBUG
735      NSAssert(descriptor == nil, @"Startup recursed!");
736    #endif  // DEBUG
737    descriptor = localDescriptor;
738  }
739  return descriptor;
740}
741
742@end
743
744
745#pragma clang diagnostic pop
746
747// @@protoc_insertion_point(global_scope)
748
749// clang-format on
750