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

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: google/protobuf/struct.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/Struct.pbobjc.h>
  20 #else
  21  #import "google/protobuf/Struct.pbobjc.h"
  22 #endif
  23 // @@protoc_insertion_point(imports)
  24
  25 #pragma clang diagnostic push
  26 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
  27 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
  28
  29 #pragma mark - GPBStructRoot
  30
  31 @implementation GPBStructRoot
  32
  33 // No extensions in the file and no imports, so no need to generate
  34 // +extensionRegistry.
  35
  36 @end
  37
  38 #pragma mark - GPBStructRoot_FileDescriptor
  39
  40 static GPBFileDescriptor *GPBStructRoot_FileDescriptor(void) {
  41   // This is called by +initialize so there is no need to worry
  42   // about thread safety of the singleton.
  43   static GPBFileDescriptor *descriptor = NULL;
  44   if (!descriptor) {
  45     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
  46     descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
  47                                                  objcPrefix:@"GPB"
  48                                                      syntax:GPBFileSyntaxProto3];
  49   }
  50   return descriptor;
  51 }
  52
  53 #pragma mark - Enum GPBNullValue
  54
  55 GPBEnumDescriptor *GPBNullValue_EnumDescriptor(void) {
  56   static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  57   if (!descriptor) {
  58     static const char *valueNames =
  59         "NullValue\000";
  60     static const int32_t values[] = {
  61         GPBNullValue_NullValue,
  62     };
  63     GPBEnumDescriptor *worker =
  64         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBNullValue)
  65                                        valueNames:valueNames
  66                                            values:values
  67                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
  68                                      enumVerifier:GPBNullValue_IsValidValue];
  69     GPBEnumDescriptor *expected = nil;
  70     if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
  71       [worker release];
  72     }
  73   }
  74   return descriptor;
  75 }
  76
  77 BOOL GPBNullValue_IsValidValue(int32_t value__) {
  78   switch (value__) {
  79     case GPBNullValue_NullValue:
  80       return YES;
  81     default:
  82       return NO;
  83   }
  84 }
  85
  86 #pragma mark - GPBStruct
  87
  88 @implementation GPBStruct
  89
  90 @dynamic fields, fields_Count;
  91
  92 typedef struct GPBStruct__storage_ {
  93   uint32_t _has_storage_[1];
  94   NSMutableDictionary *fields;
  95 } GPBStruct__storage_;
  96
  97 // This method is threadsafe because it is initially called
  98 // in +initialize for each subclass.
  99 + (GPBDescriptor *)descriptor {
 100   static GPBDescriptor *descriptor = nil;
 101   if (!descriptor) {
 102     static GPBMessageFieldDescription fields[] = {
 103       {
 104         .name = "fields",
 105         .dataTypeSpecific.className = GPBStringifySymbol(GPBValue),
 106         .number = GPBStruct_FieldNumber_Fields,
 107         .hasIndex = GPBNoHasBit,
 108         .offset = (uint32_t)offsetof(GPBStruct__storage_, fields),
 109         .flags = GPBFieldMapKeyString,
 110         .dataType = GPBDataTypeMessage,
 111       },
 112     };
 113     GPBDescriptor *localDescriptor =
 114         [GPBDescriptor allocDescriptorForClass:[GPBStruct class]
 115                                      rootClass:[GPBStructRoot class]
 116                                           file:GPBStructRoot_FileDescriptor()
 117                                         fields:fields
 118                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 119                                    storageSize:sizeof(GPBStruct__storage_)
 120                                          flags:GPBDescriptorInitializationFlag_None];
 121     NSAssert(descriptor == nil, @"Startup recursed!");
 122     descriptor = localDescriptor;
 123   }
 124   return descriptor;
 125 }
 126
 127 @end
 128
 129 #pragma mark - GPBValue
 130
 131 @implementation GPBValue
 132
 133 @dynamic kindOneOfCase;
 134 @dynamic nullValue;
 135 @dynamic numberValue;
 136 @dynamic stringValue;
 137 @dynamic boolValue;
 138 @dynamic structValue;
 139 @dynamic listValue;
 140
 141 typedef struct GPBValue__storage_ {
 142   uint32_t _has_storage_[2];
 143   GPBNullValue nullValue;
 144   NSString *stringValue;
 145   GPBStruct *structValue;
 146   GPBListValue *listValue;
 147   double numberValue;
 148 } GPBValue__storage_;
 149
 150 // This method is threadsafe because it is initially called
 151 // in +initialize for each subclass.
 152 + (GPBDescriptor *)descriptor {
 153   static GPBDescriptor *descriptor = nil;
 154   if (!descriptor) {
 155     static GPBMessageFieldDescription fields[] = {
 156       {
 157         .name = "nullValue",
 158         .dataTypeSpecific.enumDescFunc = GPBNullValue_EnumDescriptor,
 159         .number = GPBValue_FieldNumber_NullValue,
 160         .hasIndex = -1,
 161         .offset = (uint32_t)offsetof(GPBValue__storage_, nullValue),
 162         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
 163         .dataType = GPBDataTypeEnum,
 164       },
 165       {
 166         .name = "numberValue",
 167         .dataTypeSpecific.className = NULL,
 168         .number = GPBValue_FieldNumber_NumberValue,
 169         .hasIndex = -1,
 170         .offset = (uint32_t)offsetof(GPBValue__storage_, numberValue),
 171         .flags = GPBFieldOptional,
 172         .dataType = GPBDataTypeDouble,
 173       },
 174       {
 175         .name = "stringValue",
 176         .dataTypeSpecific.className = NULL,
 177         .number = GPBValue_FieldNumber_StringValue,
 178         .hasIndex = -1,
 179         .offset = (uint32_t)offsetof(GPBValue__storage_, stringValue),
 180         .flags = GPBFieldOptional,
 181         .dataType = GPBDataTypeString,
 182       },
 183       {
 184         .name = "boolValue",
 185         .dataTypeSpecific.className = NULL,
 186         .number = GPBValue_FieldNumber_BoolValue,
 187         .hasIndex = -1,
 188         .offset = 0,  // Stored in _has_storage_ to save space.
 189         .flags = GPBFieldOptional,
 190         .dataType = GPBDataTypeBool,
 191       },
 192       {
 193         .name = "structValue",
 194         .dataTypeSpecific.className = GPBStringifySymbol(GPBStruct),
 195         .number = GPBValue_FieldNumber_StructValue,
 196         .hasIndex = -1,
 197         .offset = (uint32_t)offsetof(GPBValue__storage_, structValue),
 198         .flags = GPBFieldOptional,
 199         .dataType = GPBDataTypeMessage,
 200       },
 201       {
 202         .name = "listValue",
 203         .dataTypeSpecific.className = GPBStringifySymbol(GPBListValue),
 204         .number = GPBValue_FieldNumber_ListValue,
 205         .hasIndex = -1,
 206         .offset = (uint32_t)offsetof(GPBValue__storage_, listValue),
 207         .flags = GPBFieldOptional,
 208         .dataType = GPBDataTypeMessage,
 209       },
 210     };
 211     GPBDescriptor *localDescriptor =
 212         [GPBDescriptor allocDescriptorForClass:[GPBValue class]
 213                                      rootClass:[GPBStructRoot class]
 214                                           file:GPBStructRoot_FileDescriptor()
 215                                         fields:fields
 216                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 217                                    storageSize:sizeof(GPBValue__storage_)
 218                                          flags:GPBDescriptorInitializationFlag_None];
 219     static const char *oneofs[] = {
 220       "kind",
 221     };
 222     [localDescriptor setupOneofs:oneofs
 223                            count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
 224                    firstHasIndex:-1];
 225     NSAssert(descriptor == nil, @"Startup recursed!");
 226     descriptor = localDescriptor;
 227   }
 228   return descriptor;
 229 }
 230
 231 @end
 232
 233 int32_t GPBValue_NullValue_RawValue(GPBValue *message) {
 234   GPBDescriptor *descriptor = [GPBValue descriptor];
 235   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBValue_FieldNumber_NullValue];
 236   return GPBGetMessageInt32Field(message, field);
 237 }
 238
 239 void SetGPBValue_NullValue_RawValue(GPBValue *message, int32_t value) {
 240   GPBDescriptor *descriptor = [GPBValue descriptor];
 241   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBValue_FieldNumber_NullValue];
 242   GPBSetInt32IvarWithFieldInternal(message, field, value, descriptor.file.syntax);
 243 }
 244
 245 void GPBValue_ClearKindOneOfCase(GPBValue *message) {
 246   GPBDescriptor *descriptor = [message descriptor];
 247   GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
 248   GPBMaybeClearOneof(message, oneof, -1, 0);
 249 }
 250 #pragma mark - GPBListValue
 251
 252 @implementation GPBListValue
 253
 254 @dynamic valuesArray, valuesArray_Count;
 255
 256 typedef struct GPBListValue__storage_ {
 257   uint32_t _has_storage_[1];
 258   NSMutableArray *valuesArray;
 259 } GPBListValue__storage_;
 260
 261 // This method is threadsafe because it is initially called
 262 // in +initialize for each subclass.
 263 + (GPBDescriptor *)descriptor {
 264   static GPBDescriptor *descriptor = nil;
 265   if (!descriptor) {
 266     static GPBMessageFieldDescription fields[] = {
 267       {
 268         .name = "valuesArray",
 269         .dataTypeSpecific.className = GPBStringifySymbol(GPBValue),
 270         .number = GPBListValue_FieldNumber_ValuesArray,
 271         .hasIndex = GPBNoHasBit,
 272         .offset = (uint32_t)offsetof(GPBListValue__storage_, valuesArray),
 273         .flags = GPBFieldRepeated,
 274         .dataType = GPBDataTypeMessage,
 275       },
 276     };
 277     GPBDescriptor *localDescriptor =
 278         [GPBDescriptor allocDescriptorForClass:[GPBListValue class]
 279                                      rootClass:[GPBStructRoot class]
 280                                           file:GPBStructRoot_FileDescriptor()
 281                                         fields:fields
 282                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 283                                    storageSize:sizeof(GPBListValue__storage_)
 284                                          flags:GPBDescriptorInitializationFlag_None];
 285     NSAssert(descriptor == nil, @"Startup recursed!");
 286     descriptor = localDescriptor;
 287   }
 288   return descriptor;
 289 }
 290
 291 @end
 292
 293
 294 #pragma clang diagnostic pop
 295
 296 // @@protoc_insertion_point(global_scope)