1// Generated by the protocol buffer compiler. DO NOT EDIT! 2// source: google/protobuf/wrappers.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#if GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS 17 #import <Protobuf/Wrappers.pbobjc.h> 18#else 19 #import "google/protobuf/Wrappers.pbobjc.h" 20#endif 21// @@protoc_insertion_point(imports) 22 23#pragma clang diagnostic push 24#pragma clang diagnostic ignored "-Wdeprecated-declarations" 25 26#pragma mark - GPBWrappersRoot 27 28@implementation GPBWrappersRoot 29 30// No extensions in the file and no imports, so no need to generate 31// +extensionRegistry. 32 33@end 34 35#pragma mark - GPBWrappersRoot_FileDescriptor 36 37static GPBFileDescriptor *GPBWrappersRoot_FileDescriptor(void) { 38 // This is called by +initialize so there is no need to worry 39 // about thread safety of the singleton. 40 static GPBFileDescriptor *descriptor = NULL; 41 if (!descriptor) { 42 GPB_DEBUG_CHECK_RUNTIME_VERSIONS(); 43 descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf" 44 objcPrefix:@"GPB" 45 syntax:GPBFileSyntaxProto3]; 46 } 47 return descriptor; 48} 49 50#pragma mark - GPBDoubleValue 51 52@implementation GPBDoubleValue 53 54@dynamic value; 55 56typedef struct GPBDoubleValue__storage_ { 57 uint32_t _has_storage_[1]; 58 double value; 59} GPBDoubleValue__storage_; 60 61// This method is threadsafe because it is initially called 62// in +initialize for each subclass. 63+ (GPBDescriptor *)descriptor { 64 static GPBDescriptor *descriptor = nil; 65 if (!descriptor) { 66 static GPBMessageFieldDescription fields[] = { 67 { 68 .name = "value", 69 .dataTypeSpecific.className = NULL, 70 .number = GPBDoubleValue_FieldNumber_Value, 71 .hasIndex = 0, 72 .offset = (uint32_t)offsetof(GPBDoubleValue__storage_, value), 73 .flags = GPBFieldOptional, 74 .dataType = GPBDataTypeDouble, 75 }, 76 }; 77 GPBDescriptor *localDescriptor = 78 [GPBDescriptor allocDescriptorForClass:[GPBDoubleValue class] 79 rootClass:[GPBWrappersRoot class] 80 file:GPBWrappersRoot_FileDescriptor() 81 fields:fields 82 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 83 storageSize:sizeof(GPBDoubleValue__storage_) 84 flags:GPBDescriptorInitializationFlag_None]; 85 #if defined(DEBUG) && DEBUG 86 NSAssert(descriptor == nil, @"Startup recursed!"); 87 #endif // DEBUG 88 descriptor = localDescriptor; 89 } 90 return descriptor; 91} 92 93@end 94 95#pragma mark - GPBFloatValue 96 97@implementation GPBFloatValue 98 99@dynamic value; 100 101typedef struct GPBFloatValue__storage_ { 102 uint32_t _has_storage_[1]; 103 float value; 104} GPBFloatValue__storage_; 105 106// This method is threadsafe because it is initially called 107// in +initialize for each subclass. 108+ (GPBDescriptor *)descriptor { 109 static GPBDescriptor *descriptor = nil; 110 if (!descriptor) { 111 static GPBMessageFieldDescription fields[] = { 112 { 113 .name = "value", 114 .dataTypeSpecific.className = NULL, 115 .number = GPBFloatValue_FieldNumber_Value, 116 .hasIndex = 0, 117 .offset = (uint32_t)offsetof(GPBFloatValue__storage_, value), 118 .flags = GPBFieldOptional, 119 .dataType = GPBDataTypeFloat, 120 }, 121 }; 122 GPBDescriptor *localDescriptor = 123 [GPBDescriptor allocDescriptorForClass:[GPBFloatValue class] 124 rootClass:[GPBWrappersRoot class] 125 file:GPBWrappersRoot_FileDescriptor() 126 fields:fields 127 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 128 storageSize:sizeof(GPBFloatValue__storage_) 129 flags:GPBDescriptorInitializationFlag_None]; 130 #if defined(DEBUG) && DEBUG 131 NSAssert(descriptor == nil, @"Startup recursed!"); 132 #endif // DEBUG 133 descriptor = localDescriptor; 134 } 135 return descriptor; 136} 137 138@end 139 140#pragma mark - GPBInt64Value 141 142@implementation GPBInt64Value 143 144@dynamic value; 145 146typedef struct GPBInt64Value__storage_ { 147 uint32_t _has_storage_[1]; 148 int64_t value; 149} GPBInt64Value__storage_; 150 151// This method is threadsafe because it is initially called 152// in +initialize for each subclass. 153+ (GPBDescriptor *)descriptor { 154 static GPBDescriptor *descriptor = nil; 155 if (!descriptor) { 156 static GPBMessageFieldDescription fields[] = { 157 { 158 .name = "value", 159 .dataTypeSpecific.className = NULL, 160 .number = GPBInt64Value_FieldNumber_Value, 161 .hasIndex = 0, 162 .offset = (uint32_t)offsetof(GPBInt64Value__storage_, value), 163 .flags = GPBFieldOptional, 164 .dataType = GPBDataTypeInt64, 165 }, 166 }; 167 GPBDescriptor *localDescriptor = 168 [GPBDescriptor allocDescriptorForClass:[GPBInt64Value class] 169 rootClass:[GPBWrappersRoot class] 170 file:GPBWrappersRoot_FileDescriptor() 171 fields:fields 172 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 173 storageSize:sizeof(GPBInt64Value__storage_) 174 flags:GPBDescriptorInitializationFlag_None]; 175 #if defined(DEBUG) && DEBUG 176 NSAssert(descriptor == nil, @"Startup recursed!"); 177 #endif // DEBUG 178 descriptor = localDescriptor; 179 } 180 return descriptor; 181} 182 183@end 184 185#pragma mark - GPBUInt64Value 186 187@implementation GPBUInt64Value 188 189@dynamic value; 190 191typedef struct GPBUInt64Value__storage_ { 192 uint32_t _has_storage_[1]; 193 uint64_t value; 194} GPBUInt64Value__storage_; 195 196// This method is threadsafe because it is initially called 197// in +initialize for each subclass. 198+ (GPBDescriptor *)descriptor { 199 static GPBDescriptor *descriptor = nil; 200 if (!descriptor) { 201 static GPBMessageFieldDescription fields[] = { 202 { 203 .name = "value", 204 .dataTypeSpecific.className = NULL, 205 .number = GPBUInt64Value_FieldNumber_Value, 206 .hasIndex = 0, 207 .offset = (uint32_t)offsetof(GPBUInt64Value__storage_, value), 208 .flags = GPBFieldOptional, 209 .dataType = GPBDataTypeUInt64, 210 }, 211 }; 212 GPBDescriptor *localDescriptor = 213 [GPBDescriptor allocDescriptorForClass:[GPBUInt64Value class] 214 rootClass:[GPBWrappersRoot class] 215 file:GPBWrappersRoot_FileDescriptor() 216 fields:fields 217 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 218 storageSize:sizeof(GPBUInt64Value__storage_) 219 flags:GPBDescriptorInitializationFlag_None]; 220 #if defined(DEBUG) && DEBUG 221 NSAssert(descriptor == nil, @"Startup recursed!"); 222 #endif // DEBUG 223 descriptor = localDescriptor; 224 } 225 return descriptor; 226} 227 228@end 229 230#pragma mark - GPBInt32Value 231 232@implementation GPBInt32Value 233 234@dynamic value; 235 236typedef struct GPBInt32Value__storage_ { 237 uint32_t _has_storage_[1]; 238 int32_t value; 239} GPBInt32Value__storage_; 240 241// This method is threadsafe because it is initially called 242// in +initialize for each subclass. 243+ (GPBDescriptor *)descriptor { 244 static GPBDescriptor *descriptor = nil; 245 if (!descriptor) { 246 static GPBMessageFieldDescription fields[] = { 247 { 248 .name = "value", 249 .dataTypeSpecific.className = NULL, 250 .number = GPBInt32Value_FieldNumber_Value, 251 .hasIndex = 0, 252 .offset = (uint32_t)offsetof(GPBInt32Value__storage_, value), 253 .flags = GPBFieldOptional, 254 .dataType = GPBDataTypeInt32, 255 }, 256 }; 257 GPBDescriptor *localDescriptor = 258 [GPBDescriptor allocDescriptorForClass:[GPBInt32Value class] 259 rootClass:[GPBWrappersRoot class] 260 file:GPBWrappersRoot_FileDescriptor() 261 fields:fields 262 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 263 storageSize:sizeof(GPBInt32Value__storage_) 264 flags:GPBDescriptorInitializationFlag_None]; 265 #if defined(DEBUG) && DEBUG 266 NSAssert(descriptor == nil, @"Startup recursed!"); 267 #endif // DEBUG 268 descriptor = localDescriptor; 269 } 270 return descriptor; 271} 272 273@end 274 275#pragma mark - GPBUInt32Value 276 277@implementation GPBUInt32Value 278 279@dynamic value; 280 281typedef struct GPBUInt32Value__storage_ { 282 uint32_t _has_storage_[1]; 283 uint32_t value; 284} GPBUInt32Value__storage_; 285 286// This method is threadsafe because it is initially called 287// in +initialize for each subclass. 288+ (GPBDescriptor *)descriptor { 289 static GPBDescriptor *descriptor = nil; 290 if (!descriptor) { 291 static GPBMessageFieldDescription fields[] = { 292 { 293 .name = "value", 294 .dataTypeSpecific.className = NULL, 295 .number = GPBUInt32Value_FieldNumber_Value, 296 .hasIndex = 0, 297 .offset = (uint32_t)offsetof(GPBUInt32Value__storage_, value), 298 .flags = GPBFieldOptional, 299 .dataType = GPBDataTypeUInt32, 300 }, 301 }; 302 GPBDescriptor *localDescriptor = 303 [GPBDescriptor allocDescriptorForClass:[GPBUInt32Value class] 304 rootClass:[GPBWrappersRoot class] 305 file:GPBWrappersRoot_FileDescriptor() 306 fields:fields 307 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 308 storageSize:sizeof(GPBUInt32Value__storage_) 309 flags:GPBDescriptorInitializationFlag_None]; 310 #if defined(DEBUG) && DEBUG 311 NSAssert(descriptor == nil, @"Startup recursed!"); 312 #endif // DEBUG 313 descriptor = localDescriptor; 314 } 315 return descriptor; 316} 317 318@end 319 320#pragma mark - GPBBoolValue 321 322@implementation GPBBoolValue 323 324@dynamic value; 325 326typedef struct GPBBoolValue__storage_ { 327 uint32_t _has_storage_[1]; 328} GPBBoolValue__storage_; 329 330// This method is threadsafe because it is initially called 331// in +initialize for each subclass. 332+ (GPBDescriptor *)descriptor { 333 static GPBDescriptor *descriptor = nil; 334 if (!descriptor) { 335 static GPBMessageFieldDescription fields[] = { 336 { 337 .name = "value", 338 .dataTypeSpecific.className = NULL, 339 .number = GPBBoolValue_FieldNumber_Value, 340 .hasIndex = 0, 341 .offset = 1, // Stored in _has_storage_ to save space. 342 .flags = GPBFieldOptional, 343 .dataType = GPBDataTypeBool, 344 }, 345 }; 346 GPBDescriptor *localDescriptor = 347 [GPBDescriptor allocDescriptorForClass:[GPBBoolValue class] 348 rootClass:[GPBWrappersRoot class] 349 file:GPBWrappersRoot_FileDescriptor() 350 fields:fields 351 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 352 storageSize:sizeof(GPBBoolValue__storage_) 353 flags:GPBDescriptorInitializationFlag_None]; 354 #if defined(DEBUG) && DEBUG 355 NSAssert(descriptor == nil, @"Startup recursed!"); 356 #endif // DEBUG 357 descriptor = localDescriptor; 358 } 359 return descriptor; 360} 361 362@end 363 364#pragma mark - GPBStringValue 365 366@implementation GPBStringValue 367 368@dynamic value; 369 370typedef struct GPBStringValue__storage_ { 371 uint32_t _has_storage_[1]; 372 NSString *value; 373} GPBStringValue__storage_; 374 375// This method is threadsafe because it is initially called 376// in +initialize for each subclass. 377+ (GPBDescriptor *)descriptor { 378 static GPBDescriptor *descriptor = nil; 379 if (!descriptor) { 380 static GPBMessageFieldDescription fields[] = { 381 { 382 .name = "value", 383 .dataTypeSpecific.className = NULL, 384 .number = GPBStringValue_FieldNumber_Value, 385 .hasIndex = 0, 386 .offset = (uint32_t)offsetof(GPBStringValue__storage_, value), 387 .flags = GPBFieldOptional, 388 .dataType = GPBDataTypeString, 389 }, 390 }; 391 GPBDescriptor *localDescriptor = 392 [GPBDescriptor allocDescriptorForClass:[GPBStringValue class] 393 rootClass:[GPBWrappersRoot class] 394 file:GPBWrappersRoot_FileDescriptor() 395 fields:fields 396 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 397 storageSize:sizeof(GPBStringValue__storage_) 398 flags:GPBDescriptorInitializationFlag_None]; 399 #if defined(DEBUG) && DEBUG 400 NSAssert(descriptor == nil, @"Startup recursed!"); 401 #endif // DEBUG 402 descriptor = localDescriptor; 403 } 404 return descriptor; 405} 406 407@end 408 409#pragma mark - GPBBytesValue 410 411@implementation GPBBytesValue 412 413@dynamic value; 414 415typedef struct GPBBytesValue__storage_ { 416 uint32_t _has_storage_[1]; 417 NSData *value; 418} GPBBytesValue__storage_; 419 420// This method is threadsafe because it is initially called 421// in +initialize for each subclass. 422+ (GPBDescriptor *)descriptor { 423 static GPBDescriptor *descriptor = nil; 424 if (!descriptor) { 425 static GPBMessageFieldDescription fields[] = { 426 { 427 .name = "value", 428 .dataTypeSpecific.className = NULL, 429 .number = GPBBytesValue_FieldNumber_Value, 430 .hasIndex = 0, 431 .offset = (uint32_t)offsetof(GPBBytesValue__storage_, value), 432 .flags = GPBFieldOptional, 433 .dataType = GPBDataTypeBytes, 434 }, 435 }; 436 GPBDescriptor *localDescriptor = 437 [GPBDescriptor allocDescriptorForClass:[GPBBytesValue class] 438 rootClass:[GPBWrappersRoot class] 439 file:GPBWrappersRoot_FileDescriptor() 440 fields:fields 441 fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription)) 442 storageSize:sizeof(GPBBytesValue__storage_) 443 flags:GPBDescriptorInitializationFlag_None]; 444 #if defined(DEBUG) && DEBUG 445 NSAssert(descriptor == nil, @"Startup recursed!"); 446 #endif // DEBUG 447 descriptor = localDescriptor; 448 } 449 return descriptor; 450} 451 452@end 453 454 455#pragma clang diagnostic pop 456 457// @@protoc_insertion_point(global_scope) 458