added iOS source code
[wl-app.git] / 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)