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