objectivec/GPBStruct.pbobjc.m

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // NO CHECKED-IN PROTOBUF GENCODE
   3 // clang-format off
   4 // source: google/protobuf/struct.proto
   5
   6 #import "GPBProtocolBuffers_RuntimeSupport.h"
   7 #import "GPBStruct.pbobjc.h"
   8
   9 #if GOOGLE_PROTOBUF_OBJC_VERSION < 30007
  10 #error This file was generated by a newer version of protoc which is incompatible with your Protocol Buffer library sources.
  11 #endif
  12 #if 30007 < GOOGLE_PROTOBUF_OBJC_MIN_SUPPORTED_VERSION
  13 #error This file was generated by an older version of protoc which is incompatible with your Protocol Buffer library sources.
  14 #endif
  15
  16 #import <stdatomic.h>
  17
  18 // @@protoc_insertion_point(imports)
  19
  20 #pragma clang diagnostic push
  21 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
  22 #pragma clang diagnostic ignored "-Wdirect-ivar-access"
  23 #pragma clang diagnostic ignored "-Wdollar-in-identifier-extension"
  24
  25 #pragma mark - Objective-C Class declarations
  26 // Forward declarations of Objective-C classes that we can use as
  27 // static values in struct initializers.
  28 // We don't use [Foo class] because it is not a static value.
  29 GPBObjCClassDeclaration(GPBListValue);
  30 GPBObjCClassDeclaration(GPBStruct);
  31 GPBObjCClassDeclaration(GPBValue);
  32
  33 #pragma mark - GPBStructRoot
  34
  35 @implementation GPBStructRoot
  36
  37 // No extensions in the file and no imports or none of the imports (direct or
  38 // indirect) defined extensions, so no need to generate +extensionRegistry.
  39
  40 @end
  41
  42 static GPBFileDescription GPBStructRoot_FileDescription = {
  43   .package = "google.protobuf",
  44   .prefix = "GPB",
  45   .syntax = GPBFileSyntaxProto3
  46 };
  47
  48 #pragma mark - Enum GPBNullValue
  49
  50 GPBEnumDescriptor *GPBNullValue_EnumDescriptor(void) {
  51   static _Atomic(GPBEnumDescriptor*) descriptor = nil;
  52   if (!descriptor) {
  53     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
  54     static const char *valueNames =
  55         "NullValue\000";
  56     static const int32_t values[] = {
  57         GPBNullValue_NullValue,
  58     };
  59     GPBEnumDescriptor *worker =
  60         [GPBEnumDescriptor allocDescriptorForName:GPBNSStringifySymbol(GPBNullValue)
  61                                        valueNames:valueNames
  62                                            values:values
  63                                             count:(uint32_t)(sizeof(values) / sizeof(int32_t))
  64                                      enumVerifier:GPBNullValue_IsValidValue
  65                                             flags:GPBEnumDescriptorInitializationFlag_None];
  66     GPBEnumDescriptor *expected = nil;
  67     if (!atomic_compare_exchange_strong(&descriptor, &expected, worker)) {
  68       [worker release];
  69     }
  70   }
  71   return descriptor;
  72 }
  73
  74 BOOL GPBNullValue_IsValidValue(int32_t value__) {
  75   switch (value__) {
  76     case GPBNullValue_NullValue:
  77       return YES;
  78     default:
  79       return NO;
  80   }
  81 }
  82
  83 #pragma mark - GPBStruct
  84
  85 @implementation GPBStruct
  86
  87 @dynamic fields, fields_Count;
  88
  89 typedef struct GPBStruct__storage_ {
  90   uint32_t _has_storage_[1];
  91   NSMutableDictionary *fields;
  92 } GPBStruct__storage_;
  93
  94 // This method is threadsafe because it is initially called
  95 // in +initialize for each subclass.
  96 + (GPBDescriptor *)descriptor {
  97   static GPBDescriptor *descriptor = nil;
  98   if (!descriptor) {
  99     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
 100     static GPBMessageFieldDescription fields[] = {
 101       {
 102         .name = "fields",
 103         .dataTypeSpecific.clazz = GPBObjCClass(GPBValue),
 104         .number = GPBStruct_FieldNumber_Fields,
 105         .hasIndex = GPBNoHasBit,
 106         .offset = (uint32_t)offsetof(GPBStruct__storage_, fields),
 107         .flags = GPBFieldMapKeyString,
 108         .dataType = GPBDataTypeMessage,
 109       },
 110     };
 111     GPBDescriptor *localDescriptor =
 112         [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBStruct)
 113                                    messageName:@"Struct"
 114                                fileDescription:&GPBStructRoot_FileDescription
 115                                         fields:fields
 116                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 117                                    storageSize:sizeof(GPBStruct__storage_)
 118                                          flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
 119     #if defined(DEBUG) && DEBUG
 120       NSAssert(descriptor == nil, @"Startup recursed!");
 121     #endif  // DEBUG
 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     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
 156     static GPBMessageFieldDescription fields[] = {
 157       {
 158         .name = "nullValue",
 159         .dataTypeSpecific.enumDescFunc = GPBNullValue_EnumDescriptor,
 160         .number = GPBValue_FieldNumber_NullValue,
 161         .hasIndex = -1,
 162         .offset = (uint32_t)offsetof(GPBValue__storage_, nullValue),
 163         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
 164         .dataType = GPBDataTypeEnum,
 165       },
 166       {
 167         .name = "numberValue",
 168         .dataTypeSpecific.clazz = Nil,
 169         .number = GPBValue_FieldNumber_NumberValue,
 170         .hasIndex = -1,
 171         .offset = (uint32_t)offsetof(GPBValue__storage_, numberValue),
 172         .flags = GPBFieldOptional,
 173         .dataType = GPBDataTypeDouble,
 174       },
 175       {
 176         .name = "stringValue",
 177         .dataTypeSpecific.clazz = Nil,
 178         .number = GPBValue_FieldNumber_StringValue,
 179         .hasIndex = -1,
 180         .offset = (uint32_t)offsetof(GPBValue__storage_, stringValue),
 181         .flags = GPBFieldOptional,
 182         .dataType = GPBDataTypeString,
 183       },
 184       {
 185         .name = "boolValue",
 186         .dataTypeSpecific.clazz = Nil,
 187         .number = GPBValue_FieldNumber_BoolValue,
 188         .hasIndex = -1,
 189         .offset = 0,  // Stored in _has_storage_ to save space.
 190         .flags = GPBFieldOptional,
 191         .dataType = GPBDataTypeBool,
 192       },
 193       {
 194         .name = "structValue",
 195         .dataTypeSpecific.clazz = GPBObjCClass(GPBStruct),
 196         .number = GPBValue_FieldNumber_StructValue,
 197         .hasIndex = -1,
 198         .offset = (uint32_t)offsetof(GPBValue__storage_, structValue),
 199         .flags = GPBFieldOptional,
 200         .dataType = GPBDataTypeMessage,
 201       },
 202       {
 203         .name = "listValue",
 204         .dataTypeSpecific.clazz = GPBObjCClass(GPBListValue),
 205         .number = GPBValue_FieldNumber_ListValue,
 206         .hasIndex = -1,
 207         .offset = (uint32_t)offsetof(GPBValue__storage_, listValue),
 208         .flags = GPBFieldOptional,
 209         .dataType = GPBDataTypeMessage,
 210       },
 211     };
 212     GPBDescriptor *localDescriptor =
 213         [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBValue)
 214                                    messageName:@"Value"
 215                                fileDescription:&GPBStructRoot_FileDescription
 216                                         fields:fields
 217                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 218                                    storageSize:sizeof(GPBValue__storage_)
 219                                          flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
 220     static const char *oneofs[] = {
 221       "kind",
 222     };
 223     [localDescriptor setupOneofs:oneofs
 224                            count:(uint32_t)(sizeof(oneofs) / sizeof(char*))
 225                    firstHasIndex:-1];
 226     #if defined(DEBUG) && DEBUG
 227       NSAssert(descriptor == nil, @"Startup recursed!");
 228     #endif  // DEBUG
 229     descriptor = localDescriptor;
 230   }
 231   return descriptor;
 232 }
 233
 234 @end
 235
 236 int32_t GPBValue_NullValue_RawValue(GPBValue *message) {
 237   GPBDescriptor *descriptor = [GPBValue descriptor];
 238   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBValue_FieldNumber_NullValue];
 239   return GPBGetMessageRawEnumField(message, field);
 240 }
 241
 242 void SetGPBValue_NullValue_RawValue(GPBValue *message, int32_t value) {
 243   GPBDescriptor *descriptor = [GPBValue descriptor];
 244   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBValue_FieldNumber_NullValue];
 245   GPBSetMessageRawEnumField(message, field, value);
 246 }
 247
 248 void GPBValue_ClearKindOneOfCase(GPBValue *message) {
 249   GPBDescriptor *descriptor = [GPBValue descriptor];
 250   GPBOneofDescriptor *oneof = [descriptor.oneofs objectAtIndex:0];
 251   GPBClearOneof(message, oneof);
 252 }
 253 #pragma mark - GPBListValue
 254
 255 @implementation GPBListValue
 256
 257 @dynamic valuesArray, valuesArray_Count;
 258
 259 typedef struct GPBListValue__storage_ {
 260   uint32_t _has_storage_[1];
 261   NSMutableArray *valuesArray;
 262 } GPBListValue__storage_;
 263
 264 // This method is threadsafe because it is initially called
 265 // in +initialize for each subclass.
 266 + (GPBDescriptor *)descriptor {
 267   static GPBDescriptor *descriptor = nil;
 268   if (!descriptor) {
 269     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
 270     static GPBMessageFieldDescription fields[] = {
 271       {
 272         .name = "valuesArray",
 273         .dataTypeSpecific.clazz = GPBObjCClass(GPBValue),
 274         .number = GPBListValue_FieldNumber_ValuesArray,
 275         .hasIndex = GPBNoHasBit,
 276         .offset = (uint32_t)offsetof(GPBListValue__storage_, valuesArray),
 277         .flags = GPBFieldRepeated,
 278         .dataType = GPBDataTypeMessage,
 279       },
 280     };
 281     GPBDescriptor *localDescriptor =
 282         [GPBDescriptor allocDescriptorForClass:GPBObjCClass(GPBListValue)
 283                                    messageName:@"ListValue"
 284                                fileDescription:&GPBStructRoot_FileDescription
 285                                         fields:fields
 286                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
 287                                    storageSize:sizeof(GPBListValue__storage_)
 288                                          flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown | GPBDescriptorInitializationFlag_ClosedEnumSupportKnown)];
 289     #if defined(DEBUG) && DEBUG
 290       NSAssert(descriptor == nil, @"Startup recursed!");
 291     #endif  // DEBUG
 292     descriptor = localDescriptor;
 293   }
 294   return descriptor;
 295 }
 296
 297 @end
 298
 299
 300 #pragma clang diagnostic pop
 301
 302 // @@protoc_insertion_point(global_scope)
 303
 304 // clang-format on