objectivec/GPBType.pbobjc.m

   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.
  28 GPBObjCClassDeclaration(GPBAny);
  29 GPBObjCClassDeclaration(GPBEnum);
  30 GPBObjCClassDeclaration(GPBEnumValue);
  31 GPBObjCClassDeclaration(GPBField);
  32 GPBObjCClassDeclaration(GPBOption);
  33 GPBObjCClassDeclaration(GPBSourceContext);
  34 GPBObjCClassDeclaration(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
  45 static GPBFileDescription GPBTypeRoot_FileDescription = {
  46   .package = "google.protobuf",
  47   .prefix = "GPB",
  48   .syntax = GPBFileSyntaxProto3
  49 };
  50
  51 #pragma mark - Enum GPBSyntax
  52
  53 GPBEnumDescriptor *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
  80 BOOL 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
  93 GPBEnumDescriptor *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
 140 BOOL 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
 169 GPBEnumDescriptor *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
 197 BOOL 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
 221 typedef 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
 321 int32_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
 327 void 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
 348 typedef 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
 482 int32_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
 488 void 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
 494 int32_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
 500 void 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
 517 typedef 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
 607 int32_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
 613 void 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
 627 typedef 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
 694 typedef 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