iOS/Pods/Protobuf/objectivec/google/protobuf/Type.pbobjc.m

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