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

   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
  37 static 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
  56 typedef 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     NSAssert(descriptor == nil, @"Startup recursed!");
  86     descriptor = localDescriptor;
  87   }
  88   return descriptor;
  89 }
  90
  91 @end
  92
  93 #pragma mark - GPBFloatValue
  94
  95 @implementation GPBFloatValue
  96
  97 @dynamic value;
  98
  99 typedef struct GPBFloatValue__storage_ {
 100   uint32_t _has_storage_[1];
 101   float value;
 102 } GPBFloatValue__storage_;
 103
 104 // This method is threadsafe because it is initially called
 105 // in +initialize for each subclass.
 106 + (GPBDescriptor *)descriptor {
 107   static GPBDescriptor *descriptor = nil;
 108   if (!descriptor) {
 109     static GPBMessageFieldDescription fields[] = {
 110       {
 111         .name = "value",
 112         .dataTypeSpecific.className = NULL,
 113         .number = GPBFloatValue_FieldNumber_Value,
 114         .hasIndex = 0,
 115         .offset = (uint32_t)offsetof(GPBFloatValue__storage_, value),
 116         .flags = GPBFieldOptional,
 117         .dataType = GPBDataTypeFloat,
 118       },
 119     };
 120     GPBDescriptor *localDescriptor =
 121         [GPBDescriptor allocDescriptorForClass:[GPBFloatValue class]
 122                                      rootClass:[GPBWrappersRoot class]
 123                                           file:GPBWrappersRoot_FileDescriptor()
 124                                         fields:fields
 125                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 126                                    storageSize:sizeof(GPBFloatValue__storage_)
 127                                          flags:GPBDescriptorInitializationFlag_None];
 128     NSAssert(descriptor == nil, @"Startup recursed!");
 129     descriptor = localDescriptor;
 130   }
 131   return descriptor;
 132 }
 133
 134 @end
 135
 136 #pragma mark - GPBInt64Value
 137
 138 @implementation GPBInt64Value
 139
 140 @dynamic value;
 141
 142 typedef struct GPBInt64Value__storage_ {
 143   uint32_t _has_storage_[1];
 144   int64_t value;
 145 } GPBInt64Value__storage_;
 146
 147 // This method is threadsafe because it is initially called
 148 // in +initialize for each subclass.
 149 + (GPBDescriptor *)descriptor {
 150   static GPBDescriptor *descriptor = nil;
 151   if (!descriptor) {
 152     static GPBMessageFieldDescription fields[] = {
 153       {
 154         .name = "value",
 155         .dataTypeSpecific.className = NULL,
 156         .number = GPBInt64Value_FieldNumber_Value,
 157         .hasIndex = 0,
 158         .offset = (uint32_t)offsetof(GPBInt64Value__storage_, value),
 159         .flags = GPBFieldOptional,
 160         .dataType = GPBDataTypeInt64,
 161       },
 162     };
 163     GPBDescriptor *localDescriptor =
 164         [GPBDescriptor allocDescriptorForClass:[GPBInt64Value class]
 165                                      rootClass:[GPBWrappersRoot class]
 166                                           file:GPBWrappersRoot_FileDescriptor()
 167                                         fields:fields
 168                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 169                                    storageSize:sizeof(GPBInt64Value__storage_)
 170                                          flags:GPBDescriptorInitializationFlag_None];
 171     NSAssert(descriptor == nil, @"Startup recursed!");
 172     descriptor = localDescriptor;
 173   }
 174   return descriptor;
 175 }
 176
 177 @end
 178
 179 #pragma mark - GPBUInt64Value
 180
 181 @implementation GPBUInt64Value
 182
 183 @dynamic value;
 184
 185 typedef struct GPBUInt64Value__storage_ {
 186   uint32_t _has_storage_[1];
 187   uint64_t value;
 188 } GPBUInt64Value__storage_;
 189
 190 // This method is threadsafe because it is initially called
 191 // in +initialize for each subclass.
 192 + (GPBDescriptor *)descriptor {
 193   static GPBDescriptor *descriptor = nil;
 194   if (!descriptor) {
 195     static GPBMessageFieldDescription fields[] = {
 196       {
 197         .name = "value",
 198         .dataTypeSpecific.className = NULL,
 199         .number = GPBUInt64Value_FieldNumber_Value,
 200         .hasIndex = 0,
 201         .offset = (uint32_t)offsetof(GPBUInt64Value__storage_, value),
 202         .flags = GPBFieldOptional,
 203         .dataType = GPBDataTypeUInt64,
 204       },
 205     };
 206     GPBDescriptor *localDescriptor =
 207         [GPBDescriptor allocDescriptorForClass:[GPBUInt64Value class]
 208                                      rootClass:[GPBWrappersRoot class]
 209                                           file:GPBWrappersRoot_FileDescriptor()
 210                                         fields:fields
 211                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 212                                    storageSize:sizeof(GPBUInt64Value__storage_)
 213                                          flags:GPBDescriptorInitializationFlag_None];
 214     NSAssert(descriptor == nil, @"Startup recursed!");
 215     descriptor = localDescriptor;
 216   }
 217   return descriptor;
 218 }
 219
 220 @end
 221
 222 #pragma mark - GPBInt32Value
 223
 224 @implementation GPBInt32Value
 225
 226 @dynamic value;
 227
 228 typedef struct GPBInt32Value__storage_ {
 229   uint32_t _has_storage_[1];
 230   int32_t value;
 231 } GPBInt32Value__storage_;
 232
 233 // This method is threadsafe because it is initially called
 234 // in +initialize for each subclass.
 235 + (GPBDescriptor *)descriptor {
 236   static GPBDescriptor *descriptor = nil;
 237   if (!descriptor) {
 238     static GPBMessageFieldDescription fields[] = {
 239       {
 240         .name = "value",
 241         .dataTypeSpecific.className = NULL,
 242         .number = GPBInt32Value_FieldNumber_Value,
 243         .hasIndex = 0,
 244         .offset = (uint32_t)offsetof(GPBInt32Value__storage_, value),
 245         .flags = GPBFieldOptional,
 246         .dataType = GPBDataTypeInt32,
 247       },
 248     };
 249     GPBDescriptor *localDescriptor =
 250         [GPBDescriptor allocDescriptorForClass:[GPBInt32Value class]
 251                                      rootClass:[GPBWrappersRoot class]
 252                                           file:GPBWrappersRoot_FileDescriptor()
 253                                         fields:fields
 254                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 255                                    storageSize:sizeof(GPBInt32Value__storage_)
 256                                          flags:GPBDescriptorInitializationFlag_None];
 257     NSAssert(descriptor == nil, @"Startup recursed!");
 258     descriptor = localDescriptor;
 259   }
 260   return descriptor;
 261 }
 262
 263 @end
 264
 265 #pragma mark - GPBUInt32Value
 266
 267 @implementation GPBUInt32Value
 268
 269 @dynamic value;
 270
 271 typedef struct GPBUInt32Value__storage_ {
 272   uint32_t _has_storage_[1];
 273   uint32_t value;
 274 } GPBUInt32Value__storage_;
 275
 276 // This method is threadsafe because it is initially called
 277 // in +initialize for each subclass.
 278 + (GPBDescriptor *)descriptor {
 279   static GPBDescriptor *descriptor = nil;
 280   if (!descriptor) {
 281     static GPBMessageFieldDescription fields[] = {
 282       {
 283         .name = "value",
 284         .dataTypeSpecific.className = NULL,
 285         .number = GPBUInt32Value_FieldNumber_Value,
 286         .hasIndex = 0,
 287         .offset = (uint32_t)offsetof(GPBUInt32Value__storage_, value),
 288         .flags = GPBFieldOptional,
 289         .dataType = GPBDataTypeUInt32,
 290       },
 291     };
 292     GPBDescriptor *localDescriptor =
 293         [GPBDescriptor allocDescriptorForClass:[GPBUInt32Value class]
 294                                      rootClass:[GPBWrappersRoot class]
 295                                           file:GPBWrappersRoot_FileDescriptor()
 296                                         fields:fields
 297                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 298                                    storageSize:sizeof(GPBUInt32Value__storage_)
 299                                          flags:GPBDescriptorInitializationFlag_None];
 300     NSAssert(descriptor == nil, @"Startup recursed!");
 301     descriptor = localDescriptor;
 302   }
 303   return descriptor;
 304 }
 305
 306 @end
 307
 308 #pragma mark - GPBBoolValue
 309
 310 @implementation GPBBoolValue
 311
 312 @dynamic value;
 313
 314 typedef struct GPBBoolValue__storage_ {
 315   uint32_t _has_storage_[1];
 316 } GPBBoolValue__storage_;
 317
 318 // This method is threadsafe because it is initially called
 319 // in +initialize for each subclass.
 320 + (GPBDescriptor *)descriptor {
 321   static GPBDescriptor *descriptor = nil;
 322   if (!descriptor) {
 323     static GPBMessageFieldDescription fields[] = {
 324       {
 325         .name = "value",
 326         .dataTypeSpecific.className = NULL,
 327         .number = GPBBoolValue_FieldNumber_Value,
 328         .hasIndex = 0,
 329         .offset = 1,  // Stored in _has_storage_ to save space.
 330         .flags = GPBFieldOptional,
 331         .dataType = GPBDataTypeBool,
 332       },
 333     };
 334     GPBDescriptor *localDescriptor =
 335         [GPBDescriptor allocDescriptorForClass:[GPBBoolValue class]
 336                                      rootClass:[GPBWrappersRoot class]
 337                                           file:GPBWrappersRoot_FileDescriptor()
 338                                         fields:fields
 339                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 340                                    storageSize:sizeof(GPBBoolValue__storage_)
 341                                          flags:GPBDescriptorInitializationFlag_None];
 342     NSAssert(descriptor == nil, @"Startup recursed!");
 343     descriptor = localDescriptor;
 344   }
 345   return descriptor;
 346 }
 347
 348 @end
 349
 350 #pragma mark - GPBStringValue
 351
 352 @implementation GPBStringValue
 353
 354 @dynamic value;
 355
 356 typedef struct GPBStringValue__storage_ {
 357   uint32_t _has_storage_[1];
 358   NSString *value;
 359 } GPBStringValue__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     static GPBMessageFieldDescription fields[] = {
 367       {
 368         .name = "value",
 369         .dataTypeSpecific.className = NULL,
 370         .number = GPBStringValue_FieldNumber_Value,
 371         .hasIndex = 0,
 372         .offset = (uint32_t)offsetof(GPBStringValue__storage_, value),
 373         .flags = GPBFieldOptional,
 374         .dataType = GPBDataTypeString,
 375       },
 376     };
 377     GPBDescriptor *localDescriptor =
 378         [GPBDescriptor allocDescriptorForClass:[GPBStringValue class]
 379                                      rootClass:[GPBWrappersRoot class]
 380                                           file:GPBWrappersRoot_FileDescriptor()
 381                                         fields:fields
 382                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 383                                    storageSize:sizeof(GPBStringValue__storage_)
 384                                          flags:GPBDescriptorInitializationFlag_None];
 385     NSAssert(descriptor == nil, @"Startup recursed!");
 386     descriptor = localDescriptor;
 387   }
 388   return descriptor;
 389 }
 390
 391 @end
 392
 393 #pragma mark - GPBBytesValue
 394
 395 @implementation GPBBytesValue
 396
 397 @dynamic value;
 398
 399 typedef struct GPBBytesValue__storage_ {
 400   uint32_t _has_storage_[1];
 401   NSData *value;
 402 } GPBBytesValue__storage_;
 403
 404 // This method is threadsafe because it is initially called
 405 // in +initialize for each subclass.
 406 + (GPBDescriptor *)descriptor {
 407   static GPBDescriptor *descriptor = nil;
 408   if (!descriptor) {
 409     static GPBMessageFieldDescription fields[] = {
 410       {
 411         .name = "value",
 412         .dataTypeSpecific.className = NULL,
 413         .number = GPBBytesValue_FieldNumber_Value,
 414         .hasIndex = 0,
 415         .offset = (uint32_t)offsetof(GPBBytesValue__storage_, value),
 416         .flags = GPBFieldOptional,
 417         .dataType = GPBDataTypeBytes,
 418       },
 419     };
 420     GPBDescriptor *localDescriptor =
 421         [GPBDescriptor allocDescriptorForClass:[GPBBytesValue class]
 422                                      rootClass:[GPBWrappersRoot class]
 423                                           file:GPBWrappersRoot_FileDescriptor()
 424                                         fields:fields
 425                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 426                                    storageSize:sizeof(GPBBytesValue__storage_)
 427                                          flags:GPBDescriptorInitializationFlag_None];
 428     NSAssert(descriptor == nil, @"Startup recursed!");
 429     descriptor = localDescriptor;
 430   }
 431   return descriptor;
 432 }
 433
 434 @end
 435
 436
 437 #pragma clang diagnostic pop
 438
 439 // @@protoc_insertion_point(global_scope)