Added Android code
[wl-app.git] / iOS / Pods / Protobuf / objectivec / google / protobuf / Api.pbobjc.m
1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: google/protobuf/api.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/Api.pbobjc.h>
18  #import <Protobuf/SourceContext.pbobjc.h>
19  #import <Protobuf/Type.pbobjc.h>
20 #else
21  #import "google/protobuf/Api.pbobjc.h"
22  #import "google/protobuf/SourceContext.pbobjc.h"
23  #import "google/protobuf/Type.pbobjc.h"
24 #endif
25 // @@protoc_insertion_point(imports)
26
27 #pragma clang diagnostic push
28 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
29
30 #pragma mark - GPBApiRoot
31
32 @implementation GPBApiRoot
33
34 // No extensions in the file and none of the imports (direct or indirect)
35 // defined extensions, so no need to generate +extensionRegistry.
36
37 @end
38
39 #pragma mark - GPBApiRoot_FileDescriptor
40
41 static GPBFileDescriptor *GPBApiRoot_FileDescriptor(void) {
42   // This is called by +initialize so there is no need to worry
43   // about thread safety of the singleton.
44   static GPBFileDescriptor *descriptor = NULL;
45   if (!descriptor) {
46     GPB_DEBUG_CHECK_RUNTIME_VERSIONS();
47     descriptor = [[GPBFileDescriptor alloc] initWithPackage:@"google.protobuf"
48                                                  objcPrefix:@"GPB"
49                                                      syntax:GPBFileSyntaxProto3];
50   }
51   return descriptor;
52 }
53
54 #pragma mark - GPBApi
55
56 @implementation GPBApi
57
58 @dynamic name;
59 @dynamic methodsArray, methodsArray_Count;
60 @dynamic optionsArray, optionsArray_Count;
61 @dynamic version;
62 @dynamic hasSourceContext, sourceContext;
63 @dynamic mixinsArray, mixinsArray_Count;
64 @dynamic syntax;
65
66 typedef struct GPBApi__storage_ {
67   uint32_t _has_storage_[1];
68   GPBSyntax syntax;
69   NSString *name;
70   NSMutableArray *methodsArray;
71   NSMutableArray *optionsArray;
72   NSString *version;
73   GPBSourceContext *sourceContext;
74   NSMutableArray *mixinsArray;
75 } GPBApi__storage_;
76
77 // This method is threadsafe because it is initially called
78 // in +initialize for each subclass.
79 + (GPBDescriptor *)descriptor {
80   static GPBDescriptor *descriptor = nil;
81   if (!descriptor) {
82     static GPBMessageFieldDescription fields[] = {
83       {
84         .name = "name",
85         .dataTypeSpecific.className = NULL,
86         .number = GPBApi_FieldNumber_Name,
87         .hasIndex = 0,
88         .offset = (uint32_t)offsetof(GPBApi__storage_, name),
89         .flags = GPBFieldOptional,
90         .dataType = GPBDataTypeString,
91       },
92       {
93         .name = "methodsArray",
94         .dataTypeSpecific.className = GPBStringifySymbol(GPBMethod),
95         .number = GPBApi_FieldNumber_MethodsArray,
96         .hasIndex = GPBNoHasBit,
97         .offset = (uint32_t)offsetof(GPBApi__storage_, methodsArray),
98         .flags = GPBFieldRepeated,
99         .dataType = GPBDataTypeMessage,
100       },
101       {
102         .name = "optionsArray",
103         .dataTypeSpecific.className = GPBStringifySymbol(GPBOption),
104         .number = GPBApi_FieldNumber_OptionsArray,
105         .hasIndex = GPBNoHasBit,
106         .offset = (uint32_t)offsetof(GPBApi__storage_, optionsArray),
107         .flags = GPBFieldRepeated,
108         .dataType = GPBDataTypeMessage,
109       },
110       {
111         .name = "version",
112         .dataTypeSpecific.className = NULL,
113         .number = GPBApi_FieldNumber_Version,
114         .hasIndex = 1,
115         .offset = (uint32_t)offsetof(GPBApi__storage_, version),
116         .flags = GPBFieldOptional,
117         .dataType = GPBDataTypeString,
118       },
119       {
120         .name = "sourceContext",
121         .dataTypeSpecific.className = GPBStringifySymbol(GPBSourceContext),
122         .number = GPBApi_FieldNumber_SourceContext,
123         .hasIndex = 2,
124         .offset = (uint32_t)offsetof(GPBApi__storage_, sourceContext),
125         .flags = GPBFieldOptional,
126         .dataType = GPBDataTypeMessage,
127       },
128       {
129         .name = "mixinsArray",
130         .dataTypeSpecific.className = GPBStringifySymbol(GPBMixin),
131         .number = GPBApi_FieldNumber_MixinsArray,
132         .hasIndex = GPBNoHasBit,
133         .offset = (uint32_t)offsetof(GPBApi__storage_, mixinsArray),
134         .flags = GPBFieldRepeated,
135         .dataType = GPBDataTypeMessage,
136       },
137       {
138         .name = "syntax",
139         .dataTypeSpecific.enumDescFunc = GPBSyntax_EnumDescriptor,
140         .number = GPBApi_FieldNumber_Syntax,
141         .hasIndex = 3,
142         .offset = (uint32_t)offsetof(GPBApi__storage_, syntax),
143         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
144         .dataType = GPBDataTypeEnum,
145       },
146     };
147     GPBDescriptor *localDescriptor =
148         [GPBDescriptor allocDescriptorForClass:[GPBApi class]
149                                      rootClass:[GPBApiRoot class]
150                                           file:GPBApiRoot_FileDescriptor()
151                                         fields:fields
152                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
153                                    storageSize:sizeof(GPBApi__storage_)
154                                          flags:GPBDescriptorInitializationFlag_None];
155     NSAssert(descriptor == nil, @"Startup recursed!");
156     descriptor = localDescriptor;
157   }
158   return descriptor;
159 }
160
161 @end
162
163 int32_t GPBApi_Syntax_RawValue(GPBApi *message) {
164   GPBDescriptor *descriptor = [GPBApi descriptor];
165   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBApi_FieldNumber_Syntax];
166   return GPBGetMessageInt32Field(message, field);
167 }
168
169 void SetGPBApi_Syntax_RawValue(GPBApi *message, int32_t value) {
170   GPBDescriptor *descriptor = [GPBApi descriptor];
171   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBApi_FieldNumber_Syntax];
172   GPBSetInt32IvarWithFieldInternal(message, field, value, descriptor.file.syntax);
173 }
174
175 #pragma mark - GPBMethod
176
177 @implementation GPBMethod
178
179 @dynamic name;
180 @dynamic requestTypeURL;
181 @dynamic requestStreaming;
182 @dynamic responseTypeURL;
183 @dynamic responseStreaming;
184 @dynamic optionsArray, optionsArray_Count;
185 @dynamic syntax;
186
187 typedef struct GPBMethod__storage_ {
188   uint32_t _has_storage_[1];
189   GPBSyntax syntax;
190   NSString *name;
191   NSString *requestTypeURL;
192   NSString *responseTypeURL;
193   NSMutableArray *optionsArray;
194 } GPBMethod__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 = "name",
204         .dataTypeSpecific.className = NULL,
205         .number = GPBMethod_FieldNumber_Name,
206         .hasIndex = 0,
207         .offset = (uint32_t)offsetof(GPBMethod__storage_, name),
208         .flags = GPBFieldOptional,
209         .dataType = GPBDataTypeString,
210       },
211       {
212         .name = "requestTypeURL",
213         .dataTypeSpecific.className = NULL,
214         .number = GPBMethod_FieldNumber_RequestTypeURL,
215         .hasIndex = 1,
216         .offset = (uint32_t)offsetof(GPBMethod__storage_, requestTypeURL),
217         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
218         .dataType = GPBDataTypeString,
219       },
220       {
221         .name = "requestStreaming",
222         .dataTypeSpecific.className = NULL,
223         .number = GPBMethod_FieldNumber_RequestStreaming,
224         .hasIndex = 2,
225         .offset = 3,  // Stored in _has_storage_ to save space.
226         .flags = GPBFieldOptional,
227         .dataType = GPBDataTypeBool,
228       },
229       {
230         .name = "responseTypeURL",
231         .dataTypeSpecific.className = NULL,
232         .number = GPBMethod_FieldNumber_ResponseTypeURL,
233         .hasIndex = 4,
234         .offset = (uint32_t)offsetof(GPBMethod__storage_, responseTypeURL),
235         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldTextFormatNameCustom),
236         .dataType = GPBDataTypeString,
237       },
238       {
239         .name = "responseStreaming",
240         .dataTypeSpecific.className = NULL,
241         .number = GPBMethod_FieldNumber_ResponseStreaming,
242         .hasIndex = 5,
243         .offset = 6,  // Stored in _has_storage_ to save space.
244         .flags = GPBFieldOptional,
245         .dataType = GPBDataTypeBool,
246       },
247       {
248         .name = "optionsArray",
249         .dataTypeSpecific.className = GPBStringifySymbol(GPBOption),
250         .number = GPBMethod_FieldNumber_OptionsArray,
251         .hasIndex = GPBNoHasBit,
252         .offset = (uint32_t)offsetof(GPBMethod__storage_, optionsArray),
253         .flags = GPBFieldRepeated,
254         .dataType = GPBDataTypeMessage,
255       },
256       {
257         .name = "syntax",
258         .dataTypeSpecific.enumDescFunc = GPBSyntax_EnumDescriptor,
259         .number = GPBMethod_FieldNumber_Syntax,
260         .hasIndex = 7,
261         .offset = (uint32_t)offsetof(GPBMethod__storage_, syntax),
262         .flags = (GPBFieldFlags)(GPBFieldOptional | GPBFieldHasEnumDescriptor),
263         .dataType = GPBDataTypeEnum,
264       },
265     };
266     GPBDescriptor *localDescriptor =
267         [GPBDescriptor allocDescriptorForClass:[GPBMethod class]
268                                      rootClass:[GPBApiRoot class]
269                                           file:GPBApiRoot_FileDescriptor()
270                                         fields:fields
271                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
272                                    storageSize:sizeof(GPBMethod__storage_)
273                                          flags:GPBDescriptorInitializationFlag_None];
274 #if !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
275     static const char *extraTextFormatInfo =
276         "\002\002\007\244\241!!\000\004\010\244\241!!\000";
277     [localDescriptor setupExtraTextInfo:extraTextFormatInfo];
278 #endif  // !GPBOBJC_SKIP_MESSAGE_TEXTFORMAT_EXTRAS
279     NSAssert(descriptor == nil, @"Startup recursed!");
280     descriptor = localDescriptor;
281   }
282   return descriptor;
283 }
284
285 @end
286
287 int32_t GPBMethod_Syntax_RawValue(GPBMethod *message) {
288   GPBDescriptor *descriptor = [GPBMethod descriptor];
289   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBMethod_FieldNumber_Syntax];
290   return GPBGetMessageInt32Field(message, field);
291 }
292
293 void SetGPBMethod_Syntax_RawValue(GPBMethod *message, int32_t value) {
294   GPBDescriptor *descriptor = [GPBMethod descriptor];
295   GPBFieldDescriptor *field = [descriptor fieldWithNumber:GPBMethod_FieldNumber_Syntax];
296   GPBSetInt32IvarWithFieldInternal(message, field, value, descriptor.file.syntax);
297 }
298
299 #pragma mark - GPBMixin
300
301 @implementation GPBMixin
302
303 @dynamic name;
304 @dynamic root;
305
306 typedef struct GPBMixin__storage_ {
307   uint32_t _has_storage_[1];
308   NSString *name;
309   NSString *root;
310 } GPBMixin__storage_;
311
312 // This method is threadsafe because it is initially called
313 // in +initialize for each subclass.
314 + (GPBDescriptor *)descriptor {
315   static GPBDescriptor *descriptor = nil;
316   if (!descriptor) {
317     static GPBMessageFieldDescription fields[] = {
318       {
319         .name = "name",
320         .dataTypeSpecific.className = NULL,
321         .number = GPBMixin_FieldNumber_Name,
322         .hasIndex = 0,
323         .offset = (uint32_t)offsetof(GPBMixin__storage_, name),
324         .flags = GPBFieldOptional,
325         .dataType = GPBDataTypeString,
326       },
327       {
328         .name = "root",
329         .dataTypeSpecific.className = NULL,
330         .number = GPBMixin_FieldNumber_Root,
331         .hasIndex = 1,
332         .offset = (uint32_t)offsetof(GPBMixin__storage_, root),
333         .flags = GPBFieldOptional,
334         .dataType = GPBDataTypeString,
335       },
336     };
337     GPBDescriptor *localDescriptor =
338         [GPBDescriptor allocDescriptorForClass:[GPBMixin class]
339                                      rootClass:[GPBApiRoot class]
340                                           file:GPBApiRoot_FileDescriptor()
341                                         fields:fields
342                                     fieldCount:(uint32_t)(sizeof(fields) / sizeof(GPBMessageFieldDescription))
343                                    storageSize:sizeof(GPBMixin__storage_)
344                                          flags:GPBDescriptorInitializationFlag_None];
345     NSAssert(descriptor == nil, @"Startup recursed!");
346     descriptor = localDescriptor;
347   }
348   return descriptor;
349 }
350
351 @end
352
353
354 #pragma clang diagnostic pop
355
356 // @@protoc_insertion_point(global_scope)