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