xref: /aosp_15_r20/external/cronet/third_party/protobuf/objectivec/GPBWrappers.pbobjc.m (revision 6777b5387eb2ff775bb5750e3f5d96f37fb7352b) 
1// Generated by the protocol buffer compiler.  DO NOT EDIT!
2// source: google/protobuf/wrappers.proto
3
4#import "GPBProtocolBuffers_RuntimeSupport.h"
5#import "GPBWrappers.pbobjc.h"
6
7// @@protoc_insertion_point(imports)
8
9#pragma clang diagnostic push
10#pragma clang diagnostic ignored "-Wdeprecated-declarations"
11
12#pragma mark - GPBWrappersRoot
13
14@implementation GPBWrappersRoot
15
16// No extensions in the file and no imports, so no need to generate
17// +extensionRegistry.
18
19@end
20
21#pragma mark - GPBWrappersRoot_FileDescriptor
22
23static GPBFileDescriptor *GPBWrappersRoot_FileDescriptor(void) {
24  // This is called by +initialize so there is no need to worry
25  // about thread safety of the singleton.
26  static GPBFileDescriptor *descriptor = NULL;
27  if (!descriptor) {
28    GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
29    descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
30                                                 objcPrefix:@"GPB"
31                                                     syntax:GPBFileSyntaxProto3];
32  }
33  return descriptor;
34}
35
36#pragma mark - GPBDoubleValue
37
38@implementation GPBDoubleValue
39
40@dynamic value;
41
42typedef struct GPBDoubleValue__storage_ {
43  uint32_t _has_storage_[1];
44  double value;
45} GPBDoubleValue__storage_;
46
47// This method is threadsafe because it is initially called
48// in +initialize for each subclass.
49+ (GPBDescriptor *)descriptor {
50  static GPBDescriptor *descriptor = nil;
51  if (!descriptor) {
52    static GPBMessageFieldDescription fields[] = {
53      {
54        .name = "value",
55        .dataTypeSpecific.clazz = Nil,
56        .number = GPBDoubleValue_FieldNumber_Value,
57        .hasIndex = 0,
58        .offset = (uint32_t)offsetof(GPBDoubleValue__storage_, value),
59        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
60        .dataType = GPBDataTypeDouble,
61      },
62    };
63    GPBDescriptor *localDescriptor =
64        [GPBDescriptor allocDescriptorForClass:[GPBDoubleValue class]
65                                     rootClass:[GPBWrappersRoot class]
66                                          file:GPBWrappersRoot_FileDescriptor()
67                                        fields:fields
68                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
69                                   storageSize:sizeof(GPBDoubleValue__storage_)
70                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
71    #if defined(DEBUG) && DEBUG
72      NSAssert(descriptor == nil, @"Startup recursed!");
73    #endif  // DEBUG
74    descriptor = localDescriptor;
75  }
76  return descriptor;
77}
78
79@end
80
81#pragma mark - GPBFloatValue
82
83@implementation GPBFloatValue
84
85@dynamic value;
86
87typedef struct GPBFloatValue__storage_ {
88  uint32_t _has_storage_[1];
89  float value;
90} GPBFloatValue__storage_;
91
92// This method is threadsafe because it is initially called
93// in +initialize for each subclass.
94+ (GPBDescriptor *)descriptor {
95  static GPBDescriptor *descriptor = nil;
96  if (!descriptor) {
97    static GPBMessageFieldDescription fields[] = {
98      {
99        .name = "value",
100        .dataTypeSpecific.clazz = Nil,
101        .number = GPBFloatValue_FieldNumber_Value,
102        .hasIndex = 0,
103        .offset = (uint32_t)offsetof(GPBFloatValue__storage_, value),
104        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
105        .dataType = GPBDataTypeFloat,
106      },
107    };
108    GPBDescriptor *localDescriptor =
109        [GPBDescriptor allocDescriptorForClass:[GPBFloatValue class]
110                                     rootClass:[GPBWrappersRoot class]
111                                          file:GPBWrappersRoot_FileDescriptor()
112                                        fields:fields
113                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
114                                   storageSize:sizeof(GPBFloatValue__storage_)
115                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
116    #if defined(DEBUG) && DEBUG
117      NSAssert(descriptor == nil, @"Startup recursed!");
118    #endif  // DEBUG
119    descriptor = localDescriptor;
120  }
121  return descriptor;
122}
123
124@end
125
126#pragma mark - GPBInt64Value
127
128@implementation GPBInt64Value
129
130@dynamic value;
131
132typedef struct GPBInt64Value__storage_ {
133  uint32_t _has_storage_[1];
134  int64_t value;
135} GPBInt64Value__storage_;
136
137// This method is threadsafe because it is initially called
138// in +initialize for each subclass.
139+ (GPBDescriptor *)descriptor {
140  static GPBDescriptor *descriptor = nil;
141  if (!descriptor) {
142    static GPBMessageFieldDescription fields[] = {
143      {
144        .name = "value",
145        .dataTypeSpecific.clazz = Nil,
146        .number = GPBInt64Value_FieldNumber_Value,
147        .hasIndex = 0,
148        .offset = (uint32_t)offsetof(GPBInt64Value__storage_, value),
149        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
150        .dataType = GPBDataTypeInt64,
151      },
152    };
153    GPBDescriptor *localDescriptor =
154        [GPBDescriptor allocDescriptorForClass:[GPBInt64Value class]
155                                     rootClass:[GPBWrappersRoot class]
156                                          file:GPBWrappersRoot_FileDescriptor()
157                                        fields:fields
158                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
159                                   storageSize:sizeof(GPBInt64Value__storage_)
160                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
161    #if defined(DEBUG) && DEBUG
162      NSAssert(descriptor == nil, @"Startup recursed!");
163    #endif  // DEBUG
164    descriptor = localDescriptor;
165  }
166  return descriptor;
167}
168
169@end
170
171#pragma mark - GPBUInt64Value
172
173@implementation GPBUInt64Value
174
175@dynamic value;
176
177typedef struct GPBUInt64Value__storage_ {
178  uint32_t _has_storage_[1];
179  uint64_t value;
180} GPBUInt64Value__storage_;
181
182// This method is threadsafe because it is initially called
183// in +initialize for each subclass.
184+ (GPBDescriptor *)descriptor {
185  static GPBDescriptor *descriptor = nil;
186  if (!descriptor) {
187    static GPBMessageFieldDescription fields[] = {
188      {
189        .name = "value",
190        .dataTypeSpecific.clazz = Nil,
191        .number = GPBUInt64Value_FieldNumber_Value,
192        .hasIndex = 0,
193        .offset = (uint32_t)offsetof(GPBUInt64Value__storage_, value),
194        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
195        .dataType = GPBDataTypeUInt64,
196      },
197    };
198    GPBDescriptor *localDescriptor =
199        [GPBDescriptor allocDescriptorForClass:[GPBUInt64Value class]
200                                     rootClass:[GPBWrappersRoot class]
201                                          file:GPBWrappersRoot_FileDescriptor()
202                                        fields:fields
203                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
204                                   storageSize:sizeof(GPBUInt64Value__storage_)
205                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
206    #if defined(DEBUG) && DEBUG
207      NSAssert(descriptor == nil, @"Startup recursed!");
208    #endif  // DEBUG
209    descriptor = localDescriptor;
210  }
211  return descriptor;
212}
213
214@end
215
216#pragma mark - GPBInt32Value
217
218@implementation GPBInt32Value
219
220@dynamic value;
221
222typedef struct GPBInt32Value__storage_ {
223  uint32_t _has_storage_[1];
224  int32_t value;
225} GPBInt32Value__storage_;
226
227// This method is threadsafe because it is initially called
228// in +initialize for each subclass.
229+ (GPBDescriptor *)descriptor {
230  static GPBDescriptor *descriptor = nil;
231  if (!descriptor) {
232    static GPBMessageFieldDescription fields[] = {
233      {
234        .name = "value",
235        .dataTypeSpecific.clazz = Nil,
236        .number = GPBInt32Value_FieldNumber_Value,
237        .hasIndex = 0,
238        .offset = (uint32_t)offsetof(GPBInt32Value__storage_, value),
239        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
240        .dataType = GPBDataTypeInt32,
241      },
242    };
243    GPBDescriptor *localDescriptor =
244        [GPBDescriptor allocDescriptorForClass:[GPBInt32Value class]
245                                     rootClass:[GPBWrappersRoot class]
246                                          file:GPBWrappersRoot_FileDescriptor()
247                                        fields:fields
248                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
249                                   storageSize:sizeof(GPBInt32Value__storage_)
250                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
251    #if defined(DEBUG) && DEBUG
252      NSAssert(descriptor == nil, @"Startup recursed!");
253    #endif  // DEBUG
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.clazz = Nil,
281        .number = GPBUInt32Value_FieldNumber_Value,
282        .hasIndex = 0,
283        .offset = (uint32_t)offsetof(GPBUInt32Value__storage_, value),
284        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
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:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
296    #if defined(DEBUG) && DEBUG
297      NSAssert(descriptor == nil, @"Startup recursed!");
298    #endif  // DEBUG
299    descriptor = localDescriptor;
300  }
301  return descriptor;
302}
303
304@end
305
306#pragma mark - GPBBoolValue
307
308@implementation GPBBoolValue
309
310@dynamic value;
311
312typedef struct GPBBoolValue__storage_ {
313  uint32_t _has_storage_[1];
314} GPBBoolValue__storage_;
315
316// This method is threadsafe because it is initially called
317// in +initialize for each subclass.
318+ (GPBDescriptor *)descriptor {
319  static GPBDescriptor *descriptor = nil;
320  if (!descriptor) {
321    static GPBMessageFieldDescription fields[] = {
322      {
323        .name = "value",
324        .dataTypeSpecific.clazz = Nil,
325        .number = GPBBoolValue_FieldNumber_Value,
326        .hasIndex = 0,
327        .offset = 1,  // Stored in _has_storage_ to save space.
328        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
329        .dataType = GPBDataTypeBool,
330      },
331    };
332    GPBDescriptor *localDescriptor =
333        [GPBDescriptor allocDescriptorForClass:[GPBBoolValue class]
334                                     rootClass:[GPBWrappersRoot class]
335                                          file:GPBWrappersRoot_FileDescriptor()
336                                        fields:fields
337                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
338                                   storageSize:sizeof(GPBBoolValue__storage_)
339                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
340    #if defined(DEBUG) && DEBUG
341      NSAssert(descriptor == nil, @"Startup recursed!");
342    #endif  // DEBUG
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
356typedef 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.clazz = Nil,
370        .number = GPBStringValue_FieldNumber_Value,
371        .hasIndex = 0,
372        .offset = (uint32_t)offsetof(GPBStringValue__storage_, value),
373        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
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:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
385    #if defined(DEBUG) && DEBUG
386      NSAssert(descriptor == nil, @"Startup recursed!");
387    #endif  // DEBUG
388    descriptor = localDescriptor;
389  }
390  return descriptor;
391}
392
393@end
394
395#pragma mark - GPBBytesValue
396
397@implementation GPBBytesValue
398
399@dynamic value;
400
401typedef struct GPBBytesValue__storage_ {
402  uint32_t _has_storage_[1];
403  NSData *value;
404} GPBBytesValue__storage_;
405
406// This method is threadsafe because it is initially called
407// in +initialize for each subclass.
408+ (GPBDescriptor *)descriptor {
409  static GPBDescriptor *descriptor = nil;
410  if (!descriptor) {
411    static GPBMessageFieldDescription fields[] = {
412      {
413        .name = "value",
414        .dataTypeSpecific.clazz = Nil,
415        .number = GPBBytesValue_FieldNumber_Value,
416        .hasIndex = 0,
417        .offset = (uint32_t)offsetof(GPBBytesValue__storage_, value),
418        .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldClearHasIvarOnZero),
419        .dataType = GPBDataTypeBytes,
420      },
421    };
422    GPBDescriptor *localDescriptor =
423        [GPBDescriptor allocDescriptorForClass:[GPBBytesValue class]
424                                     rootClass:[GPBWrappersRoot class]
425                                          file:GPBWrappersRoot_FileDescriptor()
426                                        fields:fields
427                                    fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
428                                   storageSize:sizeof(GPBBytesValue__storage_)
429                                         flags:(GPBDescriptorInitializationFlags)(GPBDescriptorInitializationFlag_UsesClassRefs | GPBDescriptorInitializationFlag_Proto3OptionalKnown)];
430    #if defined(DEBUG) && DEBUG
431      NSAssert(descriptor == nil, @"Startup recursed!");
432    #endif  // DEBUG
433    descriptor = localDescriptor;
434  }
435  return descriptor;
436}
437
438@end
439
440
441#pragma clang diagnostic pop
442
443// @@protoc_insertion_point(global_scope)
444