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