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