← Back to branch summary

~suaweb/nginx/nginx-recipe

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/protobuf/src/google/protobuf/descriptor.pb.h

  • Committer: Frans Elliott
  • Date: 2015-06-12 21:15:13 UTC
  • Revision ID: mastergeek.elliott@gmail.com-20150612211513-un4vguj32deibvb0
Added the actual pagespeed library to the ngx_pagespeed module dir.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/protobuf/src/google/protobuf/descriptor.pb.h
 
1
// Generated by the protocol buffer compiler.  DO NOT EDIT!
 
2
// source: google/protobuf/descriptor.proto
 
3
 
 
4
#ifndef PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED
 
5
#define PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED
 
6
 
 
7
#include <string>
 
8
 
 
9
#include <google/protobuf/stubs/common.h>
 
10
 
 
11
#if GOOGLE_PROTOBUF_VERSION < 2005000
 
12
#error This file was generated by a newer version of protoc which is
 
13
#error incompatible with your Protocol Buffer headers.  Please update
 
14
#error your headers.
 
15
#endif
 
16
#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
 
17
#error This file was generated by an older version of protoc which is
 
18
#error incompatible with your Protocol Buffer headers.  Please
 
19
#error regenerate this file with a newer version of protoc.
 
20
#endif
 
21
 
 
22
#include <google/protobuf/generated_message_util.h>
 
23
#include <google/protobuf/message.h>
 
24
#include <google/protobuf/repeated_field.h>
 
25
#include <google/protobuf/extension_set.h>
 
26
#include <google/protobuf/generated_enum_reflection.h>
 
27
#include <google/protobuf/unknown_field_set.h>
 
28
// @@protoc_insertion_point(includes)
 
29
 
 
30
namespace google {
 
31
namespace protobuf {
 
32
 
 
33
// Internal implementation detail -- do not call these.
 
34
void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
35
void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
36
void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
37
 
 
38
class FileDescriptorSet;
 
39
class FileDescriptorProto;
 
40
class DescriptorProto;
 
41
class DescriptorProto_ExtensionRange;
 
42
class FieldDescriptorProto;
 
43
class EnumDescriptorProto;
 
44
class EnumValueDescriptorProto;
 
45
class ServiceDescriptorProto;
 
46
class MethodDescriptorProto;
 
47
class FileOptions;
 
48
class MessageOptions;
 
49
class FieldOptions;
 
50
class EnumOptions;
 
51
class EnumValueOptions;
 
52
class ServiceOptions;
 
53
class MethodOptions;
 
54
class UninterpretedOption;
 
55
class UninterpretedOption_NamePart;
 
56
class SourceCodeInfo;
 
57
class SourceCodeInfo_Location;
 
58
 
 
59
enum FieldDescriptorProto_Type {
 
60
  FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
 
61
  FieldDescriptorProto_Type_TYPE_FLOAT = 2,
 
62
  FieldDescriptorProto_Type_TYPE_INT64 = 3,
 
63
  FieldDescriptorProto_Type_TYPE_UINT64 = 4,
 
64
  FieldDescriptorProto_Type_TYPE_INT32 = 5,
 
65
  FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
 
66
  FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
 
67
  FieldDescriptorProto_Type_TYPE_BOOL = 8,
 
68
  FieldDescriptorProto_Type_TYPE_STRING = 9,
 
69
  FieldDescriptorProto_Type_TYPE_GROUP = 10,
 
70
  FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
 
71
  FieldDescriptorProto_Type_TYPE_BYTES = 12,
 
72
  FieldDescriptorProto_Type_TYPE_UINT32 = 13,
 
73
  FieldDescriptorProto_Type_TYPE_ENUM = 14,
 
74
  FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
 
75
  FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
 
76
  FieldDescriptorProto_Type_TYPE_SINT32 = 17,
 
77
  FieldDescriptorProto_Type_TYPE_SINT64 = 18
 
78
};
 
79
LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value);
 
80
const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE;
 
81
const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64;
 
82
const int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1;
 
83
 
 
84
LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor();
 
85
inline const ::std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) {
 
86
  return ::google::protobuf::internal::NameOfEnum(
 
87
    FieldDescriptorProto_Type_descriptor(), value);
 
88
}
 
89
inline bool FieldDescriptorProto_Type_Parse(
 
90
    const ::std::string& name, FieldDescriptorProto_Type* value) {
 
91
  return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
 
92
    FieldDescriptorProto_Type_descriptor(), name, value);
 
93
}
 
94
enum FieldDescriptorProto_Label {
 
95
  FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
 
96
  FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
 
97
  FieldDescriptorProto_Label_LABEL_REPEATED = 3
 
98
};
 
99
LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value);
 
100
const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL;
 
101
const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED;
 
102
const int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1;
 
103
 
 
104
LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor();
 
105
inline const ::std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) {
 
106
  return ::google::protobuf::internal::NameOfEnum(
 
107
    FieldDescriptorProto_Label_descriptor(), value);
 
108
}
 
109
inline bool FieldDescriptorProto_Label_Parse(
 
110
    const ::std::string& name, FieldDescriptorProto_Label* value) {
 
111
  return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
 
112
    FieldDescriptorProto_Label_descriptor(), name, value);
 
113
}
 
114
enum FileOptions_OptimizeMode {
 
115
  FileOptions_OptimizeMode_SPEED = 1,
 
116
  FileOptions_OptimizeMode_CODE_SIZE = 2,
 
117
  FileOptions_OptimizeMode_LITE_RUNTIME = 3
 
118
};
 
119
LIBPROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value);
 
120
const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED;
 
121
const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME;
 
122
const int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1;
 
123
 
 
124
LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor();
 
125
inline const ::std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) {
 
126
  return ::google::protobuf::internal::NameOfEnum(
 
127
    FileOptions_OptimizeMode_descriptor(), value);
 
128
}
 
129
inline bool FileOptions_OptimizeMode_Parse(
 
130
    const ::std::string& name, FileOptions_OptimizeMode* value) {
 
131
  return ::google::protobuf::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
 
132
    FileOptions_OptimizeMode_descriptor(), name, value);
 
133
}
 
134
enum FieldOptions_CType {
 
135
  FieldOptions_CType_STRING = 0,
 
136
  FieldOptions_CType_CORD = 1,
 
137
  FieldOptions_CType_STRING_PIECE = 2
 
138
};
 
139
LIBPROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value);
 
140
const FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING;
 
141
const FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE;
 
142
const int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1;
 
143
 
 
144
LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor();
 
145
inline const ::std::string& FieldOptions_CType_Name(FieldOptions_CType value) {
 
146
  return ::google::protobuf::internal::NameOfEnum(
 
147
    FieldOptions_CType_descriptor(), value);
 
148
}
 
149
inline bool FieldOptions_CType_Parse(
 
150
    const ::std::string& name, FieldOptions_CType* value) {
 
151
  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_CType>(
 
152
    FieldOptions_CType_descriptor(), name, value);
 
153
}
 
154
// ===================================================================
 
155
 
 
156
class LIBPROTOBUF_EXPORT FileDescriptorSet : public ::google::protobuf::Message {
 
157
 public:
 
158
  FileDescriptorSet();
 
159
  virtual ~FileDescriptorSet();
 
160
 
 
161
  FileDescriptorSet(const FileDescriptorSet& from);
 
162
 
 
163
  inline FileDescriptorSet& operator=(const FileDescriptorSet& from) {
 
164
    CopyFrom(from);
 
165
    return *this;
 
166
  }
 
167
 
 
168
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
169
    return _unknown_fields_;
 
170
  }
 
171
 
 
172
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
173
    return &_unknown_fields_;
 
174
  }
 
175
 
 
176
  static const ::google::protobuf::Descriptor* descriptor();
 
177
  static const FileDescriptorSet& default_instance();
 
178
 
 
179
  void Swap(FileDescriptorSet* other);
 
180
 
 
181
  // implements Message ----------------------------------------------
 
182
 
 
183
  FileDescriptorSet* New() const;
 
184
  void CopyFrom(const ::google::protobuf::Message& from);
 
185
  void MergeFrom(const ::google::protobuf::Message& from);
 
186
  void CopyFrom(const FileDescriptorSet& from);
 
187
  void MergeFrom(const FileDescriptorSet& from);
 
188
  void Clear();
 
189
  bool IsInitialized() const;
 
190
 
 
191
  int ByteSize() const;
 
192
  bool MergePartialFromCodedStream(
 
193
      ::google::protobuf::io::CodedInputStream* input);
 
194
  void SerializeWithCachedSizes(
 
195
      ::google::protobuf::io::CodedOutputStream* output) const;
 
196
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
197
  int GetCachedSize() const { return _cached_size_; }
 
198
  private:
 
199
  void SharedCtor();
 
200
  void SharedDtor();
 
201
  void SetCachedSize(int size) const;
 
202
  public:
 
203
 
 
204
  ::google::protobuf::Metadata GetMetadata() const;
 
205
 
 
206
  // nested types ----------------------------------------------------
 
207
 
 
208
  // accessors -------------------------------------------------------
 
209
 
 
210
  // repeated .google.protobuf.FileDescriptorProto file = 1;
 
211
  inline int file_size() const;
 
212
  inline void clear_file();
 
213
  static const int kFileFieldNumber = 1;
 
214
  inline const ::google::protobuf::FileDescriptorProto& file(int index) const;
 
215
  inline ::google::protobuf::FileDescriptorProto* mutable_file(int index);
 
216
  inline ::google::protobuf::FileDescriptorProto* add_file();
 
217
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
 
218
      file() const;
 
219
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
 
220
      mutable_file();
 
221
 
 
222
  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet)
 
223
 private:
 
224
 
 
225
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
226
 
 
227
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > file_;
 
228
 
 
229
  mutable int _cached_size_;
 
230
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 
231
 
 
232
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
233
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
234
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
235
 
 
236
  void InitAsDefaultInstance();
 
237
  static FileDescriptorSet* default_instance_;
 
238
};
 
239
// -------------------------------------------------------------------
 
240
 
 
241
class LIBPROTOBUF_EXPORT FileDescriptorProto : public ::google::protobuf::Message {
 
242
 public:
 
243
  FileDescriptorProto();
 
244
  virtual ~FileDescriptorProto();
 
245
 
 
246
  FileDescriptorProto(const FileDescriptorProto& from);
 
247
 
 
248
  inline FileDescriptorProto& operator=(const FileDescriptorProto& from) {
 
249
    CopyFrom(from);
 
250
    return *this;
 
251
  }
 
252
 
 
253
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
254
    return _unknown_fields_;
 
255
  }
 
256
 
 
257
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
258
    return &_unknown_fields_;
 
259
  }
 
260
 
 
261
  static const ::google::protobuf::Descriptor* descriptor();
 
262
  static const FileDescriptorProto& default_instance();
 
263
 
 
264
  void Swap(FileDescriptorProto* other);
 
265
 
 
266
  // implements Message ----------------------------------------------
 
267
 
 
268
  FileDescriptorProto* New() const;
 
269
  void CopyFrom(const ::google::protobuf::Message& from);
 
270
  void MergeFrom(const ::google::protobuf::Message& from);
 
271
  void CopyFrom(const FileDescriptorProto& from);
 
272
  void MergeFrom(const FileDescriptorProto& from);
 
273
  void Clear();
 
274
  bool IsInitialized() const;
 
275
 
 
276
  int ByteSize() const;
 
277
  bool MergePartialFromCodedStream(
 
278
      ::google::protobuf::io::CodedInputStream* input);
 
279
  void SerializeWithCachedSizes(
 
280
      ::google::protobuf::io::CodedOutputStream* output) const;
 
281
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
282
  int GetCachedSize() const { return _cached_size_; }
 
283
  private:
 
284
  void SharedCtor();
 
285
  void SharedDtor();
 
286
  void SetCachedSize(int size) const;
 
287
  public:
 
288
 
 
289
  ::google::protobuf::Metadata GetMetadata() const;
 
290
 
 
291
  // nested types ----------------------------------------------------
 
292
 
 
293
  // accessors -------------------------------------------------------
 
294
 
 
295
  // optional string name = 1;
 
296
  inline bool has_name() const;
 
297
  inline void clear_name();
 
298
  static const int kNameFieldNumber = 1;
 
299
  inline const ::std::string& name() const;
 
300
  inline void set_name(const ::std::string& value);
 
301
  inline void set_name(const char* value);
 
302
  inline void set_name(const char* value, size_t size);
 
303
  inline ::std::string* mutable_name();
 
304
  inline ::std::string* release_name();
 
305
  inline void set_allocated_name(::std::string* name);
 
306
 
 
307
  // optional string package = 2;
 
308
  inline bool has_package() const;
 
309
  inline void clear_package();
 
310
  static const int kPackageFieldNumber = 2;
 
311
  inline const ::std::string& package() const;
 
312
  inline void set_package(const ::std::string& value);
 
313
  inline void set_package(const char* value);
 
314
  inline void set_package(const char* value, size_t size);
 
315
  inline ::std::string* mutable_package();
 
316
  inline ::std::string* release_package();
 
317
  inline void set_allocated_package(::std::string* package);
 
318
 
 
319
  // repeated string dependency = 3;
 
320
  inline int dependency_size() const;
 
321
  inline void clear_dependency();
 
322
  static const int kDependencyFieldNumber = 3;
 
323
  inline const ::std::string& dependency(int index) const;
 
324
  inline ::std::string* mutable_dependency(int index);
 
325
  inline void set_dependency(int index, const ::std::string& value);
 
326
  inline void set_dependency(int index, const char* value);
 
327
  inline void set_dependency(int index, const char* value, size_t size);
 
328
  inline ::std::string* add_dependency();
 
329
  inline void add_dependency(const ::std::string& value);
 
330
  inline void add_dependency(const char* value);
 
331
  inline void add_dependency(const char* value, size_t size);
 
332
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& dependency() const;
 
333
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_dependency();
 
334
 
 
335
  // repeated int32 public_dependency = 10;
 
336
  inline int public_dependency_size() const;
 
337
  inline void clear_public_dependency();
 
338
  static const int kPublicDependencyFieldNumber = 10;
 
339
  inline ::google::protobuf::int32 public_dependency(int index) const;
 
340
  inline void set_public_dependency(int index, ::google::protobuf::int32 value);
 
341
  inline void add_public_dependency(::google::protobuf::int32 value);
 
342
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
343
      public_dependency() const;
 
344
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
345
      mutable_public_dependency();
 
346
 
 
347
  // repeated int32 weak_dependency = 11;
 
348
  inline int weak_dependency_size() const;
 
349
  inline void clear_weak_dependency();
 
350
  static const int kWeakDependencyFieldNumber = 11;
 
351
  inline ::google::protobuf::int32 weak_dependency(int index) const;
 
352
  inline void set_weak_dependency(int index, ::google::protobuf::int32 value);
 
353
  inline void add_weak_dependency(::google::protobuf::int32 value);
 
354
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
355
      weak_dependency() const;
 
356
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
357
      mutable_weak_dependency();
 
358
 
 
359
  // repeated .google.protobuf.DescriptorProto message_type = 4;
 
360
  inline int message_type_size() const;
 
361
  inline void clear_message_type();
 
362
  static const int kMessageTypeFieldNumber = 4;
 
363
  inline const ::google::protobuf::DescriptorProto& message_type(int index) const;
 
364
  inline ::google::protobuf::DescriptorProto* mutable_message_type(int index);
 
365
  inline ::google::protobuf::DescriptorProto* add_message_type();
 
366
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
 
367
      message_type() const;
 
368
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
 
369
      mutable_message_type();
 
370
 
 
371
  // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
 
372
  inline int enum_type_size() const;
 
373
  inline void clear_enum_type();
 
374
  static const int kEnumTypeFieldNumber = 5;
 
375
  inline const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const;
 
376
  inline ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index);
 
377
  inline ::google::protobuf::EnumDescriptorProto* add_enum_type();
 
378
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
 
379
      enum_type() const;
 
380
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
 
381
      mutable_enum_type();
 
382
 
 
383
  // repeated .google.protobuf.ServiceDescriptorProto service = 6;
 
384
  inline int service_size() const;
 
385
  inline void clear_service();
 
386
  static const int kServiceFieldNumber = 6;
 
387
  inline const ::google::protobuf::ServiceDescriptorProto& service(int index) const;
 
388
  inline ::google::protobuf::ServiceDescriptorProto* mutable_service(int index);
 
389
  inline ::google::protobuf::ServiceDescriptorProto* add_service();
 
390
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >&
 
391
      service() const;
 
392
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >*
 
393
      mutable_service();
 
394
 
 
395
  // repeated .google.protobuf.FieldDescriptorProto extension = 7;
 
396
  inline int extension_size() const;
 
397
  inline void clear_extension();
 
398
  static const int kExtensionFieldNumber = 7;
 
399
  inline const ::google::protobuf::FieldDescriptorProto& extension(int index) const;
 
400
  inline ::google::protobuf::FieldDescriptorProto* mutable_extension(int index);
 
401
  inline ::google::protobuf::FieldDescriptorProto* add_extension();
 
402
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
 
403
      extension() const;
 
404
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
 
405
      mutable_extension();
 
406
 
 
407
  // optional .google.protobuf.FileOptions options = 8;
 
408
  inline bool has_options() const;
 
409
  inline void clear_options();
 
410
  static const int kOptionsFieldNumber = 8;
 
411
  inline const ::google::protobuf::FileOptions& options() const;
 
412
  inline ::google::protobuf::FileOptions* mutable_options();
 
413
  inline ::google::protobuf::FileOptions* release_options();
 
414
  inline void set_allocated_options(::google::protobuf::FileOptions* options);
 
415
 
 
416
  // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
 
417
  inline bool has_source_code_info() const;
 
418
  inline void clear_source_code_info();
 
419
  static const int kSourceCodeInfoFieldNumber = 9;
 
420
  inline const ::google::protobuf::SourceCodeInfo& source_code_info() const;
 
421
  inline ::google::protobuf::SourceCodeInfo* mutable_source_code_info();
 
422
  inline ::google::protobuf::SourceCodeInfo* release_source_code_info();
 
423
  inline void set_allocated_source_code_info(::google::protobuf::SourceCodeInfo* source_code_info);
 
424
 
 
425
  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto)
 
426
 private:
 
427
  inline void set_has_name();
 
428
  inline void clear_has_name();
 
429
  inline void set_has_package();
 
430
  inline void clear_has_package();
 
431
  inline void set_has_options();
 
432
  inline void clear_has_options();
 
433
  inline void set_has_source_code_info();
 
434
  inline void clear_has_source_code_info();
 
435
 
 
436
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
437
 
 
438
  ::std::string* name_;
 
439
  ::std::string* package_;
 
440
  ::google::protobuf::RepeatedPtrField< ::std::string> dependency_;
 
441
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > public_dependency_;
 
442
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > weak_dependency_;
 
443
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > message_type_;
 
444
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_;
 
445
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto > service_;
 
446
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_;
 
447
  ::google::protobuf::FileOptions* options_;
 
448
  ::google::protobuf::SourceCodeInfo* source_code_info_;
 
449
 
 
450
  mutable int _cached_size_;
 
451
  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];
 
452
 
 
453
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
454
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
455
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
456
 
 
457
  void InitAsDefaultInstance();
 
458
  static FileDescriptorProto* default_instance_;
 
459
};
 
460
// -------------------------------------------------------------------
 
461
 
 
462
class LIBPROTOBUF_EXPORT DescriptorProto_ExtensionRange : public ::google::protobuf::Message {
 
463
 public:
 
464
  DescriptorProto_ExtensionRange();
 
465
  virtual ~DescriptorProto_ExtensionRange();
 
466
 
 
467
  DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from);
 
468
 
 
469
  inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) {
 
470
    CopyFrom(from);
 
471
    return *this;
 
472
  }
 
473
 
 
474
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
475
    return _unknown_fields_;
 
476
  }
 
477
 
 
478
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
479
    return &_unknown_fields_;
 
480
  }
 
481
 
 
482
  static const ::google::protobuf::Descriptor* descriptor();
 
483
  static const DescriptorProto_ExtensionRange& default_instance();
 
484
 
 
485
  void Swap(DescriptorProto_ExtensionRange* other);
 
486
 
 
487
  // implements Message ----------------------------------------------
 
488
 
 
489
  DescriptorProto_ExtensionRange* New() const;
 
490
  void CopyFrom(const ::google::protobuf::Message& from);
 
491
  void MergeFrom(const ::google::protobuf::Message& from);
 
492
  void CopyFrom(const DescriptorProto_ExtensionRange& from);
 
493
  void MergeFrom(const DescriptorProto_ExtensionRange& from);
 
494
  void Clear();
 
495
  bool IsInitialized() const;
 
496
 
 
497
  int ByteSize() const;
 
498
  bool MergePartialFromCodedStream(
 
499
      ::google::protobuf::io::CodedInputStream* input);
 
500
  void SerializeWithCachedSizes(
 
501
      ::google::protobuf::io::CodedOutputStream* output) const;
 
502
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
503
  int GetCachedSize() const { return _cached_size_; }
 
504
  private:
 
505
  void SharedCtor();
 
506
  void SharedDtor();
 
507
  void SetCachedSize(int size) const;
 
508
  public:
 
509
 
 
510
  ::google::protobuf::Metadata GetMetadata() const;
 
511
 
 
512
  // nested types ----------------------------------------------------
 
513
 
 
514
  // accessors -------------------------------------------------------
 
515
 
 
516
  // optional int32 start = 1;
 
517
  inline bool has_start() const;
 
518
  inline void clear_start();
 
519
  static const int kStartFieldNumber = 1;
 
520
  inline ::google::protobuf::int32 start() const;
 
521
  inline void set_start(::google::protobuf::int32 value);
 
522
 
 
523
  // optional int32 end = 2;
 
524
  inline bool has_end() const;
 
525
  inline void clear_end();
 
526
  static const int kEndFieldNumber = 2;
 
527
  inline ::google::protobuf::int32 end() const;
 
528
  inline void set_end(::google::protobuf::int32 value);
 
529
 
 
530
  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange)
 
531
 private:
 
532
  inline void set_has_start();
 
533
  inline void clear_has_start();
 
534
  inline void set_has_end();
 
535
  inline void clear_has_end();
 
536
 
 
537
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
538
 
 
539
  ::google::protobuf::int32 start_;
 
540
  ::google::protobuf::int32 end_;
 
541
 
 
542
  mutable int _cached_size_;
 
543
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
 
544
 
 
545
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
546
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
547
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
548
 
 
549
  void InitAsDefaultInstance();
 
550
  static DescriptorProto_ExtensionRange* default_instance_;
 
551
};
 
552
// -------------------------------------------------------------------
 
553
 
 
554
class LIBPROTOBUF_EXPORT DescriptorProto : public ::google::protobuf::Message {
 
555
 public:
 
556
  DescriptorProto();
 
557
  virtual ~DescriptorProto();
 
558
 
 
559
  DescriptorProto(const DescriptorProto& from);
 
560
 
 
561
  inline DescriptorProto& operator=(const DescriptorProto& from) {
 
562
    CopyFrom(from);
 
563
    return *this;
 
564
  }
 
565
 
 
566
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
567
    return _unknown_fields_;
 
568
  }
 
569
 
 
570
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
571
    return &_unknown_fields_;
 
572
  }
 
573
 
 
574
  static const ::google::protobuf::Descriptor* descriptor();
 
575
  static const DescriptorProto& default_instance();
 
576
 
 
577
  void Swap(DescriptorProto* other);
 
578
 
 
579
  // implements Message ----------------------------------------------
 
580
 
 
581
  DescriptorProto* New() const;
 
582
  void CopyFrom(const ::google::protobuf::Message& from);
 
583
  void MergeFrom(const ::google::protobuf::Message& from);
 
584
  void CopyFrom(const DescriptorProto& from);
 
585
  void MergeFrom(const DescriptorProto& from);
 
586
  void Clear();
 
587
  bool IsInitialized() const;
 
588
 
 
589
  int ByteSize() const;
 
590
  bool MergePartialFromCodedStream(
 
591
      ::google::protobuf::io::CodedInputStream* input);
 
592
  void SerializeWithCachedSizes(
 
593
      ::google::protobuf::io::CodedOutputStream* output) const;
 
594
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
595
  int GetCachedSize() const { return _cached_size_; }
 
596
  private:
 
597
  void SharedCtor();
 
598
  void SharedDtor();
 
599
  void SetCachedSize(int size) const;
 
600
  public:
 
601
 
 
602
  ::google::protobuf::Metadata GetMetadata() const;
 
603
 
 
604
  // nested types ----------------------------------------------------
 
605
 
 
606
  typedef DescriptorProto_ExtensionRange ExtensionRange;
 
607
 
 
608
  // accessors -------------------------------------------------------
 
609
 
 
610
  // optional string name = 1;
 
611
  inline bool has_name() const;
 
612
  inline void clear_name();
 
613
  static const int kNameFieldNumber = 1;
 
614
  inline const ::std::string& name() const;
 
615
  inline void set_name(const ::std::string& value);
 
616
  inline void set_name(const char* value);
 
617
  inline void set_name(const char* value, size_t size);
 
618
  inline ::std::string* mutable_name();
 
619
  inline ::std::string* release_name();
 
620
  inline void set_allocated_name(::std::string* name);
 
621
 
 
622
  // repeated .google.protobuf.FieldDescriptorProto field = 2;
 
623
  inline int field_size() const;
 
624
  inline void clear_field();
 
625
  static const int kFieldFieldNumber = 2;
 
626
  inline const ::google::protobuf::FieldDescriptorProto& field(int index) const;
 
627
  inline ::google::protobuf::FieldDescriptorProto* mutable_field(int index);
 
628
  inline ::google::protobuf::FieldDescriptorProto* add_field();
 
629
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
 
630
      field() const;
 
631
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
 
632
      mutable_field();
 
633
 
 
634
  // repeated .google.protobuf.FieldDescriptorProto extension = 6;
 
635
  inline int extension_size() const;
 
636
  inline void clear_extension();
 
637
  static const int kExtensionFieldNumber = 6;
 
638
  inline const ::google::protobuf::FieldDescriptorProto& extension(int index) const;
 
639
  inline ::google::protobuf::FieldDescriptorProto* mutable_extension(int index);
 
640
  inline ::google::protobuf::FieldDescriptorProto* add_extension();
 
641
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
 
642
      extension() const;
 
643
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
 
644
      mutable_extension();
 
645
 
 
646
  // repeated .google.protobuf.DescriptorProto nested_type = 3;
 
647
  inline int nested_type_size() const;
 
648
  inline void clear_nested_type();
 
649
  static const int kNestedTypeFieldNumber = 3;
 
650
  inline const ::google::protobuf::DescriptorProto& nested_type(int index) const;
 
651
  inline ::google::protobuf::DescriptorProto* mutable_nested_type(int index);
 
652
  inline ::google::protobuf::DescriptorProto* add_nested_type();
 
653
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
 
654
      nested_type() const;
 
655
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
 
656
      mutable_nested_type();
 
657
 
 
658
  // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
 
659
  inline int enum_type_size() const;
 
660
  inline void clear_enum_type();
 
661
  static const int kEnumTypeFieldNumber = 4;
 
662
  inline const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const;
 
663
  inline ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index);
 
664
  inline ::google::protobuf::EnumDescriptorProto* add_enum_type();
 
665
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
 
666
      enum_type() const;
 
667
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
 
668
      mutable_enum_type();
 
669
 
 
670
  // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
 
671
  inline int extension_range_size() const;
 
672
  inline void clear_extension_range();
 
673
  static const int kExtensionRangeFieldNumber = 5;
 
674
  inline const ::google::protobuf::DescriptorProto_ExtensionRange& extension_range(int index) const;
 
675
  inline ::google::protobuf::DescriptorProto_ExtensionRange* mutable_extension_range(int index);
 
676
  inline ::google::protobuf::DescriptorProto_ExtensionRange* add_extension_range();
 
677
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >&
 
678
      extension_range() const;
 
679
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >*
 
680
      mutable_extension_range();
 
681
 
 
682
  // optional .google.protobuf.MessageOptions options = 7;
 
683
  inline bool has_options() const;
 
684
  inline void clear_options();
 
685
  static const int kOptionsFieldNumber = 7;
 
686
  inline const ::google::protobuf::MessageOptions& options() const;
 
687
  inline ::google::protobuf::MessageOptions* mutable_options();
 
688
  inline ::google::protobuf::MessageOptions* release_options();
 
689
  inline void set_allocated_options(::google::protobuf::MessageOptions* options);
 
690
 
 
691
  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto)
 
692
 private:
 
693
  inline void set_has_name();
 
694
  inline void clear_has_name();
 
695
  inline void set_has_options();
 
696
  inline void clear_has_options();
 
697
 
 
698
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
699
 
 
700
  ::std::string* name_;
 
701
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > field_;
 
702
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_;
 
703
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > nested_type_;
 
704
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_;
 
705
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange > extension_range_;
 
706
  ::google::protobuf::MessageOptions* options_;
 
707
 
 
708
  mutable int _cached_size_;
 
709
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
 
710
 
 
711
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
712
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
713
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
714
 
 
715
  void InitAsDefaultInstance();
 
716
  static DescriptorProto* default_instance_;
 
717
};
 
718
// -------------------------------------------------------------------
 
719
 
 
720
class LIBPROTOBUF_EXPORT FieldDescriptorProto : public ::google::protobuf::Message {
 
721
 public:
 
722
  FieldDescriptorProto();
 
723
  virtual ~FieldDescriptorProto();
 
724
 
 
725
  FieldDescriptorProto(const FieldDescriptorProto& from);
 
726
 
 
727
  inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) {
 
728
    CopyFrom(from);
 
729
    return *this;
 
730
  }
 
731
 
 
732
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
733
    return _unknown_fields_;
 
734
  }
 
735
 
 
736
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
737
    return &_unknown_fields_;
 
738
  }
 
739
 
 
740
  static const ::google::protobuf::Descriptor* descriptor();
 
741
  static const FieldDescriptorProto& default_instance();
 
742
 
 
743
  void Swap(FieldDescriptorProto* other);
 
744
 
 
745
  // implements Message ----------------------------------------------
 
746
 
 
747
  FieldDescriptorProto* New() const;
 
748
  void CopyFrom(const ::google::protobuf::Message& from);
 
749
  void MergeFrom(const ::google::protobuf::Message& from);
 
750
  void CopyFrom(const FieldDescriptorProto& from);
 
751
  void MergeFrom(const FieldDescriptorProto& from);
 
752
  void Clear();
 
753
  bool IsInitialized() const;
 
754
 
 
755
  int ByteSize() const;
 
756
  bool MergePartialFromCodedStream(
 
757
      ::google::protobuf::io::CodedInputStream* input);
 
758
  void SerializeWithCachedSizes(
 
759
      ::google::protobuf::io::CodedOutputStream* output) const;
 
760
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
761
  int GetCachedSize() const { return _cached_size_; }
 
762
  private:
 
763
  void SharedCtor();
 
764
  void SharedDtor();
 
765
  void SetCachedSize(int size) const;
 
766
  public:
 
767
 
 
768
  ::google::protobuf::Metadata GetMetadata() const;
 
769
 
 
770
  // nested types ----------------------------------------------------
 
771
 
 
772
  typedef FieldDescriptorProto_Type Type;
 
773
  static const Type TYPE_DOUBLE = FieldDescriptorProto_Type_TYPE_DOUBLE;
 
774
  static const Type TYPE_FLOAT = FieldDescriptorProto_Type_TYPE_FLOAT;
 
775
  static const Type TYPE_INT64 = FieldDescriptorProto_Type_TYPE_INT64;
 
776
  static const Type TYPE_UINT64 = FieldDescriptorProto_Type_TYPE_UINT64;
 
777
  static const Type TYPE_INT32 = FieldDescriptorProto_Type_TYPE_INT32;
 
778
  static const Type TYPE_FIXED64 = FieldDescriptorProto_Type_TYPE_FIXED64;
 
779
  static const Type TYPE_FIXED32 = FieldDescriptorProto_Type_TYPE_FIXED32;
 
780
  static const Type TYPE_BOOL = FieldDescriptorProto_Type_TYPE_BOOL;
 
781
  static const Type TYPE_STRING = FieldDescriptorProto_Type_TYPE_STRING;
 
782
  static const Type TYPE_GROUP = FieldDescriptorProto_Type_TYPE_GROUP;
 
783
  static const Type TYPE_MESSAGE = FieldDescriptorProto_Type_TYPE_MESSAGE;
 
784
  static const Type TYPE_BYTES = FieldDescriptorProto_Type_TYPE_BYTES;
 
785
  static const Type TYPE_UINT32 = FieldDescriptorProto_Type_TYPE_UINT32;
 
786
  static const Type TYPE_ENUM = FieldDescriptorProto_Type_TYPE_ENUM;
 
787
  static const Type TYPE_SFIXED32 = FieldDescriptorProto_Type_TYPE_SFIXED32;
 
788
  static const Type TYPE_SFIXED64 = FieldDescriptorProto_Type_TYPE_SFIXED64;
 
789
  static const Type TYPE_SINT32 = FieldDescriptorProto_Type_TYPE_SINT32;
 
790
  static const Type TYPE_SINT64 = FieldDescriptorProto_Type_TYPE_SINT64;
 
791
  static inline bool Type_IsValid(int value) {
 
792
    return FieldDescriptorProto_Type_IsValid(value);
 
793
  }
 
794
  static const Type Type_MIN =
 
795
    FieldDescriptorProto_Type_Type_MIN;
 
796
  static const Type Type_MAX =
 
797
    FieldDescriptorProto_Type_Type_MAX;
 
798
  static const int Type_ARRAYSIZE =
 
799
    FieldDescriptorProto_Type_Type_ARRAYSIZE;
 
800
  static inline const ::google::protobuf::EnumDescriptor*
 
801
  Type_descriptor() {
 
802
    return FieldDescriptorProto_Type_descriptor();
 
803
  }
 
804
  static inline const ::std::string& Type_Name(Type value) {
 
805
    return FieldDescriptorProto_Type_Name(value);
 
806
  }
 
807
  static inline bool Type_Parse(const ::std::string& name,
 
808
      Type* value) {
 
809
    return FieldDescriptorProto_Type_Parse(name, value);
 
810
  }
 
811
 
 
812
  typedef FieldDescriptorProto_Label Label;
 
813
  static const Label LABEL_OPTIONAL = FieldDescriptorProto_Label_LABEL_OPTIONAL;
 
814
  static const Label LABEL_REQUIRED = FieldDescriptorProto_Label_LABEL_REQUIRED;
 
815
  static const Label LABEL_REPEATED = FieldDescriptorProto_Label_LABEL_REPEATED;
 
816
  static inline bool Label_IsValid(int value) {
 
817
    return FieldDescriptorProto_Label_IsValid(value);
 
818
  }
 
819
  static const Label Label_MIN =
 
820
    FieldDescriptorProto_Label_Label_MIN;
 
821
  static const Label Label_MAX =
 
822
    FieldDescriptorProto_Label_Label_MAX;
 
823
  static const int Label_ARRAYSIZE =
 
824
    FieldDescriptorProto_Label_Label_ARRAYSIZE;
 
825
  static inline const ::google::protobuf::EnumDescriptor*
 
826
  Label_descriptor() {
 
827
    return FieldDescriptorProto_Label_descriptor();
 
828
  }
 
829
  static inline const ::std::string& Label_Name(Label value) {
 
830
    return FieldDescriptorProto_Label_Name(value);
 
831
  }
 
832
  static inline bool Label_Parse(const ::std::string& name,
 
833
      Label* value) {
 
834
    return FieldDescriptorProto_Label_Parse(name, value);
 
835
  }
 
836
 
 
837
  // accessors -------------------------------------------------------
 
838
 
 
839
  // optional string name = 1;
 
840
  inline bool has_name() const;
 
841
  inline void clear_name();
 
842
  static const int kNameFieldNumber = 1;
 
843
  inline const ::std::string& name() const;
 
844
  inline void set_name(const ::std::string& value);
 
845
  inline void set_name(const char* value);
 
846
  inline void set_name(const char* value, size_t size);
 
847
  inline ::std::string* mutable_name();
 
848
  inline ::std::string* release_name();
 
849
  inline void set_allocated_name(::std::string* name);
 
850
 
 
851
  // optional int32 number = 3;
 
852
  inline bool has_number() const;
 
853
  inline void clear_number();
 
854
  static const int kNumberFieldNumber = 3;
 
855
  inline ::google::protobuf::int32 number() const;
 
856
  inline void set_number(::google::protobuf::int32 value);
 
857
 
 
858
  // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
 
859
  inline bool has_label() const;
 
860
  inline void clear_label();
 
861
  static const int kLabelFieldNumber = 4;
 
862
  inline ::google::protobuf::FieldDescriptorProto_Label label() const;
 
863
  inline void set_label(::google::protobuf::FieldDescriptorProto_Label value);
 
864
 
 
865
  // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
 
866
  inline bool has_type() const;
 
867
  inline void clear_type();
 
868
  static const int kTypeFieldNumber = 5;
 
869
  inline ::google::protobuf::FieldDescriptorProto_Type type() const;
 
870
  inline void set_type(::google::protobuf::FieldDescriptorProto_Type value);
 
871
 
 
872
  // optional string type_name = 6;
 
873
  inline bool has_type_name() const;
 
874
  inline void clear_type_name();
 
875
  static const int kTypeNameFieldNumber = 6;
 
876
  inline const ::std::string& type_name() const;
 
877
  inline void set_type_name(const ::std::string& value);
 
878
  inline void set_type_name(const char* value);
 
879
  inline void set_type_name(const char* value, size_t size);
 
880
  inline ::std::string* mutable_type_name();
 
881
  inline ::std::string* release_type_name();
 
882
  inline void set_allocated_type_name(::std::string* type_name);
 
883
 
 
884
  // optional string extendee = 2;
 
885
  inline bool has_extendee() const;
 
886
  inline void clear_extendee();
 
887
  static const int kExtendeeFieldNumber = 2;
 
888
  inline const ::std::string& extendee() const;
 
889
  inline void set_extendee(const ::std::string& value);
 
890
  inline void set_extendee(const char* value);
 
891
  inline void set_extendee(const char* value, size_t size);
 
892
  inline ::std::string* mutable_extendee();
 
893
  inline ::std::string* release_extendee();
 
894
  inline void set_allocated_extendee(::std::string* extendee);
 
895
 
 
896
  // optional string default_value = 7;
 
897
  inline bool has_default_value() const;
 
898
  inline void clear_default_value();
 
899
  static const int kDefaultValueFieldNumber = 7;
 
900
  inline const ::std::string& default_value() const;
 
901
  inline void set_default_value(const ::std::string& value);
 
902
  inline void set_default_value(const char* value);
 
903
  inline void set_default_value(const char* value, size_t size);
 
904
  inline ::std::string* mutable_default_value();
 
905
  inline ::std::string* release_default_value();
 
906
  inline void set_allocated_default_value(::std::string* default_value);
 
907
 
 
908
  // optional .google.protobuf.FieldOptions options = 8;
 
909
  inline bool has_options() const;
 
910
  inline void clear_options();
 
911
  static const int kOptionsFieldNumber = 8;
 
912
  inline const ::google::protobuf::FieldOptions& options() const;
 
913
  inline ::google::protobuf::FieldOptions* mutable_options();
 
914
  inline ::google::protobuf::FieldOptions* release_options();
 
915
  inline void set_allocated_options(::google::protobuf::FieldOptions* options);
 
916
 
 
917
  // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto)
 
918
 private:
 
919
  inline void set_has_name();
 
920
  inline void clear_has_name();
 
921
  inline void set_has_number();
 
922
  inline void clear_has_number();
 
923
  inline void set_has_label();
 
924
  inline void clear_has_label();
 
925
  inline void set_has_type();
 
926
  inline void clear_has_type();
 
927
  inline void set_has_type_name();
 
928
  inline void clear_has_type_name();
 
929
  inline void set_has_extendee();
 
930
  inline void clear_has_extendee();
 
931
  inline void set_has_default_value();
 
932
  inline void clear_has_default_value();
 
933
  inline void set_has_options();
 
934
  inline void clear_has_options();
 
935
 
 
936
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
937
 
 
938
  ::std::string* name_;
 
939
  ::google::protobuf::int32 number_;
 
940
  int label_;
 
941
  ::std::string* type_name_;
 
942
  ::std::string* extendee_;
 
943
  ::std::string* default_value_;
 
944
  ::google::protobuf::FieldOptions* options_;
 
945
  int type_;
 
946
 
 
947
  mutable int _cached_size_;
 
948
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
 
949
 
 
950
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
951
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
952
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
953
 
 
954
  void InitAsDefaultInstance();
 
955
  static FieldDescriptorProto* default_instance_;
 
956
};
 
957
// -------------------------------------------------------------------
 
958
 
 
959
class LIBPROTOBUF_EXPORT EnumDescriptorProto : public ::google::protobuf::Message {
 
960
 public:
 
961
  EnumDescriptorProto();
 
962
  virtual ~EnumDescriptorProto();
 
963
 
 
964
  EnumDescriptorProto(const EnumDescriptorProto& from);
 
965
 
 
966
  inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) {
 
967
    CopyFrom(from);
 
968
    return *this;
 
969
  }
 
970
 
 
971
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
972
    return _unknown_fields_;
 
973
  }
 
974
 
 
975
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
976
    return &_unknown_fields_;
 
977
  }
 
978
 
 
979
  static const ::google::protobuf::Descriptor* descriptor();
 
980
  static const EnumDescriptorProto& default_instance();
 
981
 
 
982
  void Swap(EnumDescriptorProto* other);
 
983
 
 
984
  // implements Message ----------------------------------------------
 
985
 
 
986
  EnumDescriptorProto* New() const;
 
987
  void CopyFrom(const ::google::protobuf::Message& from);
 
988
  void MergeFrom(const ::google::protobuf::Message& from);
 
989
  void CopyFrom(const EnumDescriptorProto& from);
 
990
  void MergeFrom(const EnumDescriptorProto& from);
 
991
  void Clear();
 
992
  bool IsInitialized() const;
 
993
 
 
994
  int ByteSize() const;
 
995
  bool MergePartialFromCodedStream(
 
996
      ::google::protobuf::io::CodedInputStream* input);
 
997
  void SerializeWithCachedSizes(
 
998
      ::google::protobuf::io::CodedOutputStream* output) const;
 
999
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1000
  int GetCachedSize() const { return _cached_size_; }
 
1001
  private:
 
1002
  void SharedCtor();
 
1003
  void SharedDtor();
 
1004
  void SetCachedSize(int size) const;
 
1005
  public:
 
1006
 
 
1007
  ::google::protobuf::Metadata GetMetadata() const;
 
1008
 
 
1009
  // nested types ----------------------------------------------------
 
1010
 
 
1011
  // accessors -------------------------------------------------------
 
1012
 
 
1013
  // optional string name = 1;
 
1014
  inline bool has_name() const;
 
1015
  inline void clear_name();
 
1016
  static const int kNameFieldNumber = 1;
 
1017
  inline const ::std::string& name() const;
 
1018
  inline void set_name(const ::std::string& value);
 
1019
  inline void set_name(const char* value);
 
1020
  inline void set_name(const char* value, size_t size);
 
1021
  inline ::std::string* mutable_name();
 
1022
  inline ::std::string* release_name();
 
1023
  inline void set_allocated_name(::std::string* name);
 
1024
 
 
1025
  // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
 
1026
  inline int value_size() const;
 
1027
  inline void clear_value();
 
1028
  static const int kValueFieldNumber = 2;
 
1029
  inline const ::google::protobuf::EnumValueDescriptorProto& value(int index) const;
 
1030
  inline ::google::protobuf::EnumValueDescriptorProto* mutable_value(int index);
 
1031
  inline ::google::protobuf::EnumValueDescriptorProto* add_value();
 
1032
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >&
 
1033
      value() const;
 
1034
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >*
 
1035
      mutable_value();
 
1036
 
 
1037
  // optional .google.protobuf.EnumOptions options = 3;
 
1038
  inline bool has_options() const;
 
1039
  inline void clear_options();
 
1040
  static const int kOptionsFieldNumber = 3;
 
1041
  inline const ::google::protobuf::EnumOptions& options() const;
 
1042
  inline ::google::protobuf::EnumOptions* mutable_options();
 
1043
  inline ::google::protobuf::EnumOptions* release_options();
 
1044
  inline void set_allocated_options(::google::protobuf::EnumOptions* options);
 
1045
 
 
1046
  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto)
 
1047
 private:
 
1048
  inline void set_has_name();
 
1049
  inline void clear_has_name();
 
1050
  inline void set_has_options();
 
1051
  inline void clear_has_options();
 
1052
 
 
1053
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1054
 
 
1055
  ::std::string* name_;
 
1056
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto > value_;
 
1057
  ::google::protobuf::EnumOptions* options_;
 
1058
 
 
1059
  mutable int _cached_size_;
 
1060
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 
1061
 
 
1062
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1063
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1064
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1065
 
 
1066
  void InitAsDefaultInstance();
 
1067
  static EnumDescriptorProto* default_instance_;
 
1068
};
 
1069
// -------------------------------------------------------------------
 
1070
 
 
1071
class LIBPROTOBUF_EXPORT EnumValueDescriptorProto : public ::google::protobuf::Message {
 
1072
 public:
 
1073
  EnumValueDescriptorProto();
 
1074
  virtual ~EnumValueDescriptorProto();
 
1075
 
 
1076
  EnumValueDescriptorProto(const EnumValueDescriptorProto& from);
 
1077
 
 
1078
  inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) {
 
1079
    CopyFrom(from);
 
1080
    return *this;
 
1081
  }
 
1082
 
 
1083
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1084
    return _unknown_fields_;
 
1085
  }
 
1086
 
 
1087
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1088
    return &_unknown_fields_;
 
1089
  }
 
1090
 
 
1091
  static const ::google::protobuf::Descriptor* descriptor();
 
1092
  static const EnumValueDescriptorProto& default_instance();
 
1093
 
 
1094
  void Swap(EnumValueDescriptorProto* other);
 
1095
 
 
1096
  // implements Message ----------------------------------------------
 
1097
 
 
1098
  EnumValueDescriptorProto* New() const;
 
1099
  void CopyFrom(const ::google::protobuf::Message& from);
 
1100
  void MergeFrom(const ::google::protobuf::Message& from);
 
1101
  void CopyFrom(const EnumValueDescriptorProto& from);
 
1102
  void MergeFrom(const EnumValueDescriptorProto& from);
 
1103
  void Clear();
 
1104
  bool IsInitialized() const;
 
1105
 
 
1106
  int ByteSize() const;
 
1107
  bool MergePartialFromCodedStream(
 
1108
      ::google::protobuf::io::CodedInputStream* input);
 
1109
  void SerializeWithCachedSizes(
 
1110
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1111
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1112
  int GetCachedSize() const { return _cached_size_; }
 
1113
  private:
 
1114
  void SharedCtor();
 
1115
  void SharedDtor();
 
1116
  void SetCachedSize(int size) const;
 
1117
  public:
 
1118
 
 
1119
  ::google::protobuf::Metadata GetMetadata() const;
 
1120
 
 
1121
  // nested types ----------------------------------------------------
 
1122
 
 
1123
  // accessors -------------------------------------------------------
 
1124
 
 
1125
  // optional string name = 1;
 
1126
  inline bool has_name() const;
 
1127
  inline void clear_name();
 
1128
  static const int kNameFieldNumber = 1;
 
1129
  inline const ::std::string& name() const;
 
1130
  inline void set_name(const ::std::string& value);
 
1131
  inline void set_name(const char* value);
 
1132
  inline void set_name(const char* value, size_t size);
 
1133
  inline ::std::string* mutable_name();
 
1134
  inline ::std::string* release_name();
 
1135
  inline void set_allocated_name(::std::string* name);
 
1136
 
 
1137
  // optional int32 number = 2;
 
1138
  inline bool has_number() const;
 
1139
  inline void clear_number();
 
1140
  static const int kNumberFieldNumber = 2;
 
1141
  inline ::google::protobuf::int32 number() const;
 
1142
  inline void set_number(::google::protobuf::int32 value);
 
1143
 
 
1144
  // optional .google.protobuf.EnumValueOptions options = 3;
 
1145
  inline bool has_options() const;
 
1146
  inline void clear_options();
 
1147
  static const int kOptionsFieldNumber = 3;
 
1148
  inline const ::google::protobuf::EnumValueOptions& options() const;
 
1149
  inline ::google::protobuf::EnumValueOptions* mutable_options();
 
1150
  inline ::google::protobuf::EnumValueOptions* release_options();
 
1151
  inline void set_allocated_options(::google::protobuf::EnumValueOptions* options);
 
1152
 
 
1153
  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto)
 
1154
 private:
 
1155
  inline void set_has_name();
 
1156
  inline void clear_has_name();
 
1157
  inline void set_has_number();
 
1158
  inline void clear_has_number();
 
1159
  inline void set_has_options();
 
1160
  inline void clear_has_options();
 
1161
 
 
1162
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1163
 
 
1164
  ::std::string* name_;
 
1165
  ::google::protobuf::EnumValueOptions* options_;
 
1166
  ::google::protobuf::int32 number_;
 
1167
 
 
1168
  mutable int _cached_size_;
 
1169
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 
1170
 
 
1171
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1172
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1173
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1174
 
 
1175
  void InitAsDefaultInstance();
 
1176
  static EnumValueDescriptorProto* default_instance_;
 
1177
};
 
1178
// -------------------------------------------------------------------
 
1179
 
 
1180
class LIBPROTOBUF_EXPORT ServiceDescriptorProto : public ::google::protobuf::Message {
 
1181
 public:
 
1182
  ServiceDescriptorProto();
 
1183
  virtual ~ServiceDescriptorProto();
 
1184
 
 
1185
  ServiceDescriptorProto(const ServiceDescriptorProto& from);
 
1186
 
 
1187
  inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) {
 
1188
    CopyFrom(from);
 
1189
    return *this;
 
1190
  }
 
1191
 
 
1192
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1193
    return _unknown_fields_;
 
1194
  }
 
1195
 
 
1196
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1197
    return &_unknown_fields_;
 
1198
  }
 
1199
 
 
1200
  static const ::google::protobuf::Descriptor* descriptor();
 
1201
  static const ServiceDescriptorProto& default_instance();
 
1202
 
 
1203
  void Swap(ServiceDescriptorProto* other);
 
1204
 
 
1205
  // implements Message ----------------------------------------------
 
1206
 
 
1207
  ServiceDescriptorProto* New() const;
 
1208
  void CopyFrom(const ::google::protobuf::Message& from);
 
1209
  void MergeFrom(const ::google::protobuf::Message& from);
 
1210
  void CopyFrom(const ServiceDescriptorProto& from);
 
1211
  void MergeFrom(const ServiceDescriptorProto& from);
 
1212
  void Clear();
 
1213
  bool IsInitialized() const;
 
1214
 
 
1215
  int ByteSize() const;
 
1216
  bool MergePartialFromCodedStream(
 
1217
      ::google::protobuf::io::CodedInputStream* input);
 
1218
  void SerializeWithCachedSizes(
 
1219
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1220
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1221
  int GetCachedSize() const { return _cached_size_; }
 
1222
  private:
 
1223
  void SharedCtor();
 
1224
  void SharedDtor();
 
1225
  void SetCachedSize(int size) const;
 
1226
  public:
 
1227
 
 
1228
  ::google::protobuf::Metadata GetMetadata() const;
 
1229
 
 
1230
  // nested types ----------------------------------------------------
 
1231
 
 
1232
  // accessors -------------------------------------------------------
 
1233
 
 
1234
  // optional string name = 1;
 
1235
  inline bool has_name() const;
 
1236
  inline void clear_name();
 
1237
  static const int kNameFieldNumber = 1;
 
1238
  inline const ::std::string& name() const;
 
1239
  inline void set_name(const ::std::string& value);
 
1240
  inline void set_name(const char* value);
 
1241
  inline void set_name(const char* value, size_t size);
 
1242
  inline ::std::string* mutable_name();
 
1243
  inline ::std::string* release_name();
 
1244
  inline void set_allocated_name(::std::string* name);
 
1245
 
 
1246
  // repeated .google.protobuf.MethodDescriptorProto method = 2;
 
1247
  inline int method_size() const;
 
1248
  inline void clear_method();
 
1249
  static const int kMethodFieldNumber = 2;
 
1250
  inline const ::google::protobuf::MethodDescriptorProto& method(int index) const;
 
1251
  inline ::google::protobuf::MethodDescriptorProto* mutable_method(int index);
 
1252
  inline ::google::protobuf::MethodDescriptorProto* add_method();
 
1253
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >&
 
1254
      method() const;
 
1255
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >*
 
1256
      mutable_method();
 
1257
 
 
1258
  // optional .google.protobuf.ServiceOptions options = 3;
 
1259
  inline bool has_options() const;
 
1260
  inline void clear_options();
 
1261
  static const int kOptionsFieldNumber = 3;
 
1262
  inline const ::google::protobuf::ServiceOptions& options() const;
 
1263
  inline ::google::protobuf::ServiceOptions* mutable_options();
 
1264
  inline ::google::protobuf::ServiceOptions* release_options();
 
1265
  inline void set_allocated_options(::google::protobuf::ServiceOptions* options);
 
1266
 
 
1267
  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto)
 
1268
 private:
 
1269
  inline void set_has_name();
 
1270
  inline void clear_has_name();
 
1271
  inline void set_has_options();
 
1272
  inline void clear_has_options();
 
1273
 
 
1274
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1275
 
 
1276
  ::std::string* name_;
 
1277
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto > method_;
 
1278
  ::google::protobuf::ServiceOptions* options_;
 
1279
 
 
1280
  mutable int _cached_size_;
 
1281
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 
1282
 
 
1283
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1284
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1285
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1286
 
 
1287
  void InitAsDefaultInstance();
 
1288
  static ServiceDescriptorProto* default_instance_;
 
1289
};
 
1290
// -------------------------------------------------------------------
 
1291
 
 
1292
class LIBPROTOBUF_EXPORT MethodDescriptorProto : public ::google::protobuf::Message {
 
1293
 public:
 
1294
  MethodDescriptorProto();
 
1295
  virtual ~MethodDescriptorProto();
 
1296
 
 
1297
  MethodDescriptorProto(const MethodDescriptorProto& from);
 
1298
 
 
1299
  inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) {
 
1300
    CopyFrom(from);
 
1301
    return *this;
 
1302
  }
 
1303
 
 
1304
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1305
    return _unknown_fields_;
 
1306
  }
 
1307
 
 
1308
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1309
    return &_unknown_fields_;
 
1310
  }
 
1311
 
 
1312
  static const ::google::protobuf::Descriptor* descriptor();
 
1313
  static const MethodDescriptorProto& default_instance();
 
1314
 
 
1315
  void Swap(MethodDescriptorProto* other);
 
1316
 
 
1317
  // implements Message ----------------------------------------------
 
1318
 
 
1319
  MethodDescriptorProto* New() const;
 
1320
  void CopyFrom(const ::google::protobuf::Message& from);
 
1321
  void MergeFrom(const ::google::protobuf::Message& from);
 
1322
  void CopyFrom(const MethodDescriptorProto& from);
 
1323
  void MergeFrom(const MethodDescriptorProto& from);
 
1324
  void Clear();
 
1325
  bool IsInitialized() const;
 
1326
 
 
1327
  int ByteSize() const;
 
1328
  bool MergePartialFromCodedStream(
 
1329
      ::google::protobuf::io::CodedInputStream* input);
 
1330
  void SerializeWithCachedSizes(
 
1331
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1332
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1333
  int GetCachedSize() const { return _cached_size_; }
 
1334
  private:
 
1335
  void SharedCtor();
 
1336
  void SharedDtor();
 
1337
  void SetCachedSize(int size) const;
 
1338
  public:
 
1339
 
 
1340
  ::google::protobuf::Metadata GetMetadata() const;
 
1341
 
 
1342
  // nested types ----------------------------------------------------
 
1343
 
 
1344
  // accessors -------------------------------------------------------
 
1345
 
 
1346
  // optional string name = 1;
 
1347
  inline bool has_name() const;
 
1348
  inline void clear_name();
 
1349
  static const int kNameFieldNumber = 1;
 
1350
  inline const ::std::string& name() const;
 
1351
  inline void set_name(const ::std::string& value);
 
1352
  inline void set_name(const char* value);
 
1353
  inline void set_name(const char* value, size_t size);
 
1354
  inline ::std::string* mutable_name();
 
1355
  inline ::std::string* release_name();
 
1356
  inline void set_allocated_name(::std::string* name);
 
1357
 
 
1358
  // optional string input_type = 2;
 
1359
  inline bool has_input_type() const;
 
1360
  inline void clear_input_type();
 
1361
  static const int kInputTypeFieldNumber = 2;
 
1362
  inline const ::std::string& input_type() const;
 
1363
  inline void set_input_type(const ::std::string& value);
 
1364
  inline void set_input_type(const char* value);
 
1365
  inline void set_input_type(const char* value, size_t size);
 
1366
  inline ::std::string* mutable_input_type();
 
1367
  inline ::std::string* release_input_type();
 
1368
  inline void set_allocated_input_type(::std::string* input_type);
 
1369
 
 
1370
  // optional string output_type = 3;
 
1371
  inline bool has_output_type() const;
 
1372
  inline void clear_output_type();
 
1373
  static const int kOutputTypeFieldNumber = 3;
 
1374
  inline const ::std::string& output_type() const;
 
1375
  inline void set_output_type(const ::std::string& value);
 
1376
  inline void set_output_type(const char* value);
 
1377
  inline void set_output_type(const char* value, size_t size);
 
1378
  inline ::std::string* mutable_output_type();
 
1379
  inline ::std::string* release_output_type();
 
1380
  inline void set_allocated_output_type(::std::string* output_type);
 
1381
 
 
1382
  // optional .google.protobuf.MethodOptions options = 4;
 
1383
  inline bool has_options() const;
 
1384
  inline void clear_options();
 
1385
  static const int kOptionsFieldNumber = 4;
 
1386
  inline const ::google::protobuf::MethodOptions& options() const;
 
1387
  inline ::google::protobuf::MethodOptions* mutable_options();
 
1388
  inline ::google::protobuf::MethodOptions* release_options();
 
1389
  inline void set_allocated_options(::google::protobuf::MethodOptions* options);
 
1390
 
 
1391
  // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto)
 
1392
 private:
 
1393
  inline void set_has_name();
 
1394
  inline void clear_has_name();
 
1395
  inline void set_has_input_type();
 
1396
  inline void clear_has_input_type();
 
1397
  inline void set_has_output_type();
 
1398
  inline void clear_has_output_type();
 
1399
  inline void set_has_options();
 
1400
  inline void clear_has_options();
 
1401
 
 
1402
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1403
 
 
1404
  ::std::string* name_;
 
1405
  ::std::string* input_type_;
 
1406
  ::std::string* output_type_;
 
1407
  ::google::protobuf::MethodOptions* options_;
 
1408
 
 
1409
  mutable int _cached_size_;
 
1410
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
 
1411
 
 
1412
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1413
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1414
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1415
 
 
1416
  void InitAsDefaultInstance();
 
1417
  static MethodDescriptorProto* default_instance_;
 
1418
};
 
1419
// -------------------------------------------------------------------
 
1420
 
 
1421
class LIBPROTOBUF_EXPORT FileOptions : public ::google::protobuf::Message {
 
1422
 public:
 
1423
  FileOptions();
 
1424
  virtual ~FileOptions();
 
1425
 
 
1426
  FileOptions(const FileOptions& from);
 
1427
 
 
1428
  inline FileOptions& operator=(const FileOptions& from) {
 
1429
    CopyFrom(from);
 
1430
    return *this;
 
1431
  }
 
1432
 
 
1433
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1434
    return _unknown_fields_;
 
1435
  }
 
1436
 
 
1437
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1438
    return &_unknown_fields_;
 
1439
  }
 
1440
 
 
1441
  static const ::google::protobuf::Descriptor* descriptor();
 
1442
  static const FileOptions& default_instance();
 
1443
 
 
1444
  void Swap(FileOptions* other);
 
1445
 
 
1446
  // implements Message ----------------------------------------------
 
1447
 
 
1448
  FileOptions* New() const;
 
1449
  void CopyFrom(const ::google::protobuf::Message& from);
 
1450
  void MergeFrom(const ::google::protobuf::Message& from);
 
1451
  void CopyFrom(const FileOptions& from);
 
1452
  void MergeFrom(const FileOptions& from);
 
1453
  void Clear();
 
1454
  bool IsInitialized() const;
 
1455
 
 
1456
  int ByteSize() const;
 
1457
  bool MergePartialFromCodedStream(
 
1458
      ::google::protobuf::io::CodedInputStream* input);
 
1459
  void SerializeWithCachedSizes(
 
1460
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1461
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1462
  int GetCachedSize() const { return _cached_size_; }
 
1463
  private:
 
1464
  void SharedCtor();
 
1465
  void SharedDtor();
 
1466
  void SetCachedSize(int size) const;
 
1467
  public:
 
1468
 
 
1469
  ::google::protobuf::Metadata GetMetadata() const;
 
1470
 
 
1471
  // nested types ----------------------------------------------------
 
1472
 
 
1473
  typedef FileOptions_OptimizeMode OptimizeMode;
 
1474
  static const OptimizeMode SPEED = FileOptions_OptimizeMode_SPEED;
 
1475
  static const OptimizeMode CODE_SIZE = FileOptions_OptimizeMode_CODE_SIZE;
 
1476
  static const OptimizeMode LITE_RUNTIME = FileOptions_OptimizeMode_LITE_RUNTIME;
 
1477
  static inline bool OptimizeMode_IsValid(int value) {
 
1478
    return FileOptions_OptimizeMode_IsValid(value);
 
1479
  }
 
1480
  static const OptimizeMode OptimizeMode_MIN =
 
1481
    FileOptions_OptimizeMode_OptimizeMode_MIN;
 
1482
  static const OptimizeMode OptimizeMode_MAX =
 
1483
    FileOptions_OptimizeMode_OptimizeMode_MAX;
 
1484
  static const int OptimizeMode_ARRAYSIZE =
 
1485
    FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE;
 
1486
  static inline const ::google::protobuf::EnumDescriptor*
 
1487
  OptimizeMode_descriptor() {
 
1488
    return FileOptions_OptimizeMode_descriptor();
 
1489
  }
 
1490
  static inline const ::std::string& OptimizeMode_Name(OptimizeMode value) {
 
1491
    return FileOptions_OptimizeMode_Name(value);
 
1492
  }
 
1493
  static inline bool OptimizeMode_Parse(const ::std::string& name,
 
1494
      OptimizeMode* value) {
 
1495
    return FileOptions_OptimizeMode_Parse(name, value);
 
1496
  }
 
1497
 
 
1498
  // accessors -------------------------------------------------------
 
1499
 
 
1500
  // optional string java_package = 1;
 
1501
  inline bool has_java_package() const;
 
1502
  inline void clear_java_package();
 
1503
  static const int kJavaPackageFieldNumber = 1;
 
1504
  inline const ::std::string& java_package() const;
 
1505
  inline void set_java_package(const ::std::string& value);
 
1506
  inline void set_java_package(const char* value);
 
1507
  inline void set_java_package(const char* value, size_t size);
 
1508
  inline ::std::string* mutable_java_package();
 
1509
  inline ::std::string* release_java_package();
 
1510
  inline void set_allocated_java_package(::std::string* java_package);
 
1511
 
 
1512
  // optional string java_outer_classname = 8;
 
1513
  inline bool has_java_outer_classname() const;
 
1514
  inline void clear_java_outer_classname();
 
1515
  static const int kJavaOuterClassnameFieldNumber = 8;
 
1516
  inline const ::std::string& java_outer_classname() const;
 
1517
  inline void set_java_outer_classname(const ::std::string& value);
 
1518
  inline void set_java_outer_classname(const char* value);
 
1519
  inline void set_java_outer_classname(const char* value, size_t size);
 
1520
  inline ::std::string* mutable_java_outer_classname();
 
1521
  inline ::std::string* release_java_outer_classname();
 
1522
  inline void set_allocated_java_outer_classname(::std::string* java_outer_classname);
 
1523
 
 
1524
  // optional bool java_multiple_files = 10 [default = false];
 
1525
  inline bool has_java_multiple_files() const;
 
1526
  inline void clear_java_multiple_files();
 
1527
  static const int kJavaMultipleFilesFieldNumber = 10;
 
1528
  inline bool java_multiple_files() const;
 
1529
  inline void set_java_multiple_files(bool value);
 
1530
 
 
1531
  // optional bool retain_unknown_fields = 12 [default = false];
 
1532
  inline bool has_retain_unknown_fields() const;
 
1533
  inline void clear_retain_unknown_fields();
 
1534
  static const int kRetainUnknownFieldsFieldNumber = 12;
 
1535
  inline bool retain_unknown_fields() const;
 
1536
  inline void set_retain_unknown_fields(bool value);
 
1537
 
 
1538
  // optional bool java_generate_equals_and_hash = 20 [default = false];
 
1539
  inline bool has_java_generate_equals_and_hash() const;
 
1540
  inline void clear_java_generate_equals_and_hash();
 
1541
  static const int kJavaGenerateEqualsAndHashFieldNumber = 20;
 
1542
  inline bool java_generate_equals_and_hash() const;
 
1543
  inline void set_java_generate_equals_and_hash(bool value);
 
1544
 
 
1545
  // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
 
1546
  inline bool has_optimize_for() const;
 
1547
  inline void clear_optimize_for();
 
1548
  static const int kOptimizeForFieldNumber = 9;
 
1549
  inline ::google::protobuf::FileOptions_OptimizeMode optimize_for() const;
 
1550
  inline void set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value);
 
1551
 
 
1552
  // optional string go_package = 11;
 
1553
  inline bool has_go_package() const;
 
1554
  inline void clear_go_package();
 
1555
  static const int kGoPackageFieldNumber = 11;
 
1556
  inline const ::std::string& go_package() const;
 
1557
  inline void set_go_package(const ::std::string& value);
 
1558
  inline void set_go_package(const char* value);
 
1559
  inline void set_go_package(const char* value, size_t size);
 
1560
  inline ::std::string* mutable_go_package();
 
1561
  inline ::std::string* release_go_package();
 
1562
  inline void set_allocated_go_package(::std::string* go_package);
 
1563
 
 
1564
  // optional bool cc_generic_services = 16 [default = false];
 
1565
  inline bool has_cc_generic_services() const;
 
1566
  inline void clear_cc_generic_services();
 
1567
  static const int kCcGenericServicesFieldNumber = 16;
 
1568
  inline bool cc_generic_services() const;
 
1569
  inline void set_cc_generic_services(bool value);
 
1570
 
 
1571
  // optional bool java_generic_services = 17 [default = false];
 
1572
  inline bool has_java_generic_services() const;
 
1573
  inline void clear_java_generic_services();
 
1574
  static const int kJavaGenericServicesFieldNumber = 17;
 
1575
  inline bool java_generic_services() const;
 
1576
  inline void set_java_generic_services(bool value);
 
1577
 
 
1578
  // optional bool py_generic_services = 18 [default = false];
 
1579
  inline bool has_py_generic_services() const;
 
1580
  inline void clear_py_generic_services();
 
1581
  static const int kPyGenericServicesFieldNumber = 18;
 
1582
  inline bool py_generic_services() const;
 
1583
  inline void set_py_generic_services(bool value);
 
1584
 
 
1585
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
1586
  inline int uninterpreted_option_size() const;
 
1587
  inline void clear_uninterpreted_option();
 
1588
  static const int kUninterpretedOptionFieldNumber = 999;
 
1589
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
1590
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
1591
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
1592
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
1593
      uninterpreted_option() const;
 
1594
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
1595
      mutable_uninterpreted_option();
 
1596
 
 
1597
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FileOptions)
 
1598
  // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions)
 
1599
 private:
 
1600
  inline void set_has_java_package();
 
1601
  inline void clear_has_java_package();
 
1602
  inline void set_has_java_outer_classname();
 
1603
  inline void clear_has_java_outer_classname();
 
1604
  inline void set_has_java_multiple_files();
 
1605
  inline void clear_has_java_multiple_files();
 
1606
  inline void set_has_retain_unknown_fields();
 
1607
  inline void clear_has_retain_unknown_fields();
 
1608
  inline void set_has_java_generate_equals_and_hash();
 
1609
  inline void clear_has_java_generate_equals_and_hash();
 
1610
  inline void set_has_optimize_for();
 
1611
  inline void clear_has_optimize_for();
 
1612
  inline void set_has_go_package();
 
1613
  inline void clear_has_go_package();
 
1614
  inline void set_has_cc_generic_services();
 
1615
  inline void clear_has_cc_generic_services();
 
1616
  inline void set_has_java_generic_services();
 
1617
  inline void clear_has_java_generic_services();
 
1618
  inline void set_has_py_generic_services();
 
1619
  inline void clear_has_py_generic_services();
 
1620
 
 
1621
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
1622
 
 
1623
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1624
 
 
1625
  ::std::string* java_package_;
 
1626
  ::std::string* java_outer_classname_;
 
1627
  bool java_multiple_files_;
 
1628
  bool retain_unknown_fields_;
 
1629
  bool java_generate_equals_and_hash_;
 
1630
  bool cc_generic_services_;
 
1631
  int optimize_for_;
 
1632
  ::std::string* go_package_;
 
1633
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
1634
  bool java_generic_services_;
 
1635
  bool py_generic_services_;
 
1636
 
 
1637
  mutable int _cached_size_;
 
1638
  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];
 
1639
 
 
1640
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1641
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1642
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1643
 
 
1644
  void InitAsDefaultInstance();
 
1645
  static FileOptions* default_instance_;
 
1646
};
 
1647
// -------------------------------------------------------------------
 
1648
 
 
1649
class LIBPROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message {
 
1650
 public:
 
1651
  MessageOptions();
 
1652
  virtual ~MessageOptions();
 
1653
 
 
1654
  MessageOptions(const MessageOptions& from);
 
1655
 
 
1656
  inline MessageOptions& operator=(const MessageOptions& from) {
 
1657
    CopyFrom(from);
 
1658
    return *this;
 
1659
  }
 
1660
 
 
1661
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1662
    return _unknown_fields_;
 
1663
  }
 
1664
 
 
1665
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1666
    return &_unknown_fields_;
 
1667
  }
 
1668
 
 
1669
  static const ::google::protobuf::Descriptor* descriptor();
 
1670
  static const MessageOptions& default_instance();
 
1671
 
 
1672
  void Swap(MessageOptions* other);
 
1673
 
 
1674
  // implements Message ----------------------------------------------
 
1675
 
 
1676
  MessageOptions* New() const;
 
1677
  void CopyFrom(const ::google::protobuf::Message& from);
 
1678
  void MergeFrom(const ::google::protobuf::Message& from);
 
1679
  void CopyFrom(const MessageOptions& from);
 
1680
  void MergeFrom(const MessageOptions& from);
 
1681
  void Clear();
 
1682
  bool IsInitialized() const;
 
1683
 
 
1684
  int ByteSize() const;
 
1685
  bool MergePartialFromCodedStream(
 
1686
      ::google::protobuf::io::CodedInputStream* input);
 
1687
  void SerializeWithCachedSizes(
 
1688
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1689
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1690
  int GetCachedSize() const { return _cached_size_; }
 
1691
  private:
 
1692
  void SharedCtor();
 
1693
  void SharedDtor();
 
1694
  void SetCachedSize(int size) const;
 
1695
  public:
 
1696
 
 
1697
  ::google::protobuf::Metadata GetMetadata() const;
 
1698
 
 
1699
  // nested types ----------------------------------------------------
 
1700
 
 
1701
  // accessors -------------------------------------------------------
 
1702
 
 
1703
  // optional bool message_set_wire_format = 1 [default = false];
 
1704
  inline bool has_message_set_wire_format() const;
 
1705
  inline void clear_message_set_wire_format();
 
1706
  static const int kMessageSetWireFormatFieldNumber = 1;
 
1707
  inline bool message_set_wire_format() const;
 
1708
  inline void set_message_set_wire_format(bool value);
 
1709
 
 
1710
  // optional bool no_standard_descriptor_accessor = 2 [default = false];
 
1711
  inline bool has_no_standard_descriptor_accessor() const;
 
1712
  inline void clear_no_standard_descriptor_accessor();
 
1713
  static const int kNoStandardDescriptorAccessorFieldNumber = 2;
 
1714
  inline bool no_standard_descriptor_accessor() const;
 
1715
  inline void set_no_standard_descriptor_accessor(bool value);
 
1716
 
 
1717
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
1718
  inline int uninterpreted_option_size() const;
 
1719
  inline void clear_uninterpreted_option();
 
1720
  static const int kUninterpretedOptionFieldNumber = 999;
 
1721
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
1722
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
1723
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
1724
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
1725
      uninterpreted_option() const;
 
1726
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
1727
      mutable_uninterpreted_option();
 
1728
 
 
1729
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MessageOptions)
 
1730
  // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions)
 
1731
 private:
 
1732
  inline void set_has_message_set_wire_format();
 
1733
  inline void clear_has_message_set_wire_format();
 
1734
  inline void set_has_no_standard_descriptor_accessor();
 
1735
  inline void clear_has_no_standard_descriptor_accessor();
 
1736
 
 
1737
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
1738
 
 
1739
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1740
 
 
1741
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
1742
  bool message_set_wire_format_;
 
1743
  bool no_standard_descriptor_accessor_;
 
1744
 
 
1745
  mutable int _cached_size_;
 
1746
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 
1747
 
 
1748
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1749
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1750
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1751
 
 
1752
  void InitAsDefaultInstance();
 
1753
  static MessageOptions* default_instance_;
 
1754
};
 
1755
// -------------------------------------------------------------------
 
1756
 
 
1757
class LIBPROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message {
 
1758
 public:
 
1759
  FieldOptions();
 
1760
  virtual ~FieldOptions();
 
1761
 
 
1762
  FieldOptions(const FieldOptions& from);
 
1763
 
 
1764
  inline FieldOptions& operator=(const FieldOptions& from) {
 
1765
    CopyFrom(from);
 
1766
    return *this;
 
1767
  }
 
1768
 
 
1769
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1770
    return _unknown_fields_;
 
1771
  }
 
1772
 
 
1773
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1774
    return &_unknown_fields_;
 
1775
  }
 
1776
 
 
1777
  static const ::google::protobuf::Descriptor* descriptor();
 
1778
  static const FieldOptions& default_instance();
 
1779
 
 
1780
  void Swap(FieldOptions* other);
 
1781
 
 
1782
  // implements Message ----------------------------------------------
 
1783
 
 
1784
  FieldOptions* New() const;
 
1785
  void CopyFrom(const ::google::protobuf::Message& from);
 
1786
  void MergeFrom(const ::google::protobuf::Message& from);
 
1787
  void CopyFrom(const FieldOptions& from);
 
1788
  void MergeFrom(const FieldOptions& from);
 
1789
  void Clear();
 
1790
  bool IsInitialized() const;
 
1791
 
 
1792
  int ByteSize() const;
 
1793
  bool MergePartialFromCodedStream(
 
1794
      ::google::protobuf::io::CodedInputStream* input);
 
1795
  void SerializeWithCachedSizes(
 
1796
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1797
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1798
  int GetCachedSize() const { return _cached_size_; }
 
1799
  private:
 
1800
  void SharedCtor();
 
1801
  void SharedDtor();
 
1802
  void SetCachedSize(int size) const;
 
1803
  public:
 
1804
 
 
1805
  ::google::protobuf::Metadata GetMetadata() const;
 
1806
 
 
1807
  // nested types ----------------------------------------------------
 
1808
 
 
1809
  typedef FieldOptions_CType CType;
 
1810
  static const CType STRING = FieldOptions_CType_STRING;
 
1811
  static const CType CORD = FieldOptions_CType_CORD;
 
1812
  static const CType STRING_PIECE = FieldOptions_CType_STRING_PIECE;
 
1813
  static inline bool CType_IsValid(int value) {
 
1814
    return FieldOptions_CType_IsValid(value);
 
1815
  }
 
1816
  static const CType CType_MIN =
 
1817
    FieldOptions_CType_CType_MIN;
 
1818
  static const CType CType_MAX =
 
1819
    FieldOptions_CType_CType_MAX;
 
1820
  static const int CType_ARRAYSIZE =
 
1821
    FieldOptions_CType_CType_ARRAYSIZE;
 
1822
  static inline const ::google::protobuf::EnumDescriptor*
 
1823
  CType_descriptor() {
 
1824
    return FieldOptions_CType_descriptor();
 
1825
  }
 
1826
  static inline const ::std::string& CType_Name(CType value) {
 
1827
    return FieldOptions_CType_Name(value);
 
1828
  }
 
1829
  static inline bool CType_Parse(const ::std::string& name,
 
1830
      CType* value) {
 
1831
    return FieldOptions_CType_Parse(name, value);
 
1832
  }
 
1833
 
 
1834
  // accessors -------------------------------------------------------
 
1835
 
 
1836
  // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
 
1837
  inline bool has_ctype() const;
 
1838
  inline void clear_ctype();
 
1839
  static const int kCtypeFieldNumber = 1;
 
1840
  inline ::google::protobuf::FieldOptions_CType ctype() const;
 
1841
  inline void set_ctype(::google::protobuf::FieldOptions_CType value);
 
1842
 
 
1843
  // optional bool packed = 2;
 
1844
  inline bool has_packed() const;
 
1845
  inline void clear_packed();
 
1846
  static const int kPackedFieldNumber = 2;
 
1847
  inline bool packed() const;
 
1848
  inline void set_packed(bool value);
 
1849
 
 
1850
  // optional bool lazy = 5 [default = false];
 
1851
  inline bool has_lazy() const;
 
1852
  inline void clear_lazy();
 
1853
  static const int kLazyFieldNumber = 5;
 
1854
  inline bool lazy() const;
 
1855
  inline void set_lazy(bool value);
 
1856
 
 
1857
  // optional bool deprecated = 3 [default = false];
 
1858
  inline bool has_deprecated() const;
 
1859
  inline void clear_deprecated();
 
1860
  static const int kDeprecatedFieldNumber = 3;
 
1861
  inline bool deprecated() const;
 
1862
  inline void set_deprecated(bool value);
 
1863
 
 
1864
  // optional string experimental_map_key = 9;
 
1865
  inline bool has_experimental_map_key() const;
 
1866
  inline void clear_experimental_map_key();
 
1867
  static const int kExperimentalMapKeyFieldNumber = 9;
 
1868
  inline const ::std::string& experimental_map_key() const;
 
1869
  inline void set_experimental_map_key(const ::std::string& value);
 
1870
  inline void set_experimental_map_key(const char* value);
 
1871
  inline void set_experimental_map_key(const char* value, size_t size);
 
1872
  inline ::std::string* mutable_experimental_map_key();
 
1873
  inline ::std::string* release_experimental_map_key();
 
1874
  inline void set_allocated_experimental_map_key(::std::string* experimental_map_key);
 
1875
 
 
1876
  // optional bool weak = 10 [default = false];
 
1877
  inline bool has_weak() const;
 
1878
  inline void clear_weak();
 
1879
  static const int kWeakFieldNumber = 10;
 
1880
  inline bool weak() const;
 
1881
  inline void set_weak(bool value);
 
1882
 
 
1883
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
1884
  inline int uninterpreted_option_size() const;
 
1885
  inline void clear_uninterpreted_option();
 
1886
  static const int kUninterpretedOptionFieldNumber = 999;
 
1887
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
1888
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
1889
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
1890
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
1891
      uninterpreted_option() const;
 
1892
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
1893
      mutable_uninterpreted_option();
 
1894
 
 
1895
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FieldOptions)
 
1896
  // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions)
 
1897
 private:
 
1898
  inline void set_has_ctype();
 
1899
  inline void clear_has_ctype();
 
1900
  inline void set_has_packed();
 
1901
  inline void clear_has_packed();
 
1902
  inline void set_has_lazy();
 
1903
  inline void clear_has_lazy();
 
1904
  inline void set_has_deprecated();
 
1905
  inline void clear_has_deprecated();
 
1906
  inline void set_has_experimental_map_key();
 
1907
  inline void clear_has_experimental_map_key();
 
1908
  inline void set_has_weak();
 
1909
  inline void clear_has_weak();
 
1910
 
 
1911
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
1912
 
 
1913
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
1914
 
 
1915
  int ctype_;
 
1916
  bool packed_;
 
1917
  bool lazy_;
 
1918
  bool deprecated_;
 
1919
  bool weak_;
 
1920
  ::std::string* experimental_map_key_;
 
1921
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
1922
 
 
1923
  mutable int _cached_size_;
 
1924
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
 
1925
 
 
1926
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1927
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
1928
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
1929
 
 
1930
  void InitAsDefaultInstance();
 
1931
  static FieldOptions* default_instance_;
 
1932
};
 
1933
// -------------------------------------------------------------------
 
1934
 
 
1935
class LIBPROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message {
 
1936
 public:
 
1937
  EnumOptions();
 
1938
  virtual ~EnumOptions();
 
1939
 
 
1940
  EnumOptions(const EnumOptions& from);
 
1941
 
 
1942
  inline EnumOptions& operator=(const EnumOptions& from) {
 
1943
    CopyFrom(from);
 
1944
    return *this;
 
1945
  }
 
1946
 
 
1947
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
1948
    return _unknown_fields_;
 
1949
  }
 
1950
 
 
1951
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
1952
    return &_unknown_fields_;
 
1953
  }
 
1954
 
 
1955
  static const ::google::protobuf::Descriptor* descriptor();
 
1956
  static const EnumOptions& default_instance();
 
1957
 
 
1958
  void Swap(EnumOptions* other);
 
1959
 
 
1960
  // implements Message ----------------------------------------------
 
1961
 
 
1962
  EnumOptions* New() const;
 
1963
  void CopyFrom(const ::google::protobuf::Message& from);
 
1964
  void MergeFrom(const ::google::protobuf::Message& from);
 
1965
  void CopyFrom(const EnumOptions& from);
 
1966
  void MergeFrom(const EnumOptions& from);
 
1967
  void Clear();
 
1968
  bool IsInitialized() const;
 
1969
 
 
1970
  int ByteSize() const;
 
1971
  bool MergePartialFromCodedStream(
 
1972
      ::google::protobuf::io::CodedInputStream* input);
 
1973
  void SerializeWithCachedSizes(
 
1974
      ::google::protobuf::io::CodedOutputStream* output) const;
 
1975
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
1976
  int GetCachedSize() const { return _cached_size_; }
 
1977
  private:
 
1978
  void SharedCtor();
 
1979
  void SharedDtor();
 
1980
  void SetCachedSize(int size) const;
 
1981
  public:
 
1982
 
 
1983
  ::google::protobuf::Metadata GetMetadata() const;
 
1984
 
 
1985
  // nested types ----------------------------------------------------
 
1986
 
 
1987
  // accessors -------------------------------------------------------
 
1988
 
 
1989
  // optional bool allow_alias = 2 [default = true];
 
1990
  inline bool has_allow_alias() const;
 
1991
  inline void clear_allow_alias();
 
1992
  static const int kAllowAliasFieldNumber = 2;
 
1993
  inline bool allow_alias() const;
 
1994
  inline void set_allow_alias(bool value);
 
1995
 
 
1996
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
1997
  inline int uninterpreted_option_size() const;
 
1998
  inline void clear_uninterpreted_option();
 
1999
  static const int kUninterpretedOptionFieldNumber = 999;
 
2000
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
2001
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
2002
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
2003
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
2004
      uninterpreted_option() const;
 
2005
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
2006
      mutable_uninterpreted_option();
 
2007
 
 
2008
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumOptions)
 
2009
  // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions)
 
2010
 private:
 
2011
  inline void set_has_allow_alias();
 
2012
  inline void clear_has_allow_alias();
 
2013
 
 
2014
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
2015
 
 
2016
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2017
 
 
2018
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
2019
  bool allow_alias_;
 
2020
 
 
2021
  mutable int _cached_size_;
 
2022
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
 
2023
 
 
2024
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2025
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2026
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2027
 
 
2028
  void InitAsDefaultInstance();
 
2029
  static EnumOptions* default_instance_;
 
2030
};
 
2031
// -------------------------------------------------------------------
 
2032
 
 
2033
class LIBPROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message {
 
2034
 public:
 
2035
  EnumValueOptions();
 
2036
  virtual ~EnumValueOptions();
 
2037
 
 
2038
  EnumValueOptions(const EnumValueOptions& from);
 
2039
 
 
2040
  inline EnumValueOptions& operator=(const EnumValueOptions& from) {
 
2041
    CopyFrom(from);
 
2042
    return *this;
 
2043
  }
 
2044
 
 
2045
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2046
    return _unknown_fields_;
 
2047
  }
 
2048
 
 
2049
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2050
    return &_unknown_fields_;
 
2051
  }
 
2052
 
 
2053
  static const ::google::protobuf::Descriptor* descriptor();
 
2054
  static const EnumValueOptions& default_instance();
 
2055
 
 
2056
  void Swap(EnumValueOptions* other);
 
2057
 
 
2058
  // implements Message ----------------------------------------------
 
2059
 
 
2060
  EnumValueOptions* New() const;
 
2061
  void CopyFrom(const ::google::protobuf::Message& from);
 
2062
  void MergeFrom(const ::google::protobuf::Message& from);
 
2063
  void CopyFrom(const EnumValueOptions& from);
 
2064
  void MergeFrom(const EnumValueOptions& from);
 
2065
  void Clear();
 
2066
  bool IsInitialized() const;
 
2067
 
 
2068
  int ByteSize() const;
 
2069
  bool MergePartialFromCodedStream(
 
2070
      ::google::protobuf::io::CodedInputStream* input);
 
2071
  void SerializeWithCachedSizes(
 
2072
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2073
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2074
  int GetCachedSize() const { return _cached_size_; }
 
2075
  private:
 
2076
  void SharedCtor();
 
2077
  void SharedDtor();
 
2078
  void SetCachedSize(int size) const;
 
2079
  public:
 
2080
 
 
2081
  ::google::protobuf::Metadata GetMetadata() const;
 
2082
 
 
2083
  // nested types ----------------------------------------------------
 
2084
 
 
2085
  // accessors -------------------------------------------------------
 
2086
 
 
2087
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
2088
  inline int uninterpreted_option_size() const;
 
2089
  inline void clear_uninterpreted_option();
 
2090
  static const int kUninterpretedOptionFieldNumber = 999;
 
2091
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
2092
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
2093
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
2094
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
2095
      uninterpreted_option() const;
 
2096
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
2097
      mutable_uninterpreted_option();
 
2098
 
 
2099
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumValueOptions)
 
2100
  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions)
 
2101
 private:
 
2102
 
 
2103
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
2104
 
 
2105
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2106
 
 
2107
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
2108
 
 
2109
  mutable int _cached_size_;
 
2110
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 
2111
 
 
2112
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2113
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2114
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2115
 
 
2116
  void InitAsDefaultInstance();
 
2117
  static EnumValueOptions* default_instance_;
 
2118
};
 
2119
// -------------------------------------------------------------------
 
2120
 
 
2121
class LIBPROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message {
 
2122
 public:
 
2123
  ServiceOptions();
 
2124
  virtual ~ServiceOptions();
 
2125
 
 
2126
  ServiceOptions(const ServiceOptions& from);
 
2127
 
 
2128
  inline ServiceOptions& operator=(const ServiceOptions& from) {
 
2129
    CopyFrom(from);
 
2130
    return *this;
 
2131
  }
 
2132
 
 
2133
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2134
    return _unknown_fields_;
 
2135
  }
 
2136
 
 
2137
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2138
    return &_unknown_fields_;
 
2139
  }
 
2140
 
 
2141
  static const ::google::protobuf::Descriptor* descriptor();
 
2142
  static const ServiceOptions& default_instance();
 
2143
 
 
2144
  void Swap(ServiceOptions* other);
 
2145
 
 
2146
  // implements Message ----------------------------------------------
 
2147
 
 
2148
  ServiceOptions* New() const;
 
2149
  void CopyFrom(const ::google::protobuf::Message& from);
 
2150
  void MergeFrom(const ::google::protobuf::Message& from);
 
2151
  void CopyFrom(const ServiceOptions& from);
 
2152
  void MergeFrom(const ServiceOptions& from);
 
2153
  void Clear();
 
2154
  bool IsInitialized() const;
 
2155
 
 
2156
  int ByteSize() const;
 
2157
  bool MergePartialFromCodedStream(
 
2158
      ::google::protobuf::io::CodedInputStream* input);
 
2159
  void SerializeWithCachedSizes(
 
2160
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2161
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2162
  int GetCachedSize() const { return _cached_size_; }
 
2163
  private:
 
2164
  void SharedCtor();
 
2165
  void SharedDtor();
 
2166
  void SetCachedSize(int size) const;
 
2167
  public:
 
2168
 
 
2169
  ::google::protobuf::Metadata GetMetadata() const;
 
2170
 
 
2171
  // nested types ----------------------------------------------------
 
2172
 
 
2173
  // accessors -------------------------------------------------------
 
2174
 
 
2175
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
2176
  inline int uninterpreted_option_size() const;
 
2177
  inline void clear_uninterpreted_option();
 
2178
  static const int kUninterpretedOptionFieldNumber = 999;
 
2179
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
2180
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
2181
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
2182
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
2183
      uninterpreted_option() const;
 
2184
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
2185
      mutable_uninterpreted_option();
 
2186
 
 
2187
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ServiceOptions)
 
2188
  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions)
 
2189
 private:
 
2190
 
 
2191
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
2192
 
 
2193
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2194
 
 
2195
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
2196
 
 
2197
  mutable int _cached_size_;
 
2198
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 
2199
 
 
2200
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2201
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2202
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2203
 
 
2204
  void InitAsDefaultInstance();
 
2205
  static ServiceOptions* default_instance_;
 
2206
};
 
2207
// -------------------------------------------------------------------
 
2208
 
 
2209
class LIBPROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message {
 
2210
 public:
 
2211
  MethodOptions();
 
2212
  virtual ~MethodOptions();
 
2213
 
 
2214
  MethodOptions(const MethodOptions& from);
 
2215
 
 
2216
  inline MethodOptions& operator=(const MethodOptions& from) {
 
2217
    CopyFrom(from);
 
2218
    return *this;
 
2219
  }
 
2220
 
 
2221
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2222
    return _unknown_fields_;
 
2223
  }
 
2224
 
 
2225
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2226
    return &_unknown_fields_;
 
2227
  }
 
2228
 
 
2229
  static const ::google::protobuf::Descriptor* descriptor();
 
2230
  static const MethodOptions& default_instance();
 
2231
 
 
2232
  void Swap(MethodOptions* other);
 
2233
 
 
2234
  // implements Message ----------------------------------------------
 
2235
 
 
2236
  MethodOptions* New() const;
 
2237
  void CopyFrom(const ::google::protobuf::Message& from);
 
2238
  void MergeFrom(const ::google::protobuf::Message& from);
 
2239
  void CopyFrom(const MethodOptions& from);
 
2240
  void MergeFrom(const MethodOptions& from);
 
2241
  void Clear();
 
2242
  bool IsInitialized() const;
 
2243
 
 
2244
  int ByteSize() const;
 
2245
  bool MergePartialFromCodedStream(
 
2246
      ::google::protobuf::io::CodedInputStream* input);
 
2247
  void SerializeWithCachedSizes(
 
2248
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2249
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2250
  int GetCachedSize() const { return _cached_size_; }
 
2251
  private:
 
2252
  void SharedCtor();
 
2253
  void SharedDtor();
 
2254
  void SetCachedSize(int size) const;
 
2255
  public:
 
2256
 
 
2257
  ::google::protobuf::Metadata GetMetadata() const;
 
2258
 
 
2259
  // nested types ----------------------------------------------------
 
2260
 
 
2261
  // accessors -------------------------------------------------------
 
2262
 
 
2263
  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
2264
  inline int uninterpreted_option_size() const;
 
2265
  inline void clear_uninterpreted_option();
 
2266
  static const int kUninterpretedOptionFieldNumber = 999;
 
2267
  inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
 
2268
  inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
 
2269
  inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
 
2270
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
2271
      uninterpreted_option() const;
 
2272
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
2273
      mutable_uninterpreted_option();
 
2274
 
 
2275
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MethodOptions)
 
2276
  // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions)
 
2277
 private:
 
2278
 
 
2279
  ::google::protobuf::internal::ExtensionSet _extensions_;
 
2280
 
 
2281
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2282
 
 
2283
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
 
2284
 
 
2285
  mutable int _cached_size_;
 
2286
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 
2287
 
 
2288
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2289
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2290
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2291
 
 
2292
  void InitAsDefaultInstance();
 
2293
  static MethodOptions* default_instance_;
 
2294
};
 
2295
// -------------------------------------------------------------------
 
2296
 
 
2297
class LIBPROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf::Message {
 
2298
 public:
 
2299
  UninterpretedOption_NamePart();
 
2300
  virtual ~UninterpretedOption_NamePart();
 
2301
 
 
2302
  UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from);
 
2303
 
 
2304
  inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) {
 
2305
    CopyFrom(from);
 
2306
    return *this;
 
2307
  }
 
2308
 
 
2309
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2310
    return _unknown_fields_;
 
2311
  }
 
2312
 
 
2313
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2314
    return &_unknown_fields_;
 
2315
  }
 
2316
 
 
2317
  static const ::google::protobuf::Descriptor* descriptor();
 
2318
  static const UninterpretedOption_NamePart& default_instance();
 
2319
 
 
2320
  void Swap(UninterpretedOption_NamePart* other);
 
2321
 
 
2322
  // implements Message ----------------------------------------------
 
2323
 
 
2324
  UninterpretedOption_NamePart* New() const;
 
2325
  void CopyFrom(const ::google::protobuf::Message& from);
 
2326
  void MergeFrom(const ::google::protobuf::Message& from);
 
2327
  void CopyFrom(const UninterpretedOption_NamePart& from);
 
2328
  void MergeFrom(const UninterpretedOption_NamePart& from);
 
2329
  void Clear();
 
2330
  bool IsInitialized() const;
 
2331
 
 
2332
  int ByteSize() const;
 
2333
  bool MergePartialFromCodedStream(
 
2334
      ::google::protobuf::io::CodedInputStream* input);
 
2335
  void SerializeWithCachedSizes(
 
2336
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2337
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2338
  int GetCachedSize() const { return _cached_size_; }
 
2339
  private:
 
2340
  void SharedCtor();
 
2341
  void SharedDtor();
 
2342
  void SetCachedSize(int size) const;
 
2343
  public:
 
2344
 
 
2345
  ::google::protobuf::Metadata GetMetadata() const;
 
2346
 
 
2347
  // nested types ----------------------------------------------------
 
2348
 
 
2349
  // accessors -------------------------------------------------------
 
2350
 
 
2351
  // required string name_part = 1;
 
2352
  inline bool has_name_part() const;
 
2353
  inline void clear_name_part();
 
2354
  static const int kNamePartFieldNumber = 1;
 
2355
  inline const ::std::string& name_part() const;
 
2356
  inline void set_name_part(const ::std::string& value);
 
2357
  inline void set_name_part(const char* value);
 
2358
  inline void set_name_part(const char* value, size_t size);
 
2359
  inline ::std::string* mutable_name_part();
 
2360
  inline ::std::string* release_name_part();
 
2361
  inline void set_allocated_name_part(::std::string* name_part);
 
2362
 
 
2363
  // required bool is_extension = 2;
 
2364
  inline bool has_is_extension() const;
 
2365
  inline void clear_is_extension();
 
2366
  static const int kIsExtensionFieldNumber = 2;
 
2367
  inline bool is_extension() const;
 
2368
  inline void set_is_extension(bool value);
 
2369
 
 
2370
  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)
 
2371
 private:
 
2372
  inline void set_has_name_part();
 
2373
  inline void clear_has_name_part();
 
2374
  inline void set_has_is_extension();
 
2375
  inline void clear_has_is_extension();
 
2376
 
 
2377
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2378
 
 
2379
  ::std::string* name_part_;
 
2380
  bool is_extension_;
 
2381
 
 
2382
  mutable int _cached_size_;
 
2383
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
 
2384
 
 
2385
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2386
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2387
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2388
 
 
2389
  void InitAsDefaultInstance();
 
2390
  static UninterpretedOption_NamePart* default_instance_;
 
2391
};
 
2392
// -------------------------------------------------------------------
 
2393
 
 
2394
class LIBPROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message {
 
2395
 public:
 
2396
  UninterpretedOption();
 
2397
  virtual ~UninterpretedOption();
 
2398
 
 
2399
  UninterpretedOption(const UninterpretedOption& from);
 
2400
 
 
2401
  inline UninterpretedOption& operator=(const UninterpretedOption& from) {
 
2402
    CopyFrom(from);
 
2403
    return *this;
 
2404
  }
 
2405
 
 
2406
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2407
    return _unknown_fields_;
 
2408
  }
 
2409
 
 
2410
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2411
    return &_unknown_fields_;
 
2412
  }
 
2413
 
 
2414
  static const ::google::protobuf::Descriptor* descriptor();
 
2415
  static const UninterpretedOption& default_instance();
 
2416
 
 
2417
  void Swap(UninterpretedOption* other);
 
2418
 
 
2419
  // implements Message ----------------------------------------------
 
2420
 
 
2421
  UninterpretedOption* New() const;
 
2422
  void CopyFrom(const ::google::protobuf::Message& from);
 
2423
  void MergeFrom(const ::google::protobuf::Message& from);
 
2424
  void CopyFrom(const UninterpretedOption& from);
 
2425
  void MergeFrom(const UninterpretedOption& from);
 
2426
  void Clear();
 
2427
  bool IsInitialized() const;
 
2428
 
 
2429
  int ByteSize() const;
 
2430
  bool MergePartialFromCodedStream(
 
2431
      ::google::protobuf::io::CodedInputStream* input);
 
2432
  void SerializeWithCachedSizes(
 
2433
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2434
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2435
  int GetCachedSize() const { return _cached_size_; }
 
2436
  private:
 
2437
  void SharedCtor();
 
2438
  void SharedDtor();
 
2439
  void SetCachedSize(int size) const;
 
2440
  public:
 
2441
 
 
2442
  ::google::protobuf::Metadata GetMetadata() const;
 
2443
 
 
2444
  // nested types ----------------------------------------------------
 
2445
 
 
2446
  typedef UninterpretedOption_NamePart NamePart;
 
2447
 
 
2448
  // accessors -------------------------------------------------------
 
2449
 
 
2450
  // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
 
2451
  inline int name_size() const;
 
2452
  inline void clear_name();
 
2453
  static const int kNameFieldNumber = 2;
 
2454
  inline const ::google::protobuf::UninterpretedOption_NamePart& name(int index) const;
 
2455
  inline ::google::protobuf::UninterpretedOption_NamePart* mutable_name(int index);
 
2456
  inline ::google::protobuf::UninterpretedOption_NamePart* add_name();
 
2457
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >&
 
2458
      name() const;
 
2459
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >*
 
2460
      mutable_name();
 
2461
 
 
2462
  // optional string identifier_value = 3;
 
2463
  inline bool has_identifier_value() const;
 
2464
  inline void clear_identifier_value();
 
2465
  static const int kIdentifierValueFieldNumber = 3;
 
2466
  inline const ::std::string& identifier_value() const;
 
2467
  inline void set_identifier_value(const ::std::string& value);
 
2468
  inline void set_identifier_value(const char* value);
 
2469
  inline void set_identifier_value(const char* value, size_t size);
 
2470
  inline ::std::string* mutable_identifier_value();
 
2471
  inline ::std::string* release_identifier_value();
 
2472
  inline void set_allocated_identifier_value(::std::string* identifier_value);
 
2473
 
 
2474
  // optional uint64 positive_int_value = 4;
 
2475
  inline bool has_positive_int_value() const;
 
2476
  inline void clear_positive_int_value();
 
2477
  static const int kPositiveIntValueFieldNumber = 4;
 
2478
  inline ::google::protobuf::uint64 positive_int_value() const;
 
2479
  inline void set_positive_int_value(::google::protobuf::uint64 value);
 
2480
 
 
2481
  // optional int64 negative_int_value = 5;
 
2482
  inline bool has_negative_int_value() const;
 
2483
  inline void clear_negative_int_value();
 
2484
  static const int kNegativeIntValueFieldNumber = 5;
 
2485
  inline ::google::protobuf::int64 negative_int_value() const;
 
2486
  inline void set_negative_int_value(::google::protobuf::int64 value);
 
2487
 
 
2488
  // optional double double_value = 6;
 
2489
  inline bool has_double_value() const;
 
2490
  inline void clear_double_value();
 
2491
  static const int kDoubleValueFieldNumber = 6;
 
2492
  inline double double_value() const;
 
2493
  inline void set_double_value(double value);
 
2494
 
 
2495
  // optional bytes string_value = 7;
 
2496
  inline bool has_string_value() const;
 
2497
  inline void clear_string_value();
 
2498
  static const int kStringValueFieldNumber = 7;
 
2499
  inline const ::std::string& string_value() const;
 
2500
  inline void set_string_value(const ::std::string& value);
 
2501
  inline void set_string_value(const char* value);
 
2502
  inline void set_string_value(const void* value, size_t size);
 
2503
  inline ::std::string* mutable_string_value();
 
2504
  inline ::std::string* release_string_value();
 
2505
  inline void set_allocated_string_value(::std::string* string_value);
 
2506
 
 
2507
  // optional string aggregate_value = 8;
 
2508
  inline bool has_aggregate_value() const;
 
2509
  inline void clear_aggregate_value();
 
2510
  static const int kAggregateValueFieldNumber = 8;
 
2511
  inline const ::std::string& aggregate_value() const;
 
2512
  inline void set_aggregate_value(const ::std::string& value);
 
2513
  inline void set_aggregate_value(const char* value);
 
2514
  inline void set_aggregate_value(const char* value, size_t size);
 
2515
  inline ::std::string* mutable_aggregate_value();
 
2516
  inline ::std::string* release_aggregate_value();
 
2517
  inline void set_allocated_aggregate_value(::std::string* aggregate_value);
 
2518
 
 
2519
  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption)
 
2520
 private:
 
2521
  inline void set_has_identifier_value();
 
2522
  inline void clear_has_identifier_value();
 
2523
  inline void set_has_positive_int_value();
 
2524
  inline void clear_has_positive_int_value();
 
2525
  inline void set_has_negative_int_value();
 
2526
  inline void clear_has_negative_int_value();
 
2527
  inline void set_has_double_value();
 
2528
  inline void clear_has_double_value();
 
2529
  inline void set_has_string_value();
 
2530
  inline void clear_has_string_value();
 
2531
  inline void set_has_aggregate_value();
 
2532
  inline void clear_has_aggregate_value();
 
2533
 
 
2534
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2535
 
 
2536
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart > name_;
 
2537
  ::std::string* identifier_value_;
 
2538
  ::google::protobuf::uint64 positive_int_value_;
 
2539
  ::google::protobuf::int64 negative_int_value_;
 
2540
  double double_value_;
 
2541
  ::std::string* string_value_;
 
2542
  ::std::string* aggregate_value_;
 
2543
 
 
2544
  mutable int _cached_size_;
 
2545
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
 
2546
 
 
2547
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2548
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2549
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2550
 
 
2551
  void InitAsDefaultInstance();
 
2552
  static UninterpretedOption* default_instance_;
 
2553
};
 
2554
// -------------------------------------------------------------------
 
2555
 
 
2556
class LIBPROTOBUF_EXPORT SourceCodeInfo_Location : public ::google::protobuf::Message {
 
2557
 public:
 
2558
  SourceCodeInfo_Location();
 
2559
  virtual ~SourceCodeInfo_Location();
 
2560
 
 
2561
  SourceCodeInfo_Location(const SourceCodeInfo_Location& from);
 
2562
 
 
2563
  inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) {
 
2564
    CopyFrom(from);
 
2565
    return *this;
 
2566
  }
 
2567
 
 
2568
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2569
    return _unknown_fields_;
 
2570
  }
 
2571
 
 
2572
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2573
    return &_unknown_fields_;
 
2574
  }
 
2575
 
 
2576
  static const ::google::protobuf::Descriptor* descriptor();
 
2577
  static const SourceCodeInfo_Location& default_instance();
 
2578
 
 
2579
  void Swap(SourceCodeInfo_Location* other);
 
2580
 
 
2581
  // implements Message ----------------------------------------------
 
2582
 
 
2583
  SourceCodeInfo_Location* New() const;
 
2584
  void CopyFrom(const ::google::protobuf::Message& from);
 
2585
  void MergeFrom(const ::google::protobuf::Message& from);
 
2586
  void CopyFrom(const SourceCodeInfo_Location& from);
 
2587
  void MergeFrom(const SourceCodeInfo_Location& from);
 
2588
  void Clear();
 
2589
  bool IsInitialized() const;
 
2590
 
 
2591
  int ByteSize() const;
 
2592
  bool MergePartialFromCodedStream(
 
2593
      ::google::protobuf::io::CodedInputStream* input);
 
2594
  void SerializeWithCachedSizes(
 
2595
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2596
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2597
  int GetCachedSize() const { return _cached_size_; }
 
2598
  private:
 
2599
  void SharedCtor();
 
2600
  void SharedDtor();
 
2601
  void SetCachedSize(int size) const;
 
2602
  public:
 
2603
 
 
2604
  ::google::protobuf::Metadata GetMetadata() const;
 
2605
 
 
2606
  // nested types ----------------------------------------------------
 
2607
 
 
2608
  // accessors -------------------------------------------------------
 
2609
 
 
2610
  // repeated int32 path = 1 [packed = true];
 
2611
  inline int path_size() const;
 
2612
  inline void clear_path();
 
2613
  static const int kPathFieldNumber = 1;
 
2614
  inline ::google::protobuf::int32 path(int index) const;
 
2615
  inline void set_path(int index, ::google::protobuf::int32 value);
 
2616
  inline void add_path(::google::protobuf::int32 value);
 
2617
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
2618
      path() const;
 
2619
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
2620
      mutable_path();
 
2621
 
 
2622
  // repeated int32 span = 2 [packed = true];
 
2623
  inline int span_size() const;
 
2624
  inline void clear_span();
 
2625
  static const int kSpanFieldNumber = 2;
 
2626
  inline ::google::protobuf::int32 span(int index) const;
 
2627
  inline void set_span(int index, ::google::protobuf::int32 value);
 
2628
  inline void add_span(::google::protobuf::int32 value);
 
2629
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
2630
      span() const;
 
2631
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
2632
      mutable_span();
 
2633
 
 
2634
  // optional string leading_comments = 3;
 
2635
  inline bool has_leading_comments() const;
 
2636
  inline void clear_leading_comments();
 
2637
  static const int kLeadingCommentsFieldNumber = 3;
 
2638
  inline const ::std::string& leading_comments() const;
 
2639
  inline void set_leading_comments(const ::std::string& value);
 
2640
  inline void set_leading_comments(const char* value);
 
2641
  inline void set_leading_comments(const char* value, size_t size);
 
2642
  inline ::std::string* mutable_leading_comments();
 
2643
  inline ::std::string* release_leading_comments();
 
2644
  inline void set_allocated_leading_comments(::std::string* leading_comments);
 
2645
 
 
2646
  // optional string trailing_comments = 4;
 
2647
  inline bool has_trailing_comments() const;
 
2648
  inline void clear_trailing_comments();
 
2649
  static const int kTrailingCommentsFieldNumber = 4;
 
2650
  inline const ::std::string& trailing_comments() const;
 
2651
  inline void set_trailing_comments(const ::std::string& value);
 
2652
  inline void set_trailing_comments(const char* value);
 
2653
  inline void set_trailing_comments(const char* value, size_t size);
 
2654
  inline ::std::string* mutable_trailing_comments();
 
2655
  inline ::std::string* release_trailing_comments();
 
2656
  inline void set_allocated_trailing_comments(::std::string* trailing_comments);
 
2657
 
 
2658
  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location)
 
2659
 private:
 
2660
  inline void set_has_leading_comments();
 
2661
  inline void clear_has_leading_comments();
 
2662
  inline void set_has_trailing_comments();
 
2663
  inline void clear_has_trailing_comments();
 
2664
 
 
2665
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2666
 
 
2667
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > path_;
 
2668
  mutable int _path_cached_byte_size_;
 
2669
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > span_;
 
2670
  mutable int _span_cached_byte_size_;
 
2671
  ::std::string* leading_comments_;
 
2672
  ::std::string* trailing_comments_;
 
2673
 
 
2674
  mutable int _cached_size_;
 
2675
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
 
2676
 
 
2677
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2678
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2679
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2680
 
 
2681
  void InitAsDefaultInstance();
 
2682
  static SourceCodeInfo_Location* default_instance_;
 
2683
};
 
2684
// -------------------------------------------------------------------
 
2685
 
 
2686
class LIBPROTOBUF_EXPORT SourceCodeInfo : public ::google::protobuf::Message {
 
2687
 public:
 
2688
  SourceCodeInfo();
 
2689
  virtual ~SourceCodeInfo();
 
2690
 
 
2691
  SourceCodeInfo(const SourceCodeInfo& from);
 
2692
 
 
2693
  inline SourceCodeInfo& operator=(const SourceCodeInfo& from) {
 
2694
    CopyFrom(from);
 
2695
    return *this;
 
2696
  }
 
2697
 
 
2698
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 
2699
    return _unknown_fields_;
 
2700
  }
 
2701
 
 
2702
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 
2703
    return &_unknown_fields_;
 
2704
  }
 
2705
 
 
2706
  static const ::google::protobuf::Descriptor* descriptor();
 
2707
  static const SourceCodeInfo& default_instance();
 
2708
 
 
2709
  void Swap(SourceCodeInfo* other);
 
2710
 
 
2711
  // implements Message ----------------------------------------------
 
2712
 
 
2713
  SourceCodeInfo* New() const;
 
2714
  void CopyFrom(const ::google::protobuf::Message& from);
 
2715
  void MergeFrom(const ::google::protobuf::Message& from);
 
2716
  void CopyFrom(const SourceCodeInfo& from);
 
2717
  void MergeFrom(const SourceCodeInfo& from);
 
2718
  void Clear();
 
2719
  bool IsInitialized() const;
 
2720
 
 
2721
  int ByteSize() const;
 
2722
  bool MergePartialFromCodedStream(
 
2723
      ::google::protobuf::io::CodedInputStream* input);
 
2724
  void SerializeWithCachedSizes(
 
2725
      ::google::protobuf::io::CodedOutputStream* output) const;
 
2726
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 
2727
  int GetCachedSize() const { return _cached_size_; }
 
2728
  private:
 
2729
  void SharedCtor();
 
2730
  void SharedDtor();
 
2731
  void SetCachedSize(int size) const;
 
2732
  public:
 
2733
 
 
2734
  ::google::protobuf::Metadata GetMetadata() const;
 
2735
 
 
2736
  // nested types ----------------------------------------------------
 
2737
 
 
2738
  typedef SourceCodeInfo_Location Location;
 
2739
 
 
2740
  // accessors -------------------------------------------------------
 
2741
 
 
2742
  // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
 
2743
  inline int location_size() const;
 
2744
  inline void clear_location();
 
2745
  static const int kLocationFieldNumber = 1;
 
2746
  inline const ::google::protobuf::SourceCodeInfo_Location& location(int index) const;
 
2747
  inline ::google::protobuf::SourceCodeInfo_Location* mutable_location(int index);
 
2748
  inline ::google::protobuf::SourceCodeInfo_Location* add_location();
 
2749
  inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >&
 
2750
      location() const;
 
2751
  inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >*
 
2752
      mutable_location();
 
2753
 
 
2754
  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo)
 
2755
 private:
 
2756
 
 
2757
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
2758
 
 
2759
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location > location_;
 
2760
 
 
2761
  mutable int _cached_size_;
 
2762
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 
2763
 
 
2764
  friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2765
  friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto();
 
2766
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto();
 
2767
 
 
2768
  void InitAsDefaultInstance();
 
2769
  static SourceCodeInfo* default_instance_;
 
2770
};
 
2771
// ===================================================================
 
2772
 
 
2773
 
 
2774
// ===================================================================
 
2775
 
 
2776
// FileDescriptorSet
 
2777
 
 
2778
// repeated .google.protobuf.FileDescriptorProto file = 1;
 
2779
inline int FileDescriptorSet::file_size() const {
 
2780
  return file_.size();
 
2781
}
 
2782
inline void FileDescriptorSet::clear_file() {
 
2783
  file_.Clear();
 
2784
}
 
2785
inline const ::google::protobuf::FileDescriptorProto& FileDescriptorSet::file(int index) const {
 
2786
  return file_.Get(index);
 
2787
}
 
2788
inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) {
 
2789
  return file_.Mutable(index);
 
2790
}
 
2791
inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::add_file() {
 
2792
  return file_.Add();
 
2793
}
 
2794
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
 
2795
FileDescriptorSet::file() const {
 
2796
  return file_;
 
2797
}
 
2798
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
 
2799
FileDescriptorSet::mutable_file() {
 
2800
  return &file_;
 
2801
}
 
2802
 
 
2803
// -------------------------------------------------------------------
 
2804
 
 
2805
// FileDescriptorProto
 
2806
 
 
2807
// optional string name = 1;
 
2808
inline bool FileDescriptorProto::has_name() const {
 
2809
  return (_has_bits_[0] & 0x00000001u) != 0;
 
2810
}
 
2811
inline void FileDescriptorProto::set_has_name() {
 
2812
  _has_bits_[0] |= 0x00000001u;
 
2813
}
 
2814
inline void FileDescriptorProto::clear_has_name() {
 
2815
  _has_bits_[0] &= ~0x00000001u;
 
2816
}
 
2817
inline void FileDescriptorProto::clear_name() {
 
2818
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
2819
    name_->clear();
 
2820
  }
 
2821
  clear_has_name();
 
2822
}
 
2823
inline const ::std::string& FileDescriptorProto::name() const {
 
2824
  return *name_;
 
2825
}
 
2826
inline void FileDescriptorProto::set_name(const ::std::string& value) {
 
2827
  set_has_name();
 
2828
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
2829
    name_ = new ::std::string;
 
2830
  }
 
2831
  name_->assign(value);
 
2832
}
 
2833
inline void FileDescriptorProto::set_name(const char* value) {
 
2834
  set_has_name();
 
2835
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
2836
    name_ = new ::std::string;
 
2837
  }
 
2838
  name_->assign(value);
 
2839
}
 
2840
inline void FileDescriptorProto::set_name(const char* value, size_t size) {
 
2841
  set_has_name();
 
2842
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
2843
    name_ = new ::std::string;
 
2844
  }
 
2845
  name_->assign(reinterpret_cast<const char*>(value), size);
 
2846
}
 
2847
inline ::std::string* FileDescriptorProto::mutable_name() {
 
2848
  set_has_name();
 
2849
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
2850
    name_ = new ::std::string;
 
2851
  }
 
2852
  return name_;
 
2853
}
 
2854
inline ::std::string* FileDescriptorProto::release_name() {
 
2855
  clear_has_name();
 
2856
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
2857
    return NULL;
 
2858
  } else {
 
2859
    ::std::string* temp = name_;
 
2860
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
2861
    return temp;
 
2862
  }
 
2863
}
 
2864
inline void FileDescriptorProto::set_allocated_name(::std::string* name) {
 
2865
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
2866
    delete name_;
 
2867
  }
 
2868
  if (name) {
 
2869
    set_has_name();
 
2870
    name_ = name;
 
2871
  } else {
 
2872
    clear_has_name();
 
2873
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
2874
  }
 
2875
}
 
2876
 
 
2877
// optional string package = 2;
 
2878
inline bool FileDescriptorProto::has_package() const {
 
2879
  return (_has_bits_[0] & 0x00000002u) != 0;
 
2880
}
 
2881
inline void FileDescriptorProto::set_has_package() {
 
2882
  _has_bits_[0] |= 0x00000002u;
 
2883
}
 
2884
inline void FileDescriptorProto::clear_has_package() {
 
2885
  _has_bits_[0] &= ~0x00000002u;
 
2886
}
 
2887
inline void FileDescriptorProto::clear_package() {
 
2888
  if (package_ != &::google::protobuf::internal::GetEmptyString()) {
 
2889
    package_->clear();
 
2890
  }
 
2891
  clear_has_package();
 
2892
}
 
2893
inline const ::std::string& FileDescriptorProto::package() const {
 
2894
  return *package_;
 
2895
}
 
2896
inline void FileDescriptorProto::set_package(const ::std::string& value) {
 
2897
  set_has_package();
 
2898
  if (package_ == &::google::protobuf::internal::GetEmptyString()) {
 
2899
    package_ = new ::std::string;
 
2900
  }
 
2901
  package_->assign(value);
 
2902
}
 
2903
inline void FileDescriptorProto::set_package(const char* value) {
 
2904
  set_has_package();
 
2905
  if (package_ == &::google::protobuf::internal::GetEmptyString()) {
 
2906
    package_ = new ::std::string;
 
2907
  }
 
2908
  package_->assign(value);
 
2909
}
 
2910
inline void FileDescriptorProto::set_package(const char* value, size_t size) {
 
2911
  set_has_package();
 
2912
  if (package_ == &::google::protobuf::internal::GetEmptyString()) {
 
2913
    package_ = new ::std::string;
 
2914
  }
 
2915
  package_->assign(reinterpret_cast<const char*>(value), size);
 
2916
}
 
2917
inline ::std::string* FileDescriptorProto::mutable_package() {
 
2918
  set_has_package();
 
2919
  if (package_ == &::google::protobuf::internal::GetEmptyString()) {
 
2920
    package_ = new ::std::string;
 
2921
  }
 
2922
  return package_;
 
2923
}
 
2924
inline ::std::string* FileDescriptorProto::release_package() {
 
2925
  clear_has_package();
 
2926
  if (package_ == &::google::protobuf::internal::GetEmptyString()) {
 
2927
    return NULL;
 
2928
  } else {
 
2929
    ::std::string* temp = package_;
 
2930
    package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
2931
    return temp;
 
2932
  }
 
2933
}
 
2934
inline void FileDescriptorProto::set_allocated_package(::std::string* package) {
 
2935
  if (package_ != &::google::protobuf::internal::GetEmptyString()) {
 
2936
    delete package_;
 
2937
  }
 
2938
  if (package) {
 
2939
    set_has_package();
 
2940
    package_ = package;
 
2941
  } else {
 
2942
    clear_has_package();
 
2943
    package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
2944
  }
 
2945
}
 
2946
 
 
2947
// repeated string dependency = 3;
 
2948
inline int FileDescriptorProto::dependency_size() const {
 
2949
  return dependency_.size();
 
2950
}
 
2951
inline void FileDescriptorProto::clear_dependency() {
 
2952
  dependency_.Clear();
 
2953
}
 
2954
inline const ::std::string& FileDescriptorProto::dependency(int index) const {
 
2955
  return dependency_.Get(index);
 
2956
}
 
2957
inline ::std::string* FileDescriptorProto::mutable_dependency(int index) {
 
2958
  return dependency_.Mutable(index);
 
2959
}
 
2960
inline void FileDescriptorProto::set_dependency(int index, const ::std::string& value) {
 
2961
  dependency_.Mutable(index)->assign(value);
 
2962
}
 
2963
inline void FileDescriptorProto::set_dependency(int index, const char* value) {
 
2964
  dependency_.Mutable(index)->assign(value);
 
2965
}
 
2966
inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) {
 
2967
  dependency_.Mutable(index)->assign(
 
2968
    reinterpret_cast<const char*>(value), size);
 
2969
}
 
2970
inline ::std::string* FileDescriptorProto::add_dependency() {
 
2971
  return dependency_.Add();
 
2972
}
 
2973
inline void FileDescriptorProto::add_dependency(const ::std::string& value) {
 
2974
  dependency_.Add()->assign(value);
 
2975
}
 
2976
inline void FileDescriptorProto::add_dependency(const char* value) {
 
2977
  dependency_.Add()->assign(value);
 
2978
}
 
2979
inline void FileDescriptorProto::add_dependency(const char* value, size_t size) {
 
2980
  dependency_.Add()->assign(reinterpret_cast<const char*>(value), size);
 
2981
}
 
2982
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
 
2983
FileDescriptorProto::dependency() const {
 
2984
  return dependency_;
 
2985
}
 
2986
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
 
2987
FileDescriptorProto::mutable_dependency() {
 
2988
  return &dependency_;
 
2989
}
 
2990
 
 
2991
// repeated int32 public_dependency = 10;
 
2992
inline int FileDescriptorProto::public_dependency_size() const {
 
2993
  return public_dependency_.size();
 
2994
}
 
2995
inline void FileDescriptorProto::clear_public_dependency() {
 
2996
  public_dependency_.Clear();
 
2997
}
 
2998
inline ::google::protobuf::int32 FileDescriptorProto::public_dependency(int index) const {
 
2999
  return public_dependency_.Get(index);
 
3000
}
 
3001
inline void FileDescriptorProto::set_public_dependency(int index, ::google::protobuf::int32 value) {
 
3002
  public_dependency_.Set(index, value);
 
3003
}
 
3004
inline void FileDescriptorProto::add_public_dependency(::google::protobuf::int32 value) {
 
3005
  public_dependency_.Add(value);
 
3006
}
 
3007
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
3008
FileDescriptorProto::public_dependency() const {
 
3009
  return public_dependency_;
 
3010
}
 
3011
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
3012
FileDescriptorProto::mutable_public_dependency() {
 
3013
  return &public_dependency_;
 
3014
}
 
3015
 
 
3016
// repeated int32 weak_dependency = 11;
 
3017
inline int FileDescriptorProto::weak_dependency_size() const {
 
3018
  return weak_dependency_.size();
 
3019
}
 
3020
inline void FileDescriptorProto::clear_weak_dependency() {
 
3021
  weak_dependency_.Clear();
 
3022
}
 
3023
inline ::google::protobuf::int32 FileDescriptorProto::weak_dependency(int index) const {
 
3024
  return weak_dependency_.Get(index);
 
3025
}
 
3026
inline void FileDescriptorProto::set_weak_dependency(int index, ::google::protobuf::int32 value) {
 
3027
  weak_dependency_.Set(index, value);
 
3028
}
 
3029
inline void FileDescriptorProto::add_weak_dependency(::google::protobuf::int32 value) {
 
3030
  weak_dependency_.Add(value);
 
3031
}
 
3032
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
3033
FileDescriptorProto::weak_dependency() const {
 
3034
  return weak_dependency_;
 
3035
}
 
3036
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
3037
FileDescriptorProto::mutable_weak_dependency() {
 
3038
  return &weak_dependency_;
 
3039
}
 
3040
 
 
3041
// repeated .google.protobuf.DescriptorProto message_type = 4;
 
3042
inline int FileDescriptorProto::message_type_size() const {
 
3043
  return message_type_.size();
 
3044
}
 
3045
inline void FileDescriptorProto::clear_message_type() {
 
3046
  message_type_.Clear();
 
3047
}
 
3048
inline const ::google::protobuf::DescriptorProto& FileDescriptorProto::message_type(int index) const {
 
3049
  return message_type_.Get(index);
 
3050
}
 
3051
inline ::google::protobuf::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) {
 
3052
  return message_type_.Mutable(index);
 
3053
}
 
3054
inline ::google::protobuf::DescriptorProto* FileDescriptorProto::add_message_type() {
 
3055
  return message_type_.Add();
 
3056
}
 
3057
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
 
3058
FileDescriptorProto::message_type() const {
 
3059
  return message_type_;
 
3060
}
 
3061
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
 
3062
FileDescriptorProto::mutable_message_type() {
 
3063
  return &message_type_;
 
3064
}
 
3065
 
 
3066
// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
 
3067
inline int FileDescriptorProto::enum_type_size() const {
 
3068
  return enum_type_.size();
 
3069
}
 
3070
inline void FileDescriptorProto::clear_enum_type() {
 
3071
  enum_type_.Clear();
 
3072
}
 
3073
inline const ::google::protobuf::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const {
 
3074
  return enum_type_.Get(index);
 
3075
}
 
3076
inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) {
 
3077
  return enum_type_.Mutable(index);
 
3078
}
 
3079
inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::add_enum_type() {
 
3080
  return enum_type_.Add();
 
3081
}
 
3082
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
 
3083
FileDescriptorProto::enum_type() const {
 
3084
  return enum_type_;
 
3085
}
 
3086
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
 
3087
FileDescriptorProto::mutable_enum_type() {
 
3088
  return &enum_type_;
 
3089
}
 
3090
 
 
3091
// repeated .google.protobuf.ServiceDescriptorProto service = 6;
 
3092
inline int FileDescriptorProto::service_size() const {
 
3093
  return service_.size();
 
3094
}
 
3095
inline void FileDescriptorProto::clear_service() {
 
3096
  service_.Clear();
 
3097
}
 
3098
inline const ::google::protobuf::ServiceDescriptorProto& FileDescriptorProto::service(int index) const {
 
3099
  return service_.Get(index);
 
3100
}
 
3101
inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) {
 
3102
  return service_.Mutable(index);
 
3103
}
 
3104
inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::add_service() {
 
3105
  return service_.Add();
 
3106
}
 
3107
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >&
 
3108
FileDescriptorProto::service() const {
 
3109
  return service_;
 
3110
}
 
3111
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >*
 
3112
FileDescriptorProto::mutable_service() {
 
3113
  return &service_;
 
3114
}
 
3115
 
 
3116
// repeated .google.protobuf.FieldDescriptorProto extension = 7;
 
3117
inline int FileDescriptorProto::extension_size() const {
 
3118
  return extension_.size();
 
3119
}
 
3120
inline void FileDescriptorProto::clear_extension() {
 
3121
  extension_.Clear();
 
3122
}
 
3123
inline const ::google::protobuf::FieldDescriptorProto& FileDescriptorProto::extension(int index) const {
 
3124
  return extension_.Get(index);
 
3125
}
 
3126
inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) {
 
3127
  return extension_.Mutable(index);
 
3128
}
 
3129
inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::add_extension() {
 
3130
  return extension_.Add();
 
3131
}
 
3132
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
 
3133
FileDescriptorProto::extension() const {
 
3134
  return extension_;
 
3135
}
 
3136
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
 
3137
FileDescriptorProto::mutable_extension() {
 
3138
  return &extension_;
 
3139
}
 
3140
 
 
3141
// optional .google.protobuf.FileOptions options = 8;
 
3142
inline bool FileDescriptorProto::has_options() const {
 
3143
  return (_has_bits_[0] & 0x00000200u) != 0;
 
3144
}
 
3145
inline void FileDescriptorProto::set_has_options() {
 
3146
  _has_bits_[0] |= 0x00000200u;
 
3147
}
 
3148
inline void FileDescriptorProto::clear_has_options() {
 
3149
  _has_bits_[0] &= ~0x00000200u;
 
3150
}
 
3151
inline void FileDescriptorProto::clear_options() {
 
3152
  if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear();
 
3153
  clear_has_options();
 
3154
}
 
3155
inline const ::google::protobuf::FileOptions& FileDescriptorProto::options() const {
 
3156
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
3157
}
 
3158
inline ::google::protobuf::FileOptions* FileDescriptorProto::mutable_options() {
 
3159
  set_has_options();
 
3160
  if (options_ == NULL) options_ = new ::google::protobuf::FileOptions;
 
3161
  return options_;
 
3162
}
 
3163
inline ::google::protobuf::FileOptions* FileDescriptorProto::release_options() {
 
3164
  clear_has_options();
 
3165
  ::google::protobuf::FileOptions* temp = options_;
 
3166
  options_ = NULL;
 
3167
  return temp;
 
3168
}
 
3169
inline void FileDescriptorProto::set_allocated_options(::google::protobuf::FileOptions* options) {
 
3170
  delete options_;
 
3171
  options_ = options;
 
3172
  if (options) {
 
3173
    set_has_options();
 
3174
  } else {
 
3175
    clear_has_options();
 
3176
  }
 
3177
}
 
3178
 
 
3179
// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
 
3180
inline bool FileDescriptorProto::has_source_code_info() const {
 
3181
  return (_has_bits_[0] & 0x00000400u) != 0;
 
3182
}
 
3183
inline void FileDescriptorProto::set_has_source_code_info() {
 
3184
  _has_bits_[0] |= 0x00000400u;
 
3185
}
 
3186
inline void FileDescriptorProto::clear_has_source_code_info() {
 
3187
  _has_bits_[0] &= ~0x00000400u;
 
3188
}
 
3189
inline void FileDescriptorProto::clear_source_code_info() {
 
3190
  if (source_code_info_ != NULL) source_code_info_->::google::protobuf::SourceCodeInfo::Clear();
 
3191
  clear_has_source_code_info();
 
3192
}
 
3193
inline const ::google::protobuf::SourceCodeInfo& FileDescriptorProto::source_code_info() const {
 
3194
  return source_code_info_ != NULL ? *source_code_info_ : *default_instance_->source_code_info_;
 
3195
}
 
3196
inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info() {
 
3197
  set_has_source_code_info();
 
3198
  if (source_code_info_ == NULL) source_code_info_ = new ::google::protobuf::SourceCodeInfo;
 
3199
  return source_code_info_;
 
3200
}
 
3201
inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::release_source_code_info() {
 
3202
  clear_has_source_code_info();
 
3203
  ::google::protobuf::SourceCodeInfo* temp = source_code_info_;
 
3204
  source_code_info_ = NULL;
 
3205
  return temp;
 
3206
}
 
3207
inline void FileDescriptorProto::set_allocated_source_code_info(::google::protobuf::SourceCodeInfo* source_code_info) {
 
3208
  delete source_code_info_;
 
3209
  source_code_info_ = source_code_info;
 
3210
  if (source_code_info) {
 
3211
    set_has_source_code_info();
 
3212
  } else {
 
3213
    clear_has_source_code_info();
 
3214
  }
 
3215
}
 
3216
 
 
3217
// -------------------------------------------------------------------
 
3218
 
 
3219
// DescriptorProto_ExtensionRange
 
3220
 
 
3221
// optional int32 start = 1;
 
3222
inline bool DescriptorProto_ExtensionRange::has_start() const {
 
3223
  return (_has_bits_[0] & 0x00000001u) != 0;
 
3224
}
 
3225
inline void DescriptorProto_ExtensionRange::set_has_start() {
 
3226
  _has_bits_[0] |= 0x00000001u;
 
3227
}
 
3228
inline void DescriptorProto_ExtensionRange::clear_has_start() {
 
3229
  _has_bits_[0] &= ~0x00000001u;
 
3230
}
 
3231
inline void DescriptorProto_ExtensionRange::clear_start() {
 
3232
  start_ = 0;
 
3233
  clear_has_start();
 
3234
}
 
3235
inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::start() const {
 
3236
  return start_;
 
3237
}
 
3238
inline void DescriptorProto_ExtensionRange::set_start(::google::protobuf::int32 value) {
 
3239
  set_has_start();
 
3240
  start_ = value;
 
3241
}
 
3242
 
 
3243
// optional int32 end = 2;
 
3244
inline bool DescriptorProto_ExtensionRange::has_end() const {
 
3245
  return (_has_bits_[0] & 0x00000002u) != 0;
 
3246
}
 
3247
inline void DescriptorProto_ExtensionRange::set_has_end() {
 
3248
  _has_bits_[0] |= 0x00000002u;
 
3249
}
 
3250
inline void DescriptorProto_ExtensionRange::clear_has_end() {
 
3251
  _has_bits_[0] &= ~0x00000002u;
 
3252
}
 
3253
inline void DescriptorProto_ExtensionRange::clear_end() {
 
3254
  end_ = 0;
 
3255
  clear_has_end();
 
3256
}
 
3257
inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::end() const {
 
3258
  return end_;
 
3259
}
 
3260
inline void DescriptorProto_ExtensionRange::set_end(::google::protobuf::int32 value) {
 
3261
  set_has_end();
 
3262
  end_ = value;
 
3263
}
 
3264
 
 
3265
// -------------------------------------------------------------------
 
3266
 
 
3267
// DescriptorProto
 
3268
 
 
3269
// optional string name = 1;
 
3270
inline bool DescriptorProto::has_name() const {
 
3271
  return (_has_bits_[0] & 0x00000001u) != 0;
 
3272
}
 
3273
inline void DescriptorProto::set_has_name() {
 
3274
  _has_bits_[0] |= 0x00000001u;
 
3275
}
 
3276
inline void DescriptorProto::clear_has_name() {
 
3277
  _has_bits_[0] &= ~0x00000001u;
 
3278
}
 
3279
inline void DescriptorProto::clear_name() {
 
3280
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3281
    name_->clear();
 
3282
  }
 
3283
  clear_has_name();
 
3284
}
 
3285
inline const ::std::string& DescriptorProto::name() const {
 
3286
  return *name_;
 
3287
}
 
3288
inline void DescriptorProto::set_name(const ::std::string& value) {
 
3289
  set_has_name();
 
3290
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3291
    name_ = new ::std::string;
 
3292
  }
 
3293
  name_->assign(value);
 
3294
}
 
3295
inline void DescriptorProto::set_name(const char* value) {
 
3296
  set_has_name();
 
3297
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3298
    name_ = new ::std::string;
 
3299
  }
 
3300
  name_->assign(value);
 
3301
}
 
3302
inline void DescriptorProto::set_name(const char* value, size_t size) {
 
3303
  set_has_name();
 
3304
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3305
    name_ = new ::std::string;
 
3306
  }
 
3307
  name_->assign(reinterpret_cast<const char*>(value), size);
 
3308
}
 
3309
inline ::std::string* DescriptorProto::mutable_name() {
 
3310
  set_has_name();
 
3311
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3312
    name_ = new ::std::string;
 
3313
  }
 
3314
  return name_;
 
3315
}
 
3316
inline ::std::string* DescriptorProto::release_name() {
 
3317
  clear_has_name();
 
3318
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3319
    return NULL;
 
3320
  } else {
 
3321
    ::std::string* temp = name_;
 
3322
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3323
    return temp;
 
3324
  }
 
3325
}
 
3326
inline void DescriptorProto::set_allocated_name(::std::string* name) {
 
3327
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3328
    delete name_;
 
3329
  }
 
3330
  if (name) {
 
3331
    set_has_name();
 
3332
    name_ = name;
 
3333
  } else {
 
3334
    clear_has_name();
 
3335
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3336
  }
 
3337
}
 
3338
 
 
3339
// repeated .google.protobuf.FieldDescriptorProto field = 2;
 
3340
inline int DescriptorProto::field_size() const {
 
3341
  return field_.size();
 
3342
}
 
3343
inline void DescriptorProto::clear_field() {
 
3344
  field_.Clear();
 
3345
}
 
3346
inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::field(int index) const {
 
3347
  return field_.Get(index);
 
3348
}
 
3349
inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_field(int index) {
 
3350
  return field_.Mutable(index);
 
3351
}
 
3352
inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_field() {
 
3353
  return field_.Add();
 
3354
}
 
3355
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
 
3356
DescriptorProto::field() const {
 
3357
  return field_;
 
3358
}
 
3359
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
 
3360
DescriptorProto::mutable_field() {
 
3361
  return &field_;
 
3362
}
 
3363
 
 
3364
// repeated .google.protobuf.FieldDescriptorProto extension = 6;
 
3365
inline int DescriptorProto::extension_size() const {
 
3366
  return extension_.size();
 
3367
}
 
3368
inline void DescriptorProto::clear_extension() {
 
3369
  extension_.Clear();
 
3370
}
 
3371
inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::extension(int index) const {
 
3372
  return extension_.Get(index);
 
3373
}
 
3374
inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) {
 
3375
  return extension_.Mutable(index);
 
3376
}
 
3377
inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_extension() {
 
3378
  return extension_.Add();
 
3379
}
 
3380
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
 
3381
DescriptorProto::extension() const {
 
3382
  return extension_;
 
3383
}
 
3384
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
 
3385
DescriptorProto::mutable_extension() {
 
3386
  return &extension_;
 
3387
}
 
3388
 
 
3389
// repeated .google.protobuf.DescriptorProto nested_type = 3;
 
3390
inline int DescriptorProto::nested_type_size() const {
 
3391
  return nested_type_.size();
 
3392
}
 
3393
inline void DescriptorProto::clear_nested_type() {
 
3394
  nested_type_.Clear();
 
3395
}
 
3396
inline const ::google::protobuf::DescriptorProto& DescriptorProto::nested_type(int index) const {
 
3397
  return nested_type_.Get(index);
 
3398
}
 
3399
inline ::google::protobuf::DescriptorProto* DescriptorProto::mutable_nested_type(int index) {
 
3400
  return nested_type_.Mutable(index);
 
3401
}
 
3402
inline ::google::protobuf::DescriptorProto* DescriptorProto::add_nested_type() {
 
3403
  return nested_type_.Add();
 
3404
}
 
3405
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
 
3406
DescriptorProto::nested_type() const {
 
3407
  return nested_type_;
 
3408
}
 
3409
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
 
3410
DescriptorProto::mutable_nested_type() {
 
3411
  return &nested_type_;
 
3412
}
 
3413
 
 
3414
// repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
 
3415
inline int DescriptorProto::enum_type_size() const {
 
3416
  return enum_type_.size();
 
3417
}
 
3418
inline void DescriptorProto::clear_enum_type() {
 
3419
  enum_type_.Clear();
 
3420
}
 
3421
inline const ::google::protobuf::EnumDescriptorProto& DescriptorProto::enum_type(int index) const {
 
3422
  return enum_type_.Get(index);
 
3423
}
 
3424
inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) {
 
3425
  return enum_type_.Mutable(index);
 
3426
}
 
3427
inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::add_enum_type() {
 
3428
  return enum_type_.Add();
 
3429
}
 
3430
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
 
3431
DescriptorProto::enum_type() const {
 
3432
  return enum_type_;
 
3433
}
 
3434
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
 
3435
DescriptorProto::mutable_enum_type() {
 
3436
  return &enum_type_;
 
3437
}
 
3438
 
 
3439
// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
 
3440
inline int DescriptorProto::extension_range_size() const {
 
3441
  return extension_range_.size();
 
3442
}
 
3443
inline void DescriptorProto::clear_extension_range() {
 
3444
  extension_range_.Clear();
 
3445
}
 
3446
inline const ::google::protobuf::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const {
 
3447
  return extension_range_.Get(index);
 
3448
}
 
3449
inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) {
 
3450
  return extension_range_.Mutable(index);
 
3451
}
 
3452
inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() {
 
3453
  return extension_range_.Add();
 
3454
}
 
3455
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >&
 
3456
DescriptorProto::extension_range() const {
 
3457
  return extension_range_;
 
3458
}
 
3459
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >*
 
3460
DescriptorProto::mutable_extension_range() {
 
3461
  return &extension_range_;
 
3462
}
 
3463
 
 
3464
// optional .google.protobuf.MessageOptions options = 7;
 
3465
inline bool DescriptorProto::has_options() const {
 
3466
  return (_has_bits_[0] & 0x00000040u) != 0;
 
3467
}
 
3468
inline void DescriptorProto::set_has_options() {
 
3469
  _has_bits_[0] |= 0x00000040u;
 
3470
}
 
3471
inline void DescriptorProto::clear_has_options() {
 
3472
  _has_bits_[0] &= ~0x00000040u;
 
3473
}
 
3474
inline void DescriptorProto::clear_options() {
 
3475
  if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear();
 
3476
  clear_has_options();
 
3477
}
 
3478
inline const ::google::protobuf::MessageOptions& DescriptorProto::options() const {
 
3479
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
3480
}
 
3481
inline ::google::protobuf::MessageOptions* DescriptorProto::mutable_options() {
 
3482
  set_has_options();
 
3483
  if (options_ == NULL) options_ = new ::google::protobuf::MessageOptions;
 
3484
  return options_;
 
3485
}
 
3486
inline ::google::protobuf::MessageOptions* DescriptorProto::release_options() {
 
3487
  clear_has_options();
 
3488
  ::google::protobuf::MessageOptions* temp = options_;
 
3489
  options_ = NULL;
 
3490
  return temp;
 
3491
}
 
3492
inline void DescriptorProto::set_allocated_options(::google::protobuf::MessageOptions* options) {
 
3493
  delete options_;
 
3494
  options_ = options;
 
3495
  if (options) {
 
3496
    set_has_options();
 
3497
  } else {
 
3498
    clear_has_options();
 
3499
  }
 
3500
}
 
3501
 
 
3502
// -------------------------------------------------------------------
 
3503
 
 
3504
// FieldDescriptorProto
 
3505
 
 
3506
// optional string name = 1;
 
3507
inline bool FieldDescriptorProto::has_name() const {
 
3508
  return (_has_bits_[0] & 0x00000001u) != 0;
 
3509
}
 
3510
inline void FieldDescriptorProto::set_has_name() {
 
3511
  _has_bits_[0] |= 0x00000001u;
 
3512
}
 
3513
inline void FieldDescriptorProto::clear_has_name() {
 
3514
  _has_bits_[0] &= ~0x00000001u;
 
3515
}
 
3516
inline void FieldDescriptorProto::clear_name() {
 
3517
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3518
    name_->clear();
 
3519
  }
 
3520
  clear_has_name();
 
3521
}
 
3522
inline const ::std::string& FieldDescriptorProto::name() const {
 
3523
  return *name_;
 
3524
}
 
3525
inline void FieldDescriptorProto::set_name(const ::std::string& value) {
 
3526
  set_has_name();
 
3527
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3528
    name_ = new ::std::string;
 
3529
  }
 
3530
  name_->assign(value);
 
3531
}
 
3532
inline void FieldDescriptorProto::set_name(const char* value) {
 
3533
  set_has_name();
 
3534
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3535
    name_ = new ::std::string;
 
3536
  }
 
3537
  name_->assign(value);
 
3538
}
 
3539
inline void FieldDescriptorProto::set_name(const char* value, size_t size) {
 
3540
  set_has_name();
 
3541
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3542
    name_ = new ::std::string;
 
3543
  }
 
3544
  name_->assign(reinterpret_cast<const char*>(value), size);
 
3545
}
 
3546
inline ::std::string* FieldDescriptorProto::mutable_name() {
 
3547
  set_has_name();
 
3548
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3549
    name_ = new ::std::string;
 
3550
  }
 
3551
  return name_;
 
3552
}
 
3553
inline ::std::string* FieldDescriptorProto::release_name() {
 
3554
  clear_has_name();
 
3555
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3556
    return NULL;
 
3557
  } else {
 
3558
    ::std::string* temp = name_;
 
3559
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3560
    return temp;
 
3561
  }
 
3562
}
 
3563
inline void FieldDescriptorProto::set_allocated_name(::std::string* name) {
 
3564
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3565
    delete name_;
 
3566
  }
 
3567
  if (name) {
 
3568
    set_has_name();
 
3569
    name_ = name;
 
3570
  } else {
 
3571
    clear_has_name();
 
3572
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3573
  }
 
3574
}
 
3575
 
 
3576
// optional int32 number = 3;
 
3577
inline bool FieldDescriptorProto::has_number() const {
 
3578
  return (_has_bits_[0] & 0x00000002u) != 0;
 
3579
}
 
3580
inline void FieldDescriptorProto::set_has_number() {
 
3581
  _has_bits_[0] |= 0x00000002u;
 
3582
}
 
3583
inline void FieldDescriptorProto::clear_has_number() {
 
3584
  _has_bits_[0] &= ~0x00000002u;
 
3585
}
 
3586
inline void FieldDescriptorProto::clear_number() {
 
3587
  number_ = 0;
 
3588
  clear_has_number();
 
3589
}
 
3590
inline ::google::protobuf::int32 FieldDescriptorProto::number() const {
 
3591
  return number_;
 
3592
}
 
3593
inline void FieldDescriptorProto::set_number(::google::protobuf::int32 value) {
 
3594
  set_has_number();
 
3595
  number_ = value;
 
3596
}
 
3597
 
 
3598
// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
 
3599
inline bool FieldDescriptorProto::has_label() const {
 
3600
  return (_has_bits_[0] & 0x00000004u) != 0;
 
3601
}
 
3602
inline void FieldDescriptorProto::set_has_label() {
 
3603
  _has_bits_[0] |= 0x00000004u;
 
3604
}
 
3605
inline void FieldDescriptorProto::clear_has_label() {
 
3606
  _has_bits_[0] &= ~0x00000004u;
 
3607
}
 
3608
inline void FieldDescriptorProto::clear_label() {
 
3609
  label_ = 1;
 
3610
  clear_has_label();
 
3611
}
 
3612
inline ::google::protobuf::FieldDescriptorProto_Label FieldDescriptorProto::label() const {
 
3613
  return static_cast< ::google::protobuf::FieldDescriptorProto_Label >(label_);
 
3614
}
 
3615
inline void FieldDescriptorProto::set_label(::google::protobuf::FieldDescriptorProto_Label value) {
 
3616
  assert(::google::protobuf::FieldDescriptorProto_Label_IsValid(value));
 
3617
  set_has_label();
 
3618
  label_ = value;
 
3619
}
 
3620
 
 
3621
// optional .google.protobuf.FieldDescriptorProto.Type type = 5;
 
3622
inline bool FieldDescriptorProto::has_type() const {
 
3623
  return (_has_bits_[0] & 0x00000008u) != 0;
 
3624
}
 
3625
inline void FieldDescriptorProto::set_has_type() {
 
3626
  _has_bits_[0] |= 0x00000008u;
 
3627
}
 
3628
inline void FieldDescriptorProto::clear_has_type() {
 
3629
  _has_bits_[0] &= ~0x00000008u;
 
3630
}
 
3631
inline void FieldDescriptorProto::clear_type() {
 
3632
  type_ = 1;
 
3633
  clear_has_type();
 
3634
}
 
3635
inline ::google::protobuf::FieldDescriptorProto_Type FieldDescriptorProto::type() const {
 
3636
  return static_cast< ::google::protobuf::FieldDescriptorProto_Type >(type_);
 
3637
}
 
3638
inline void FieldDescriptorProto::set_type(::google::protobuf::FieldDescriptorProto_Type value) {
 
3639
  assert(::google::protobuf::FieldDescriptorProto_Type_IsValid(value));
 
3640
  set_has_type();
 
3641
  type_ = value;
 
3642
}
 
3643
 
 
3644
// optional string type_name = 6;
 
3645
inline bool FieldDescriptorProto::has_type_name() const {
 
3646
  return (_has_bits_[0] & 0x00000010u) != 0;
 
3647
}
 
3648
inline void FieldDescriptorProto::set_has_type_name() {
 
3649
  _has_bits_[0] |= 0x00000010u;
 
3650
}
 
3651
inline void FieldDescriptorProto::clear_has_type_name() {
 
3652
  _has_bits_[0] &= ~0x00000010u;
 
3653
}
 
3654
inline void FieldDescriptorProto::clear_type_name() {
 
3655
  if (type_name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3656
    type_name_->clear();
 
3657
  }
 
3658
  clear_has_type_name();
 
3659
}
 
3660
inline const ::std::string& FieldDescriptorProto::type_name() const {
 
3661
  return *type_name_;
 
3662
}
 
3663
inline void FieldDescriptorProto::set_type_name(const ::std::string& value) {
 
3664
  set_has_type_name();
 
3665
  if (type_name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3666
    type_name_ = new ::std::string;
 
3667
  }
 
3668
  type_name_->assign(value);
 
3669
}
 
3670
inline void FieldDescriptorProto::set_type_name(const char* value) {
 
3671
  set_has_type_name();
 
3672
  if (type_name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3673
    type_name_ = new ::std::string;
 
3674
  }
 
3675
  type_name_->assign(value);
 
3676
}
 
3677
inline void FieldDescriptorProto::set_type_name(const char* value, size_t size) {
 
3678
  set_has_type_name();
 
3679
  if (type_name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3680
    type_name_ = new ::std::string;
 
3681
  }
 
3682
  type_name_->assign(reinterpret_cast<const char*>(value), size);
 
3683
}
 
3684
inline ::std::string* FieldDescriptorProto::mutable_type_name() {
 
3685
  set_has_type_name();
 
3686
  if (type_name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3687
    type_name_ = new ::std::string;
 
3688
  }
 
3689
  return type_name_;
 
3690
}
 
3691
inline ::std::string* FieldDescriptorProto::release_type_name() {
 
3692
  clear_has_type_name();
 
3693
  if (type_name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3694
    return NULL;
 
3695
  } else {
 
3696
    ::std::string* temp = type_name_;
 
3697
    type_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3698
    return temp;
 
3699
  }
 
3700
}
 
3701
inline void FieldDescriptorProto::set_allocated_type_name(::std::string* type_name) {
 
3702
  if (type_name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3703
    delete type_name_;
 
3704
  }
 
3705
  if (type_name) {
 
3706
    set_has_type_name();
 
3707
    type_name_ = type_name;
 
3708
  } else {
 
3709
    clear_has_type_name();
 
3710
    type_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3711
  }
 
3712
}
 
3713
 
 
3714
// optional string extendee = 2;
 
3715
inline bool FieldDescriptorProto::has_extendee() const {
 
3716
  return (_has_bits_[0] & 0x00000020u) != 0;
 
3717
}
 
3718
inline void FieldDescriptorProto::set_has_extendee() {
 
3719
  _has_bits_[0] |= 0x00000020u;
 
3720
}
 
3721
inline void FieldDescriptorProto::clear_has_extendee() {
 
3722
  _has_bits_[0] &= ~0x00000020u;
 
3723
}
 
3724
inline void FieldDescriptorProto::clear_extendee() {
 
3725
  if (extendee_ != &::google::protobuf::internal::GetEmptyString()) {
 
3726
    extendee_->clear();
 
3727
  }
 
3728
  clear_has_extendee();
 
3729
}
 
3730
inline const ::std::string& FieldDescriptorProto::extendee() const {
 
3731
  return *extendee_;
 
3732
}
 
3733
inline void FieldDescriptorProto::set_extendee(const ::std::string& value) {
 
3734
  set_has_extendee();
 
3735
  if (extendee_ == &::google::protobuf::internal::GetEmptyString()) {
 
3736
    extendee_ = new ::std::string;
 
3737
  }
 
3738
  extendee_->assign(value);
 
3739
}
 
3740
inline void FieldDescriptorProto::set_extendee(const char* value) {
 
3741
  set_has_extendee();
 
3742
  if (extendee_ == &::google::protobuf::internal::GetEmptyString()) {
 
3743
    extendee_ = new ::std::string;
 
3744
  }
 
3745
  extendee_->assign(value);
 
3746
}
 
3747
inline void FieldDescriptorProto::set_extendee(const char* value, size_t size) {
 
3748
  set_has_extendee();
 
3749
  if (extendee_ == &::google::protobuf::internal::GetEmptyString()) {
 
3750
    extendee_ = new ::std::string;
 
3751
  }
 
3752
  extendee_->assign(reinterpret_cast<const char*>(value), size);
 
3753
}
 
3754
inline ::std::string* FieldDescriptorProto::mutable_extendee() {
 
3755
  set_has_extendee();
 
3756
  if (extendee_ == &::google::protobuf::internal::GetEmptyString()) {
 
3757
    extendee_ = new ::std::string;
 
3758
  }
 
3759
  return extendee_;
 
3760
}
 
3761
inline ::std::string* FieldDescriptorProto::release_extendee() {
 
3762
  clear_has_extendee();
 
3763
  if (extendee_ == &::google::protobuf::internal::GetEmptyString()) {
 
3764
    return NULL;
 
3765
  } else {
 
3766
    ::std::string* temp = extendee_;
 
3767
    extendee_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3768
    return temp;
 
3769
  }
 
3770
}
 
3771
inline void FieldDescriptorProto::set_allocated_extendee(::std::string* extendee) {
 
3772
  if (extendee_ != &::google::protobuf::internal::GetEmptyString()) {
 
3773
    delete extendee_;
 
3774
  }
 
3775
  if (extendee) {
 
3776
    set_has_extendee();
 
3777
    extendee_ = extendee;
 
3778
  } else {
 
3779
    clear_has_extendee();
 
3780
    extendee_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3781
  }
 
3782
}
 
3783
 
 
3784
// optional string default_value = 7;
 
3785
inline bool FieldDescriptorProto::has_default_value() const {
 
3786
  return (_has_bits_[0] & 0x00000040u) != 0;
 
3787
}
 
3788
inline void FieldDescriptorProto::set_has_default_value() {
 
3789
  _has_bits_[0] |= 0x00000040u;
 
3790
}
 
3791
inline void FieldDescriptorProto::clear_has_default_value() {
 
3792
  _has_bits_[0] &= ~0x00000040u;
 
3793
}
 
3794
inline void FieldDescriptorProto::clear_default_value() {
 
3795
  if (default_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
3796
    default_value_->clear();
 
3797
  }
 
3798
  clear_has_default_value();
 
3799
}
 
3800
inline const ::std::string& FieldDescriptorProto::default_value() const {
 
3801
  return *default_value_;
 
3802
}
 
3803
inline void FieldDescriptorProto::set_default_value(const ::std::string& value) {
 
3804
  set_has_default_value();
 
3805
  if (default_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
3806
    default_value_ = new ::std::string;
 
3807
  }
 
3808
  default_value_->assign(value);
 
3809
}
 
3810
inline void FieldDescriptorProto::set_default_value(const char* value) {
 
3811
  set_has_default_value();
 
3812
  if (default_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
3813
    default_value_ = new ::std::string;
 
3814
  }
 
3815
  default_value_->assign(value);
 
3816
}
 
3817
inline void FieldDescriptorProto::set_default_value(const char* value, size_t size) {
 
3818
  set_has_default_value();
 
3819
  if (default_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
3820
    default_value_ = new ::std::string;
 
3821
  }
 
3822
  default_value_->assign(reinterpret_cast<const char*>(value), size);
 
3823
}
 
3824
inline ::std::string* FieldDescriptorProto::mutable_default_value() {
 
3825
  set_has_default_value();
 
3826
  if (default_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
3827
    default_value_ = new ::std::string;
 
3828
  }
 
3829
  return default_value_;
 
3830
}
 
3831
inline ::std::string* FieldDescriptorProto::release_default_value() {
 
3832
  clear_has_default_value();
 
3833
  if (default_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
3834
    return NULL;
 
3835
  } else {
 
3836
    ::std::string* temp = default_value_;
 
3837
    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3838
    return temp;
 
3839
  }
 
3840
}
 
3841
inline void FieldDescriptorProto::set_allocated_default_value(::std::string* default_value) {
 
3842
  if (default_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
3843
    delete default_value_;
 
3844
  }
 
3845
  if (default_value) {
 
3846
    set_has_default_value();
 
3847
    default_value_ = default_value;
 
3848
  } else {
 
3849
    clear_has_default_value();
 
3850
    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3851
  }
 
3852
}
 
3853
 
 
3854
// optional .google.protobuf.FieldOptions options = 8;
 
3855
inline bool FieldDescriptorProto::has_options() const {
 
3856
  return (_has_bits_[0] & 0x00000080u) != 0;
 
3857
}
 
3858
inline void FieldDescriptorProto::set_has_options() {
 
3859
  _has_bits_[0] |= 0x00000080u;
 
3860
}
 
3861
inline void FieldDescriptorProto::clear_has_options() {
 
3862
  _has_bits_[0] &= ~0x00000080u;
 
3863
}
 
3864
inline void FieldDescriptorProto::clear_options() {
 
3865
  if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear();
 
3866
  clear_has_options();
 
3867
}
 
3868
inline const ::google::protobuf::FieldOptions& FieldDescriptorProto::options() const {
 
3869
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
3870
}
 
3871
inline ::google::protobuf::FieldOptions* FieldDescriptorProto::mutable_options() {
 
3872
  set_has_options();
 
3873
  if (options_ == NULL) options_ = new ::google::protobuf::FieldOptions;
 
3874
  return options_;
 
3875
}
 
3876
inline ::google::protobuf::FieldOptions* FieldDescriptorProto::release_options() {
 
3877
  clear_has_options();
 
3878
  ::google::protobuf::FieldOptions* temp = options_;
 
3879
  options_ = NULL;
 
3880
  return temp;
 
3881
}
 
3882
inline void FieldDescriptorProto::set_allocated_options(::google::protobuf::FieldOptions* options) {
 
3883
  delete options_;
 
3884
  options_ = options;
 
3885
  if (options) {
 
3886
    set_has_options();
 
3887
  } else {
 
3888
    clear_has_options();
 
3889
  }
 
3890
}
 
3891
 
 
3892
// -------------------------------------------------------------------
 
3893
 
 
3894
// EnumDescriptorProto
 
3895
 
 
3896
// optional string name = 1;
 
3897
inline bool EnumDescriptorProto::has_name() const {
 
3898
  return (_has_bits_[0] & 0x00000001u) != 0;
 
3899
}
 
3900
inline void EnumDescriptorProto::set_has_name() {
 
3901
  _has_bits_[0] |= 0x00000001u;
 
3902
}
 
3903
inline void EnumDescriptorProto::clear_has_name() {
 
3904
  _has_bits_[0] &= ~0x00000001u;
 
3905
}
 
3906
inline void EnumDescriptorProto::clear_name() {
 
3907
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3908
    name_->clear();
 
3909
  }
 
3910
  clear_has_name();
 
3911
}
 
3912
inline const ::std::string& EnumDescriptorProto::name() const {
 
3913
  return *name_;
 
3914
}
 
3915
inline void EnumDescriptorProto::set_name(const ::std::string& value) {
 
3916
  set_has_name();
 
3917
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3918
    name_ = new ::std::string;
 
3919
  }
 
3920
  name_->assign(value);
 
3921
}
 
3922
inline void EnumDescriptorProto::set_name(const char* value) {
 
3923
  set_has_name();
 
3924
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3925
    name_ = new ::std::string;
 
3926
  }
 
3927
  name_->assign(value);
 
3928
}
 
3929
inline void EnumDescriptorProto::set_name(const char* value, size_t size) {
 
3930
  set_has_name();
 
3931
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3932
    name_ = new ::std::string;
 
3933
  }
 
3934
  name_->assign(reinterpret_cast<const char*>(value), size);
 
3935
}
 
3936
inline ::std::string* EnumDescriptorProto::mutable_name() {
 
3937
  set_has_name();
 
3938
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3939
    name_ = new ::std::string;
 
3940
  }
 
3941
  return name_;
 
3942
}
 
3943
inline ::std::string* EnumDescriptorProto::release_name() {
 
3944
  clear_has_name();
 
3945
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
3946
    return NULL;
 
3947
  } else {
 
3948
    ::std::string* temp = name_;
 
3949
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3950
    return temp;
 
3951
  }
 
3952
}
 
3953
inline void EnumDescriptorProto::set_allocated_name(::std::string* name) {
 
3954
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
3955
    delete name_;
 
3956
  }
 
3957
  if (name) {
 
3958
    set_has_name();
 
3959
    name_ = name;
 
3960
  } else {
 
3961
    clear_has_name();
 
3962
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
3963
  }
 
3964
}
 
3965
 
 
3966
// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
 
3967
inline int EnumDescriptorProto::value_size() const {
 
3968
  return value_.size();
 
3969
}
 
3970
inline void EnumDescriptorProto::clear_value() {
 
3971
  value_.Clear();
 
3972
}
 
3973
inline const ::google::protobuf::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const {
 
3974
  return value_.Get(index);
 
3975
}
 
3976
inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) {
 
3977
  return value_.Mutable(index);
 
3978
}
 
3979
inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::add_value() {
 
3980
  return value_.Add();
 
3981
}
 
3982
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >&
 
3983
EnumDescriptorProto::value() const {
 
3984
  return value_;
 
3985
}
 
3986
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >*
 
3987
EnumDescriptorProto::mutable_value() {
 
3988
  return &value_;
 
3989
}
 
3990
 
 
3991
// optional .google.protobuf.EnumOptions options = 3;
 
3992
inline bool EnumDescriptorProto::has_options() const {
 
3993
  return (_has_bits_[0] & 0x00000004u) != 0;
 
3994
}
 
3995
inline void EnumDescriptorProto::set_has_options() {
 
3996
  _has_bits_[0] |= 0x00000004u;
 
3997
}
 
3998
inline void EnumDescriptorProto::clear_has_options() {
 
3999
  _has_bits_[0] &= ~0x00000004u;
 
4000
}
 
4001
inline void EnumDescriptorProto::clear_options() {
 
4002
  if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear();
 
4003
  clear_has_options();
 
4004
}
 
4005
inline const ::google::protobuf::EnumOptions& EnumDescriptorProto::options() const {
 
4006
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
4007
}
 
4008
inline ::google::protobuf::EnumOptions* EnumDescriptorProto::mutable_options() {
 
4009
  set_has_options();
 
4010
  if (options_ == NULL) options_ = new ::google::protobuf::EnumOptions;
 
4011
  return options_;
 
4012
}
 
4013
inline ::google::protobuf::EnumOptions* EnumDescriptorProto::release_options() {
 
4014
  clear_has_options();
 
4015
  ::google::protobuf::EnumOptions* temp = options_;
 
4016
  options_ = NULL;
 
4017
  return temp;
 
4018
}
 
4019
inline void EnumDescriptorProto::set_allocated_options(::google::protobuf::EnumOptions* options) {
 
4020
  delete options_;
 
4021
  options_ = options;
 
4022
  if (options) {
 
4023
    set_has_options();
 
4024
  } else {
 
4025
    clear_has_options();
 
4026
  }
 
4027
}
 
4028
 
 
4029
// -------------------------------------------------------------------
 
4030
 
 
4031
// EnumValueDescriptorProto
 
4032
 
 
4033
// optional string name = 1;
 
4034
inline bool EnumValueDescriptorProto::has_name() const {
 
4035
  return (_has_bits_[0] & 0x00000001u) != 0;
 
4036
}
 
4037
inline void EnumValueDescriptorProto::set_has_name() {
 
4038
  _has_bits_[0] |= 0x00000001u;
 
4039
}
 
4040
inline void EnumValueDescriptorProto::clear_has_name() {
 
4041
  _has_bits_[0] &= ~0x00000001u;
 
4042
}
 
4043
inline void EnumValueDescriptorProto::clear_name() {
 
4044
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
4045
    name_->clear();
 
4046
  }
 
4047
  clear_has_name();
 
4048
}
 
4049
inline const ::std::string& EnumValueDescriptorProto::name() const {
 
4050
  return *name_;
 
4051
}
 
4052
inline void EnumValueDescriptorProto::set_name(const ::std::string& value) {
 
4053
  set_has_name();
 
4054
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4055
    name_ = new ::std::string;
 
4056
  }
 
4057
  name_->assign(value);
 
4058
}
 
4059
inline void EnumValueDescriptorProto::set_name(const char* value) {
 
4060
  set_has_name();
 
4061
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4062
    name_ = new ::std::string;
 
4063
  }
 
4064
  name_->assign(value);
 
4065
}
 
4066
inline void EnumValueDescriptorProto::set_name(const char* value, size_t size) {
 
4067
  set_has_name();
 
4068
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4069
    name_ = new ::std::string;
 
4070
  }
 
4071
  name_->assign(reinterpret_cast<const char*>(value), size);
 
4072
}
 
4073
inline ::std::string* EnumValueDescriptorProto::mutable_name() {
 
4074
  set_has_name();
 
4075
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4076
    name_ = new ::std::string;
 
4077
  }
 
4078
  return name_;
 
4079
}
 
4080
inline ::std::string* EnumValueDescriptorProto::release_name() {
 
4081
  clear_has_name();
 
4082
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4083
    return NULL;
 
4084
  } else {
 
4085
    ::std::string* temp = name_;
 
4086
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4087
    return temp;
 
4088
  }
 
4089
}
 
4090
inline void EnumValueDescriptorProto::set_allocated_name(::std::string* name) {
 
4091
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
4092
    delete name_;
 
4093
  }
 
4094
  if (name) {
 
4095
    set_has_name();
 
4096
    name_ = name;
 
4097
  } else {
 
4098
    clear_has_name();
 
4099
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4100
  }
 
4101
}
 
4102
 
 
4103
// optional int32 number = 2;
 
4104
inline bool EnumValueDescriptorProto::has_number() const {
 
4105
  return (_has_bits_[0] & 0x00000002u) != 0;
 
4106
}
 
4107
inline void EnumValueDescriptorProto::set_has_number() {
 
4108
  _has_bits_[0] |= 0x00000002u;
 
4109
}
 
4110
inline void EnumValueDescriptorProto::clear_has_number() {
 
4111
  _has_bits_[0] &= ~0x00000002u;
 
4112
}
 
4113
inline void EnumValueDescriptorProto::clear_number() {
 
4114
  number_ = 0;
 
4115
  clear_has_number();
 
4116
}
 
4117
inline ::google::protobuf::int32 EnumValueDescriptorProto::number() const {
 
4118
  return number_;
 
4119
}
 
4120
inline void EnumValueDescriptorProto::set_number(::google::protobuf::int32 value) {
 
4121
  set_has_number();
 
4122
  number_ = value;
 
4123
}
 
4124
 
 
4125
// optional .google.protobuf.EnumValueOptions options = 3;
 
4126
inline bool EnumValueDescriptorProto::has_options() const {
 
4127
  return (_has_bits_[0] & 0x00000004u) != 0;
 
4128
}
 
4129
inline void EnumValueDescriptorProto::set_has_options() {
 
4130
  _has_bits_[0] |= 0x00000004u;
 
4131
}
 
4132
inline void EnumValueDescriptorProto::clear_has_options() {
 
4133
  _has_bits_[0] &= ~0x00000004u;
 
4134
}
 
4135
inline void EnumValueDescriptorProto::clear_options() {
 
4136
  if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear();
 
4137
  clear_has_options();
 
4138
}
 
4139
inline const ::google::protobuf::EnumValueOptions& EnumValueDescriptorProto::options() const {
 
4140
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
4141
}
 
4142
inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::mutable_options() {
 
4143
  set_has_options();
 
4144
  if (options_ == NULL) options_ = new ::google::protobuf::EnumValueOptions;
 
4145
  return options_;
 
4146
}
 
4147
inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::release_options() {
 
4148
  clear_has_options();
 
4149
  ::google::protobuf::EnumValueOptions* temp = options_;
 
4150
  options_ = NULL;
 
4151
  return temp;
 
4152
}
 
4153
inline void EnumValueDescriptorProto::set_allocated_options(::google::protobuf::EnumValueOptions* options) {
 
4154
  delete options_;
 
4155
  options_ = options;
 
4156
  if (options) {
 
4157
    set_has_options();
 
4158
  } else {
 
4159
    clear_has_options();
 
4160
  }
 
4161
}
 
4162
 
 
4163
// -------------------------------------------------------------------
 
4164
 
 
4165
// ServiceDescriptorProto
 
4166
 
 
4167
// optional string name = 1;
 
4168
inline bool ServiceDescriptorProto::has_name() const {
 
4169
  return (_has_bits_[0] & 0x00000001u) != 0;
 
4170
}
 
4171
inline void ServiceDescriptorProto::set_has_name() {
 
4172
  _has_bits_[0] |= 0x00000001u;
 
4173
}
 
4174
inline void ServiceDescriptorProto::clear_has_name() {
 
4175
  _has_bits_[0] &= ~0x00000001u;
 
4176
}
 
4177
inline void ServiceDescriptorProto::clear_name() {
 
4178
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
4179
    name_->clear();
 
4180
  }
 
4181
  clear_has_name();
 
4182
}
 
4183
inline const ::std::string& ServiceDescriptorProto::name() const {
 
4184
  return *name_;
 
4185
}
 
4186
inline void ServiceDescriptorProto::set_name(const ::std::string& value) {
 
4187
  set_has_name();
 
4188
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4189
    name_ = new ::std::string;
 
4190
  }
 
4191
  name_->assign(value);
 
4192
}
 
4193
inline void ServiceDescriptorProto::set_name(const char* value) {
 
4194
  set_has_name();
 
4195
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4196
    name_ = new ::std::string;
 
4197
  }
 
4198
  name_->assign(value);
 
4199
}
 
4200
inline void ServiceDescriptorProto::set_name(const char* value, size_t size) {
 
4201
  set_has_name();
 
4202
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4203
    name_ = new ::std::string;
 
4204
  }
 
4205
  name_->assign(reinterpret_cast<const char*>(value), size);
 
4206
}
 
4207
inline ::std::string* ServiceDescriptorProto::mutable_name() {
 
4208
  set_has_name();
 
4209
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4210
    name_ = new ::std::string;
 
4211
  }
 
4212
  return name_;
 
4213
}
 
4214
inline ::std::string* ServiceDescriptorProto::release_name() {
 
4215
  clear_has_name();
 
4216
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4217
    return NULL;
 
4218
  } else {
 
4219
    ::std::string* temp = name_;
 
4220
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4221
    return temp;
 
4222
  }
 
4223
}
 
4224
inline void ServiceDescriptorProto::set_allocated_name(::std::string* name) {
 
4225
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
4226
    delete name_;
 
4227
  }
 
4228
  if (name) {
 
4229
    set_has_name();
 
4230
    name_ = name;
 
4231
  } else {
 
4232
    clear_has_name();
 
4233
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4234
  }
 
4235
}
 
4236
 
 
4237
// repeated .google.protobuf.MethodDescriptorProto method = 2;
 
4238
inline int ServiceDescriptorProto::method_size() const {
 
4239
  return method_.size();
 
4240
}
 
4241
inline void ServiceDescriptorProto::clear_method() {
 
4242
  method_.Clear();
 
4243
}
 
4244
inline const ::google::protobuf::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const {
 
4245
  return method_.Get(index);
 
4246
}
 
4247
inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) {
 
4248
  return method_.Mutable(index);
 
4249
}
 
4250
inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::add_method() {
 
4251
  return method_.Add();
 
4252
}
 
4253
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >&
 
4254
ServiceDescriptorProto::method() const {
 
4255
  return method_;
 
4256
}
 
4257
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >*
 
4258
ServiceDescriptorProto::mutable_method() {
 
4259
  return &method_;
 
4260
}
 
4261
 
 
4262
// optional .google.protobuf.ServiceOptions options = 3;
 
4263
inline bool ServiceDescriptorProto::has_options() const {
 
4264
  return (_has_bits_[0] & 0x00000004u) != 0;
 
4265
}
 
4266
inline void ServiceDescriptorProto::set_has_options() {
 
4267
  _has_bits_[0] |= 0x00000004u;
 
4268
}
 
4269
inline void ServiceDescriptorProto::clear_has_options() {
 
4270
  _has_bits_[0] &= ~0x00000004u;
 
4271
}
 
4272
inline void ServiceDescriptorProto::clear_options() {
 
4273
  if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear();
 
4274
  clear_has_options();
 
4275
}
 
4276
inline const ::google::protobuf::ServiceOptions& ServiceDescriptorProto::options() const {
 
4277
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
4278
}
 
4279
inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::mutable_options() {
 
4280
  set_has_options();
 
4281
  if (options_ == NULL) options_ = new ::google::protobuf::ServiceOptions;
 
4282
  return options_;
 
4283
}
 
4284
inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::release_options() {
 
4285
  clear_has_options();
 
4286
  ::google::protobuf::ServiceOptions* temp = options_;
 
4287
  options_ = NULL;
 
4288
  return temp;
 
4289
}
 
4290
inline void ServiceDescriptorProto::set_allocated_options(::google::protobuf::ServiceOptions* options) {
 
4291
  delete options_;
 
4292
  options_ = options;
 
4293
  if (options) {
 
4294
    set_has_options();
 
4295
  } else {
 
4296
    clear_has_options();
 
4297
  }
 
4298
}
 
4299
 
 
4300
// -------------------------------------------------------------------
 
4301
 
 
4302
// MethodDescriptorProto
 
4303
 
 
4304
// optional string name = 1;
 
4305
inline bool MethodDescriptorProto::has_name() const {
 
4306
  return (_has_bits_[0] & 0x00000001u) != 0;
 
4307
}
 
4308
inline void MethodDescriptorProto::set_has_name() {
 
4309
  _has_bits_[0] |= 0x00000001u;
 
4310
}
 
4311
inline void MethodDescriptorProto::clear_has_name() {
 
4312
  _has_bits_[0] &= ~0x00000001u;
 
4313
}
 
4314
inline void MethodDescriptorProto::clear_name() {
 
4315
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
4316
    name_->clear();
 
4317
  }
 
4318
  clear_has_name();
 
4319
}
 
4320
inline const ::std::string& MethodDescriptorProto::name() const {
 
4321
  return *name_;
 
4322
}
 
4323
inline void MethodDescriptorProto::set_name(const ::std::string& value) {
 
4324
  set_has_name();
 
4325
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4326
    name_ = new ::std::string;
 
4327
  }
 
4328
  name_->assign(value);
 
4329
}
 
4330
inline void MethodDescriptorProto::set_name(const char* value) {
 
4331
  set_has_name();
 
4332
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4333
    name_ = new ::std::string;
 
4334
  }
 
4335
  name_->assign(value);
 
4336
}
 
4337
inline void MethodDescriptorProto::set_name(const char* value, size_t size) {
 
4338
  set_has_name();
 
4339
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4340
    name_ = new ::std::string;
 
4341
  }
 
4342
  name_->assign(reinterpret_cast<const char*>(value), size);
 
4343
}
 
4344
inline ::std::string* MethodDescriptorProto::mutable_name() {
 
4345
  set_has_name();
 
4346
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4347
    name_ = new ::std::string;
 
4348
  }
 
4349
  return name_;
 
4350
}
 
4351
inline ::std::string* MethodDescriptorProto::release_name() {
 
4352
  clear_has_name();
 
4353
  if (name_ == &::google::protobuf::internal::GetEmptyString()) {
 
4354
    return NULL;
 
4355
  } else {
 
4356
    ::std::string* temp = name_;
 
4357
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4358
    return temp;
 
4359
  }
 
4360
}
 
4361
inline void MethodDescriptorProto::set_allocated_name(::std::string* name) {
 
4362
  if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 
4363
    delete name_;
 
4364
  }
 
4365
  if (name) {
 
4366
    set_has_name();
 
4367
    name_ = name;
 
4368
  } else {
 
4369
    clear_has_name();
 
4370
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4371
  }
 
4372
}
 
4373
 
 
4374
// optional string input_type = 2;
 
4375
inline bool MethodDescriptorProto::has_input_type() const {
 
4376
  return (_has_bits_[0] & 0x00000002u) != 0;
 
4377
}
 
4378
inline void MethodDescriptorProto::set_has_input_type() {
 
4379
  _has_bits_[0] |= 0x00000002u;
 
4380
}
 
4381
inline void MethodDescriptorProto::clear_has_input_type() {
 
4382
  _has_bits_[0] &= ~0x00000002u;
 
4383
}
 
4384
inline void MethodDescriptorProto::clear_input_type() {
 
4385
  if (input_type_ != &::google::protobuf::internal::GetEmptyString()) {
 
4386
    input_type_->clear();
 
4387
  }
 
4388
  clear_has_input_type();
 
4389
}
 
4390
inline const ::std::string& MethodDescriptorProto::input_type() const {
 
4391
  return *input_type_;
 
4392
}
 
4393
inline void MethodDescriptorProto::set_input_type(const ::std::string& value) {
 
4394
  set_has_input_type();
 
4395
  if (input_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4396
    input_type_ = new ::std::string;
 
4397
  }
 
4398
  input_type_->assign(value);
 
4399
}
 
4400
inline void MethodDescriptorProto::set_input_type(const char* value) {
 
4401
  set_has_input_type();
 
4402
  if (input_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4403
    input_type_ = new ::std::string;
 
4404
  }
 
4405
  input_type_->assign(value);
 
4406
}
 
4407
inline void MethodDescriptorProto::set_input_type(const char* value, size_t size) {
 
4408
  set_has_input_type();
 
4409
  if (input_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4410
    input_type_ = new ::std::string;
 
4411
  }
 
4412
  input_type_->assign(reinterpret_cast<const char*>(value), size);
 
4413
}
 
4414
inline ::std::string* MethodDescriptorProto::mutable_input_type() {
 
4415
  set_has_input_type();
 
4416
  if (input_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4417
    input_type_ = new ::std::string;
 
4418
  }
 
4419
  return input_type_;
 
4420
}
 
4421
inline ::std::string* MethodDescriptorProto::release_input_type() {
 
4422
  clear_has_input_type();
 
4423
  if (input_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4424
    return NULL;
 
4425
  } else {
 
4426
    ::std::string* temp = input_type_;
 
4427
    input_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4428
    return temp;
 
4429
  }
 
4430
}
 
4431
inline void MethodDescriptorProto::set_allocated_input_type(::std::string* input_type) {
 
4432
  if (input_type_ != &::google::protobuf::internal::GetEmptyString()) {
 
4433
    delete input_type_;
 
4434
  }
 
4435
  if (input_type) {
 
4436
    set_has_input_type();
 
4437
    input_type_ = input_type;
 
4438
  } else {
 
4439
    clear_has_input_type();
 
4440
    input_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4441
  }
 
4442
}
 
4443
 
 
4444
// optional string output_type = 3;
 
4445
inline bool MethodDescriptorProto::has_output_type() const {
 
4446
  return (_has_bits_[0] & 0x00000004u) != 0;
 
4447
}
 
4448
inline void MethodDescriptorProto::set_has_output_type() {
 
4449
  _has_bits_[0] |= 0x00000004u;
 
4450
}
 
4451
inline void MethodDescriptorProto::clear_has_output_type() {
 
4452
  _has_bits_[0] &= ~0x00000004u;
 
4453
}
 
4454
inline void MethodDescriptorProto::clear_output_type() {
 
4455
  if (output_type_ != &::google::protobuf::internal::GetEmptyString()) {
 
4456
    output_type_->clear();
 
4457
  }
 
4458
  clear_has_output_type();
 
4459
}
 
4460
inline const ::std::string& MethodDescriptorProto::output_type() const {
 
4461
  return *output_type_;
 
4462
}
 
4463
inline void MethodDescriptorProto::set_output_type(const ::std::string& value) {
 
4464
  set_has_output_type();
 
4465
  if (output_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4466
    output_type_ = new ::std::string;
 
4467
  }
 
4468
  output_type_->assign(value);
 
4469
}
 
4470
inline void MethodDescriptorProto::set_output_type(const char* value) {
 
4471
  set_has_output_type();
 
4472
  if (output_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4473
    output_type_ = new ::std::string;
 
4474
  }
 
4475
  output_type_->assign(value);
 
4476
}
 
4477
inline void MethodDescriptorProto::set_output_type(const char* value, size_t size) {
 
4478
  set_has_output_type();
 
4479
  if (output_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4480
    output_type_ = new ::std::string;
 
4481
  }
 
4482
  output_type_->assign(reinterpret_cast<const char*>(value), size);
 
4483
}
 
4484
inline ::std::string* MethodDescriptorProto::mutable_output_type() {
 
4485
  set_has_output_type();
 
4486
  if (output_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4487
    output_type_ = new ::std::string;
 
4488
  }
 
4489
  return output_type_;
 
4490
}
 
4491
inline ::std::string* MethodDescriptorProto::release_output_type() {
 
4492
  clear_has_output_type();
 
4493
  if (output_type_ == &::google::protobuf::internal::GetEmptyString()) {
 
4494
    return NULL;
 
4495
  } else {
 
4496
    ::std::string* temp = output_type_;
 
4497
    output_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4498
    return temp;
 
4499
  }
 
4500
}
 
4501
inline void MethodDescriptorProto::set_allocated_output_type(::std::string* output_type) {
 
4502
  if (output_type_ != &::google::protobuf::internal::GetEmptyString()) {
 
4503
    delete output_type_;
 
4504
  }
 
4505
  if (output_type) {
 
4506
    set_has_output_type();
 
4507
    output_type_ = output_type;
 
4508
  } else {
 
4509
    clear_has_output_type();
 
4510
    output_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4511
  }
 
4512
}
 
4513
 
 
4514
// optional .google.protobuf.MethodOptions options = 4;
 
4515
inline bool MethodDescriptorProto::has_options() const {
 
4516
  return (_has_bits_[0] & 0x00000008u) != 0;
 
4517
}
 
4518
inline void MethodDescriptorProto::set_has_options() {
 
4519
  _has_bits_[0] |= 0x00000008u;
 
4520
}
 
4521
inline void MethodDescriptorProto::clear_has_options() {
 
4522
  _has_bits_[0] &= ~0x00000008u;
 
4523
}
 
4524
inline void MethodDescriptorProto::clear_options() {
 
4525
  if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear();
 
4526
  clear_has_options();
 
4527
}
 
4528
inline const ::google::protobuf::MethodOptions& MethodDescriptorProto::options() const {
 
4529
  return options_ != NULL ? *options_ : *default_instance_->options_;
 
4530
}
 
4531
inline ::google::protobuf::MethodOptions* MethodDescriptorProto::mutable_options() {
 
4532
  set_has_options();
 
4533
  if (options_ == NULL) options_ = new ::google::protobuf::MethodOptions;
 
4534
  return options_;
 
4535
}
 
4536
inline ::google::protobuf::MethodOptions* MethodDescriptorProto::release_options() {
 
4537
  clear_has_options();
 
4538
  ::google::protobuf::MethodOptions* temp = options_;
 
4539
  options_ = NULL;
 
4540
  return temp;
 
4541
}
 
4542
inline void MethodDescriptorProto::set_allocated_options(::google::protobuf::MethodOptions* options) {
 
4543
  delete options_;
 
4544
  options_ = options;
 
4545
  if (options) {
 
4546
    set_has_options();
 
4547
  } else {
 
4548
    clear_has_options();
 
4549
  }
 
4550
}
 
4551
 
 
4552
// -------------------------------------------------------------------
 
4553
 
 
4554
// FileOptions
 
4555
 
 
4556
// optional string java_package = 1;
 
4557
inline bool FileOptions::has_java_package() const {
 
4558
  return (_has_bits_[0] & 0x00000001u) != 0;
 
4559
}
 
4560
inline void FileOptions::set_has_java_package() {
 
4561
  _has_bits_[0] |= 0x00000001u;
 
4562
}
 
4563
inline void FileOptions::clear_has_java_package() {
 
4564
  _has_bits_[0] &= ~0x00000001u;
 
4565
}
 
4566
inline void FileOptions::clear_java_package() {
 
4567
  if (java_package_ != &::google::protobuf::internal::GetEmptyString()) {
 
4568
    java_package_->clear();
 
4569
  }
 
4570
  clear_has_java_package();
 
4571
}
 
4572
inline const ::std::string& FileOptions::java_package() const {
 
4573
  return *java_package_;
 
4574
}
 
4575
inline void FileOptions::set_java_package(const ::std::string& value) {
 
4576
  set_has_java_package();
 
4577
  if (java_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4578
    java_package_ = new ::std::string;
 
4579
  }
 
4580
  java_package_->assign(value);
 
4581
}
 
4582
inline void FileOptions::set_java_package(const char* value) {
 
4583
  set_has_java_package();
 
4584
  if (java_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4585
    java_package_ = new ::std::string;
 
4586
  }
 
4587
  java_package_->assign(value);
 
4588
}
 
4589
inline void FileOptions::set_java_package(const char* value, size_t size) {
 
4590
  set_has_java_package();
 
4591
  if (java_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4592
    java_package_ = new ::std::string;
 
4593
  }
 
4594
  java_package_->assign(reinterpret_cast<const char*>(value), size);
 
4595
}
 
4596
inline ::std::string* FileOptions::mutable_java_package() {
 
4597
  set_has_java_package();
 
4598
  if (java_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4599
    java_package_ = new ::std::string;
 
4600
  }
 
4601
  return java_package_;
 
4602
}
 
4603
inline ::std::string* FileOptions::release_java_package() {
 
4604
  clear_has_java_package();
 
4605
  if (java_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4606
    return NULL;
 
4607
  } else {
 
4608
    ::std::string* temp = java_package_;
 
4609
    java_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4610
    return temp;
 
4611
  }
 
4612
}
 
4613
inline void FileOptions::set_allocated_java_package(::std::string* java_package) {
 
4614
  if (java_package_ != &::google::protobuf::internal::GetEmptyString()) {
 
4615
    delete java_package_;
 
4616
  }
 
4617
  if (java_package) {
 
4618
    set_has_java_package();
 
4619
    java_package_ = java_package;
 
4620
  } else {
 
4621
    clear_has_java_package();
 
4622
    java_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4623
  }
 
4624
}
 
4625
 
 
4626
// optional string java_outer_classname = 8;
 
4627
inline bool FileOptions::has_java_outer_classname() const {
 
4628
  return (_has_bits_[0] & 0x00000002u) != 0;
 
4629
}
 
4630
inline void FileOptions::set_has_java_outer_classname() {
 
4631
  _has_bits_[0] |= 0x00000002u;
 
4632
}
 
4633
inline void FileOptions::clear_has_java_outer_classname() {
 
4634
  _has_bits_[0] &= ~0x00000002u;
 
4635
}
 
4636
inline void FileOptions::clear_java_outer_classname() {
 
4637
  if (java_outer_classname_ != &::google::protobuf::internal::GetEmptyString()) {
 
4638
    java_outer_classname_->clear();
 
4639
  }
 
4640
  clear_has_java_outer_classname();
 
4641
}
 
4642
inline const ::std::string& FileOptions::java_outer_classname() const {
 
4643
  return *java_outer_classname_;
 
4644
}
 
4645
inline void FileOptions::set_java_outer_classname(const ::std::string& value) {
 
4646
  set_has_java_outer_classname();
 
4647
  if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) {
 
4648
    java_outer_classname_ = new ::std::string;
 
4649
  }
 
4650
  java_outer_classname_->assign(value);
 
4651
}
 
4652
inline void FileOptions::set_java_outer_classname(const char* value) {
 
4653
  set_has_java_outer_classname();
 
4654
  if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) {
 
4655
    java_outer_classname_ = new ::std::string;
 
4656
  }
 
4657
  java_outer_classname_->assign(value);
 
4658
}
 
4659
inline void FileOptions::set_java_outer_classname(const char* value, size_t size) {
 
4660
  set_has_java_outer_classname();
 
4661
  if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) {
 
4662
    java_outer_classname_ = new ::std::string;
 
4663
  }
 
4664
  java_outer_classname_->assign(reinterpret_cast<const char*>(value), size);
 
4665
}
 
4666
inline ::std::string* FileOptions::mutable_java_outer_classname() {
 
4667
  set_has_java_outer_classname();
 
4668
  if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) {
 
4669
    java_outer_classname_ = new ::std::string;
 
4670
  }
 
4671
  return java_outer_classname_;
 
4672
}
 
4673
inline ::std::string* FileOptions::release_java_outer_classname() {
 
4674
  clear_has_java_outer_classname();
 
4675
  if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) {
 
4676
    return NULL;
 
4677
  } else {
 
4678
    ::std::string* temp = java_outer_classname_;
 
4679
    java_outer_classname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4680
    return temp;
 
4681
  }
 
4682
}
 
4683
inline void FileOptions::set_allocated_java_outer_classname(::std::string* java_outer_classname) {
 
4684
  if (java_outer_classname_ != &::google::protobuf::internal::GetEmptyString()) {
 
4685
    delete java_outer_classname_;
 
4686
  }
 
4687
  if (java_outer_classname) {
 
4688
    set_has_java_outer_classname();
 
4689
    java_outer_classname_ = java_outer_classname;
 
4690
  } else {
 
4691
    clear_has_java_outer_classname();
 
4692
    java_outer_classname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4693
  }
 
4694
}
 
4695
 
 
4696
// optional bool java_multiple_files = 10 [default = false];
 
4697
inline bool FileOptions::has_java_multiple_files() const {
 
4698
  return (_has_bits_[0] & 0x00000004u) != 0;
 
4699
}
 
4700
inline void FileOptions::set_has_java_multiple_files() {
 
4701
  _has_bits_[0] |= 0x00000004u;
 
4702
}
 
4703
inline void FileOptions::clear_has_java_multiple_files() {
 
4704
  _has_bits_[0] &= ~0x00000004u;
 
4705
}
 
4706
inline void FileOptions::clear_java_multiple_files() {
 
4707
  java_multiple_files_ = false;
 
4708
  clear_has_java_multiple_files();
 
4709
}
 
4710
inline bool FileOptions::java_multiple_files() const {
 
4711
  return java_multiple_files_;
 
4712
}
 
4713
inline void FileOptions::set_java_multiple_files(bool value) {
 
4714
  set_has_java_multiple_files();
 
4715
  java_multiple_files_ = value;
 
4716
}
 
4717
 
 
4718
// optional bool retain_unknown_fields = 12 [default = false];
 
4719
inline bool FileOptions::has_retain_unknown_fields() const {
 
4720
  return (_has_bits_[0] & 0x00000008u) != 0;
 
4721
}
 
4722
inline void FileOptions::set_has_retain_unknown_fields() {
 
4723
  _has_bits_[0] |= 0x00000008u;
 
4724
}
 
4725
inline void FileOptions::clear_has_retain_unknown_fields() {
 
4726
  _has_bits_[0] &= ~0x00000008u;
 
4727
}
 
4728
inline void FileOptions::clear_retain_unknown_fields() {
 
4729
  retain_unknown_fields_ = false;
 
4730
  clear_has_retain_unknown_fields();
 
4731
}
 
4732
inline bool FileOptions::retain_unknown_fields() const {
 
4733
  return retain_unknown_fields_;
 
4734
}
 
4735
inline void FileOptions::set_retain_unknown_fields(bool value) {
 
4736
  set_has_retain_unknown_fields();
 
4737
  retain_unknown_fields_ = value;
 
4738
}
 
4739
 
 
4740
// optional bool java_generate_equals_and_hash = 20 [default = false];
 
4741
inline bool FileOptions::has_java_generate_equals_and_hash() const {
 
4742
  return (_has_bits_[0] & 0x00000010u) != 0;
 
4743
}
 
4744
inline void FileOptions::set_has_java_generate_equals_and_hash() {
 
4745
  _has_bits_[0] |= 0x00000010u;
 
4746
}
 
4747
inline void FileOptions::clear_has_java_generate_equals_and_hash() {
 
4748
  _has_bits_[0] &= ~0x00000010u;
 
4749
}
 
4750
inline void FileOptions::clear_java_generate_equals_and_hash() {
 
4751
  java_generate_equals_and_hash_ = false;
 
4752
  clear_has_java_generate_equals_and_hash();
 
4753
}
 
4754
inline bool FileOptions::java_generate_equals_and_hash() const {
 
4755
  return java_generate_equals_and_hash_;
 
4756
}
 
4757
inline void FileOptions::set_java_generate_equals_and_hash(bool value) {
 
4758
  set_has_java_generate_equals_and_hash();
 
4759
  java_generate_equals_and_hash_ = value;
 
4760
}
 
4761
 
 
4762
// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
 
4763
inline bool FileOptions::has_optimize_for() const {
 
4764
  return (_has_bits_[0] & 0x00000020u) != 0;
 
4765
}
 
4766
inline void FileOptions::set_has_optimize_for() {
 
4767
  _has_bits_[0] |= 0x00000020u;
 
4768
}
 
4769
inline void FileOptions::clear_has_optimize_for() {
 
4770
  _has_bits_[0] &= ~0x00000020u;
 
4771
}
 
4772
inline void FileOptions::clear_optimize_for() {
 
4773
  optimize_for_ = 1;
 
4774
  clear_has_optimize_for();
 
4775
}
 
4776
inline ::google::protobuf::FileOptions_OptimizeMode FileOptions::optimize_for() const {
 
4777
  return static_cast< ::google::protobuf::FileOptions_OptimizeMode >(optimize_for_);
 
4778
}
 
4779
inline void FileOptions::set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value) {
 
4780
  assert(::google::protobuf::FileOptions_OptimizeMode_IsValid(value));
 
4781
  set_has_optimize_for();
 
4782
  optimize_for_ = value;
 
4783
}
 
4784
 
 
4785
// optional string go_package = 11;
 
4786
inline bool FileOptions::has_go_package() const {
 
4787
  return (_has_bits_[0] & 0x00000040u) != 0;
 
4788
}
 
4789
inline void FileOptions::set_has_go_package() {
 
4790
  _has_bits_[0] |= 0x00000040u;
 
4791
}
 
4792
inline void FileOptions::clear_has_go_package() {
 
4793
  _has_bits_[0] &= ~0x00000040u;
 
4794
}
 
4795
inline void FileOptions::clear_go_package() {
 
4796
  if (go_package_ != &::google::protobuf::internal::GetEmptyString()) {
 
4797
    go_package_->clear();
 
4798
  }
 
4799
  clear_has_go_package();
 
4800
}
 
4801
inline const ::std::string& FileOptions::go_package() const {
 
4802
  return *go_package_;
 
4803
}
 
4804
inline void FileOptions::set_go_package(const ::std::string& value) {
 
4805
  set_has_go_package();
 
4806
  if (go_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4807
    go_package_ = new ::std::string;
 
4808
  }
 
4809
  go_package_->assign(value);
 
4810
}
 
4811
inline void FileOptions::set_go_package(const char* value) {
 
4812
  set_has_go_package();
 
4813
  if (go_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4814
    go_package_ = new ::std::string;
 
4815
  }
 
4816
  go_package_->assign(value);
 
4817
}
 
4818
inline void FileOptions::set_go_package(const char* value, size_t size) {
 
4819
  set_has_go_package();
 
4820
  if (go_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4821
    go_package_ = new ::std::string;
 
4822
  }
 
4823
  go_package_->assign(reinterpret_cast<const char*>(value), size);
 
4824
}
 
4825
inline ::std::string* FileOptions::mutable_go_package() {
 
4826
  set_has_go_package();
 
4827
  if (go_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4828
    go_package_ = new ::std::string;
 
4829
  }
 
4830
  return go_package_;
 
4831
}
 
4832
inline ::std::string* FileOptions::release_go_package() {
 
4833
  clear_has_go_package();
 
4834
  if (go_package_ == &::google::protobuf::internal::GetEmptyString()) {
 
4835
    return NULL;
 
4836
  } else {
 
4837
    ::std::string* temp = go_package_;
 
4838
    go_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4839
    return temp;
 
4840
  }
 
4841
}
 
4842
inline void FileOptions::set_allocated_go_package(::std::string* go_package) {
 
4843
  if (go_package_ != &::google::protobuf::internal::GetEmptyString()) {
 
4844
    delete go_package_;
 
4845
  }
 
4846
  if (go_package) {
 
4847
    set_has_go_package();
 
4848
    go_package_ = go_package;
 
4849
  } else {
 
4850
    clear_has_go_package();
 
4851
    go_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
4852
  }
 
4853
}
 
4854
 
 
4855
// optional bool cc_generic_services = 16 [default = false];
 
4856
inline bool FileOptions::has_cc_generic_services() const {
 
4857
  return (_has_bits_[0] & 0x00000080u) != 0;
 
4858
}
 
4859
inline void FileOptions::set_has_cc_generic_services() {
 
4860
  _has_bits_[0] |= 0x00000080u;
 
4861
}
 
4862
inline void FileOptions::clear_has_cc_generic_services() {
 
4863
  _has_bits_[0] &= ~0x00000080u;
 
4864
}
 
4865
inline void FileOptions::clear_cc_generic_services() {
 
4866
  cc_generic_services_ = false;
 
4867
  clear_has_cc_generic_services();
 
4868
}
 
4869
inline bool FileOptions::cc_generic_services() const {
 
4870
  return cc_generic_services_;
 
4871
}
 
4872
inline void FileOptions::set_cc_generic_services(bool value) {
 
4873
  set_has_cc_generic_services();
 
4874
  cc_generic_services_ = value;
 
4875
}
 
4876
 
 
4877
// optional bool java_generic_services = 17 [default = false];
 
4878
inline bool FileOptions::has_java_generic_services() const {
 
4879
  return (_has_bits_[0] & 0x00000100u) != 0;
 
4880
}
 
4881
inline void FileOptions::set_has_java_generic_services() {
 
4882
  _has_bits_[0] |= 0x00000100u;
 
4883
}
 
4884
inline void FileOptions::clear_has_java_generic_services() {
 
4885
  _has_bits_[0] &= ~0x00000100u;
 
4886
}
 
4887
inline void FileOptions::clear_java_generic_services() {
 
4888
  java_generic_services_ = false;
 
4889
  clear_has_java_generic_services();
 
4890
}
 
4891
inline bool FileOptions::java_generic_services() const {
 
4892
  return java_generic_services_;
 
4893
}
 
4894
inline void FileOptions::set_java_generic_services(bool value) {
 
4895
  set_has_java_generic_services();
 
4896
  java_generic_services_ = value;
 
4897
}
 
4898
 
 
4899
// optional bool py_generic_services = 18 [default = false];
 
4900
inline bool FileOptions::has_py_generic_services() const {
 
4901
  return (_has_bits_[0] & 0x00000200u) != 0;
 
4902
}
 
4903
inline void FileOptions::set_has_py_generic_services() {
 
4904
  _has_bits_[0] |= 0x00000200u;
 
4905
}
 
4906
inline void FileOptions::clear_has_py_generic_services() {
 
4907
  _has_bits_[0] &= ~0x00000200u;
 
4908
}
 
4909
inline void FileOptions::clear_py_generic_services() {
 
4910
  py_generic_services_ = false;
 
4911
  clear_has_py_generic_services();
 
4912
}
 
4913
inline bool FileOptions::py_generic_services() const {
 
4914
  return py_generic_services_;
 
4915
}
 
4916
inline void FileOptions::set_py_generic_services(bool value) {
 
4917
  set_has_py_generic_services();
 
4918
  py_generic_services_ = value;
 
4919
}
 
4920
 
 
4921
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
4922
inline int FileOptions::uninterpreted_option_size() const {
 
4923
  return uninterpreted_option_.size();
 
4924
}
 
4925
inline void FileOptions::clear_uninterpreted_option() {
 
4926
  uninterpreted_option_.Clear();
 
4927
}
 
4928
inline const ::google::protobuf::UninterpretedOption& FileOptions::uninterpreted_option(int index) const {
 
4929
  return uninterpreted_option_.Get(index);
 
4930
}
 
4931
inline ::google::protobuf::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) {
 
4932
  return uninterpreted_option_.Mutable(index);
 
4933
}
 
4934
inline ::google::protobuf::UninterpretedOption* FileOptions::add_uninterpreted_option() {
 
4935
  return uninterpreted_option_.Add();
 
4936
}
 
4937
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
4938
FileOptions::uninterpreted_option() const {
 
4939
  return uninterpreted_option_;
 
4940
}
 
4941
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
4942
FileOptions::mutable_uninterpreted_option() {
 
4943
  return &uninterpreted_option_;
 
4944
}
 
4945
 
 
4946
// -------------------------------------------------------------------
 
4947
 
 
4948
// MessageOptions
 
4949
 
 
4950
// optional bool message_set_wire_format = 1 [default = false];
 
4951
inline bool MessageOptions::has_message_set_wire_format() const {
 
4952
  return (_has_bits_[0] & 0x00000001u) != 0;
 
4953
}
 
4954
inline void MessageOptions::set_has_message_set_wire_format() {
 
4955
  _has_bits_[0] |= 0x00000001u;
 
4956
}
 
4957
inline void MessageOptions::clear_has_message_set_wire_format() {
 
4958
  _has_bits_[0] &= ~0x00000001u;
 
4959
}
 
4960
inline void MessageOptions::clear_message_set_wire_format() {
 
4961
  message_set_wire_format_ = false;
 
4962
  clear_has_message_set_wire_format();
 
4963
}
 
4964
inline bool MessageOptions::message_set_wire_format() const {
 
4965
  return message_set_wire_format_;
 
4966
}
 
4967
inline void MessageOptions::set_message_set_wire_format(bool value) {
 
4968
  set_has_message_set_wire_format();
 
4969
  message_set_wire_format_ = value;
 
4970
}
 
4971
 
 
4972
// optional bool no_standard_descriptor_accessor = 2 [default = false];
 
4973
inline bool MessageOptions::has_no_standard_descriptor_accessor() const {
 
4974
  return (_has_bits_[0] & 0x00000002u) != 0;
 
4975
}
 
4976
inline void MessageOptions::set_has_no_standard_descriptor_accessor() {
 
4977
  _has_bits_[0] |= 0x00000002u;
 
4978
}
 
4979
inline void MessageOptions::clear_has_no_standard_descriptor_accessor() {
 
4980
  _has_bits_[0] &= ~0x00000002u;
 
4981
}
 
4982
inline void MessageOptions::clear_no_standard_descriptor_accessor() {
 
4983
  no_standard_descriptor_accessor_ = false;
 
4984
  clear_has_no_standard_descriptor_accessor();
 
4985
}
 
4986
inline bool MessageOptions::no_standard_descriptor_accessor() const {
 
4987
  return no_standard_descriptor_accessor_;
 
4988
}
 
4989
inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) {
 
4990
  set_has_no_standard_descriptor_accessor();
 
4991
  no_standard_descriptor_accessor_ = value;
 
4992
}
 
4993
 
 
4994
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
4995
inline int MessageOptions::uninterpreted_option_size() const {
 
4996
  return uninterpreted_option_.size();
 
4997
}
 
4998
inline void MessageOptions::clear_uninterpreted_option() {
 
4999
  uninterpreted_option_.Clear();
 
5000
}
 
5001
inline const ::google::protobuf::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const {
 
5002
  return uninterpreted_option_.Get(index);
 
5003
}
 
5004
inline ::google::protobuf::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) {
 
5005
  return uninterpreted_option_.Mutable(index);
 
5006
}
 
5007
inline ::google::protobuf::UninterpretedOption* MessageOptions::add_uninterpreted_option() {
 
5008
  return uninterpreted_option_.Add();
 
5009
}
 
5010
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
5011
MessageOptions::uninterpreted_option() const {
 
5012
  return uninterpreted_option_;
 
5013
}
 
5014
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
5015
MessageOptions::mutable_uninterpreted_option() {
 
5016
  return &uninterpreted_option_;
 
5017
}
 
5018
 
 
5019
// -------------------------------------------------------------------
 
5020
 
 
5021
// FieldOptions
 
5022
 
 
5023
// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
 
5024
inline bool FieldOptions::has_ctype() const {
 
5025
  return (_has_bits_[0] & 0x00000001u) != 0;
 
5026
}
 
5027
inline void FieldOptions::set_has_ctype() {
 
5028
  _has_bits_[0] |= 0x00000001u;
 
5029
}
 
5030
inline void FieldOptions::clear_has_ctype() {
 
5031
  _has_bits_[0] &= ~0x00000001u;
 
5032
}
 
5033
inline void FieldOptions::clear_ctype() {
 
5034
  ctype_ = 0;
 
5035
  clear_has_ctype();
 
5036
}
 
5037
inline ::google::protobuf::FieldOptions_CType FieldOptions::ctype() const {
 
5038
  return static_cast< ::google::protobuf::FieldOptions_CType >(ctype_);
 
5039
}
 
5040
inline void FieldOptions::set_ctype(::google::protobuf::FieldOptions_CType value) {
 
5041
  assert(::google::protobuf::FieldOptions_CType_IsValid(value));
 
5042
  set_has_ctype();
 
5043
  ctype_ = value;
 
5044
}
 
5045
 
 
5046
// optional bool packed = 2;
 
5047
inline bool FieldOptions::has_packed() const {
 
5048
  return (_has_bits_[0] & 0x00000002u) != 0;
 
5049
}
 
5050
inline void FieldOptions::set_has_packed() {
 
5051
  _has_bits_[0] |= 0x00000002u;
 
5052
}
 
5053
inline void FieldOptions::clear_has_packed() {
 
5054
  _has_bits_[0] &= ~0x00000002u;
 
5055
}
 
5056
inline void FieldOptions::clear_packed() {
 
5057
  packed_ = false;
 
5058
  clear_has_packed();
 
5059
}
 
5060
inline bool FieldOptions::packed() const {
 
5061
  return packed_;
 
5062
}
 
5063
inline void FieldOptions::set_packed(bool value) {
 
5064
  set_has_packed();
 
5065
  packed_ = value;
 
5066
}
 
5067
 
 
5068
// optional bool lazy = 5 [default = false];
 
5069
inline bool FieldOptions::has_lazy() const {
 
5070
  return (_has_bits_[0] & 0x00000004u) != 0;
 
5071
}
 
5072
inline void FieldOptions::set_has_lazy() {
 
5073
  _has_bits_[0] |= 0x00000004u;
 
5074
}
 
5075
inline void FieldOptions::clear_has_lazy() {
 
5076
  _has_bits_[0] &= ~0x00000004u;
 
5077
}
 
5078
inline void FieldOptions::clear_lazy() {
 
5079
  lazy_ = false;
 
5080
  clear_has_lazy();
 
5081
}
 
5082
inline bool FieldOptions::lazy() const {
 
5083
  return lazy_;
 
5084
}
 
5085
inline void FieldOptions::set_lazy(bool value) {
 
5086
  set_has_lazy();
 
5087
  lazy_ = value;
 
5088
}
 
5089
 
 
5090
// optional bool deprecated = 3 [default = false];
 
5091
inline bool FieldOptions::has_deprecated() const {
 
5092
  return (_has_bits_[0] & 0x00000008u) != 0;
 
5093
}
 
5094
inline void FieldOptions::set_has_deprecated() {
 
5095
  _has_bits_[0] |= 0x00000008u;
 
5096
}
 
5097
inline void FieldOptions::clear_has_deprecated() {
 
5098
  _has_bits_[0] &= ~0x00000008u;
 
5099
}
 
5100
inline void FieldOptions::clear_deprecated() {
 
5101
  deprecated_ = false;
 
5102
  clear_has_deprecated();
 
5103
}
 
5104
inline bool FieldOptions::deprecated() const {
 
5105
  return deprecated_;
 
5106
}
 
5107
inline void FieldOptions::set_deprecated(bool value) {
 
5108
  set_has_deprecated();
 
5109
  deprecated_ = value;
 
5110
}
 
5111
 
 
5112
// optional string experimental_map_key = 9;
 
5113
inline bool FieldOptions::has_experimental_map_key() const {
 
5114
  return (_has_bits_[0] & 0x00000010u) != 0;
 
5115
}
 
5116
inline void FieldOptions::set_has_experimental_map_key() {
 
5117
  _has_bits_[0] |= 0x00000010u;
 
5118
}
 
5119
inline void FieldOptions::clear_has_experimental_map_key() {
 
5120
  _has_bits_[0] &= ~0x00000010u;
 
5121
}
 
5122
inline void FieldOptions::clear_experimental_map_key() {
 
5123
  if (experimental_map_key_ != &::google::protobuf::internal::GetEmptyString()) {
 
5124
    experimental_map_key_->clear();
 
5125
  }
 
5126
  clear_has_experimental_map_key();
 
5127
}
 
5128
inline const ::std::string& FieldOptions::experimental_map_key() const {
 
5129
  return *experimental_map_key_;
 
5130
}
 
5131
inline void FieldOptions::set_experimental_map_key(const ::std::string& value) {
 
5132
  set_has_experimental_map_key();
 
5133
  if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) {
 
5134
    experimental_map_key_ = new ::std::string;
 
5135
  }
 
5136
  experimental_map_key_->assign(value);
 
5137
}
 
5138
inline void FieldOptions::set_experimental_map_key(const char* value) {
 
5139
  set_has_experimental_map_key();
 
5140
  if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) {
 
5141
    experimental_map_key_ = new ::std::string;
 
5142
  }
 
5143
  experimental_map_key_->assign(value);
 
5144
}
 
5145
inline void FieldOptions::set_experimental_map_key(const char* value, size_t size) {
 
5146
  set_has_experimental_map_key();
 
5147
  if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) {
 
5148
    experimental_map_key_ = new ::std::string;
 
5149
  }
 
5150
  experimental_map_key_->assign(reinterpret_cast<const char*>(value), size);
 
5151
}
 
5152
inline ::std::string* FieldOptions::mutable_experimental_map_key() {
 
5153
  set_has_experimental_map_key();
 
5154
  if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) {
 
5155
    experimental_map_key_ = new ::std::string;
 
5156
  }
 
5157
  return experimental_map_key_;
 
5158
}
 
5159
inline ::std::string* FieldOptions::release_experimental_map_key() {
 
5160
  clear_has_experimental_map_key();
 
5161
  if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) {
 
5162
    return NULL;
 
5163
  } else {
 
5164
    ::std::string* temp = experimental_map_key_;
 
5165
    experimental_map_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5166
    return temp;
 
5167
  }
 
5168
}
 
5169
inline void FieldOptions::set_allocated_experimental_map_key(::std::string* experimental_map_key) {
 
5170
  if (experimental_map_key_ != &::google::protobuf::internal::GetEmptyString()) {
 
5171
    delete experimental_map_key_;
 
5172
  }
 
5173
  if (experimental_map_key) {
 
5174
    set_has_experimental_map_key();
 
5175
    experimental_map_key_ = experimental_map_key;
 
5176
  } else {
 
5177
    clear_has_experimental_map_key();
 
5178
    experimental_map_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5179
  }
 
5180
}
 
5181
 
 
5182
// optional bool weak = 10 [default = false];
 
5183
inline bool FieldOptions::has_weak() const {
 
5184
  return (_has_bits_[0] & 0x00000020u) != 0;
 
5185
}
 
5186
inline void FieldOptions::set_has_weak() {
 
5187
  _has_bits_[0] |= 0x00000020u;
 
5188
}
 
5189
inline void FieldOptions::clear_has_weak() {
 
5190
  _has_bits_[0] &= ~0x00000020u;
 
5191
}
 
5192
inline void FieldOptions::clear_weak() {
 
5193
  weak_ = false;
 
5194
  clear_has_weak();
 
5195
}
 
5196
inline bool FieldOptions::weak() const {
 
5197
  return weak_;
 
5198
}
 
5199
inline void FieldOptions::set_weak(bool value) {
 
5200
  set_has_weak();
 
5201
  weak_ = value;
 
5202
}
 
5203
 
 
5204
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
5205
inline int FieldOptions::uninterpreted_option_size() const {
 
5206
  return uninterpreted_option_.size();
 
5207
}
 
5208
inline void FieldOptions::clear_uninterpreted_option() {
 
5209
  uninterpreted_option_.Clear();
 
5210
}
 
5211
inline const ::google::protobuf::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const {
 
5212
  return uninterpreted_option_.Get(index);
 
5213
}
 
5214
inline ::google::protobuf::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) {
 
5215
  return uninterpreted_option_.Mutable(index);
 
5216
}
 
5217
inline ::google::protobuf::UninterpretedOption* FieldOptions::add_uninterpreted_option() {
 
5218
  return uninterpreted_option_.Add();
 
5219
}
 
5220
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
5221
FieldOptions::uninterpreted_option() const {
 
5222
  return uninterpreted_option_;
 
5223
}
 
5224
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
5225
FieldOptions::mutable_uninterpreted_option() {
 
5226
  return &uninterpreted_option_;
 
5227
}
 
5228
 
 
5229
// -------------------------------------------------------------------
 
5230
 
 
5231
// EnumOptions
 
5232
 
 
5233
// optional bool allow_alias = 2 [default = true];
 
5234
inline bool EnumOptions::has_allow_alias() const {
 
5235
  return (_has_bits_[0] & 0x00000001u) != 0;
 
5236
}
 
5237
inline void EnumOptions::set_has_allow_alias() {
 
5238
  _has_bits_[0] |= 0x00000001u;
 
5239
}
 
5240
inline void EnumOptions::clear_has_allow_alias() {
 
5241
  _has_bits_[0] &= ~0x00000001u;
 
5242
}
 
5243
inline void EnumOptions::clear_allow_alias() {
 
5244
  allow_alias_ = true;
 
5245
  clear_has_allow_alias();
 
5246
}
 
5247
inline bool EnumOptions::allow_alias() const {
 
5248
  return allow_alias_;
 
5249
}
 
5250
inline void EnumOptions::set_allow_alias(bool value) {
 
5251
  set_has_allow_alias();
 
5252
  allow_alias_ = value;
 
5253
}
 
5254
 
 
5255
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
5256
inline int EnumOptions::uninterpreted_option_size() const {
 
5257
  return uninterpreted_option_.size();
 
5258
}
 
5259
inline void EnumOptions::clear_uninterpreted_option() {
 
5260
  uninterpreted_option_.Clear();
 
5261
}
 
5262
inline const ::google::protobuf::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const {
 
5263
  return uninterpreted_option_.Get(index);
 
5264
}
 
5265
inline ::google::protobuf::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) {
 
5266
  return uninterpreted_option_.Mutable(index);
 
5267
}
 
5268
inline ::google::protobuf::UninterpretedOption* EnumOptions::add_uninterpreted_option() {
 
5269
  return uninterpreted_option_.Add();
 
5270
}
 
5271
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
5272
EnumOptions::uninterpreted_option() const {
 
5273
  return uninterpreted_option_;
 
5274
}
 
5275
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
5276
EnumOptions::mutable_uninterpreted_option() {
 
5277
  return &uninterpreted_option_;
 
5278
}
 
5279
 
 
5280
// -------------------------------------------------------------------
 
5281
 
 
5282
// EnumValueOptions
 
5283
 
 
5284
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
5285
inline int EnumValueOptions::uninterpreted_option_size() const {
 
5286
  return uninterpreted_option_.size();
 
5287
}
 
5288
inline void EnumValueOptions::clear_uninterpreted_option() {
 
5289
  uninterpreted_option_.Clear();
 
5290
}
 
5291
inline const ::google::protobuf::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const {
 
5292
  return uninterpreted_option_.Get(index);
 
5293
}
 
5294
inline ::google::protobuf::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) {
 
5295
  return uninterpreted_option_.Mutable(index);
 
5296
}
 
5297
inline ::google::protobuf::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() {
 
5298
  return uninterpreted_option_.Add();
 
5299
}
 
5300
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
5301
EnumValueOptions::uninterpreted_option() const {
 
5302
  return uninterpreted_option_;
 
5303
}
 
5304
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
5305
EnumValueOptions::mutable_uninterpreted_option() {
 
5306
  return &uninterpreted_option_;
 
5307
}
 
5308
 
 
5309
// -------------------------------------------------------------------
 
5310
 
 
5311
// ServiceOptions
 
5312
 
 
5313
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
5314
inline int ServiceOptions::uninterpreted_option_size() const {
 
5315
  return uninterpreted_option_.size();
 
5316
}
 
5317
inline void ServiceOptions::clear_uninterpreted_option() {
 
5318
  uninterpreted_option_.Clear();
 
5319
}
 
5320
inline const ::google::protobuf::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const {
 
5321
  return uninterpreted_option_.Get(index);
 
5322
}
 
5323
inline ::google::protobuf::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) {
 
5324
  return uninterpreted_option_.Mutable(index);
 
5325
}
 
5326
inline ::google::protobuf::UninterpretedOption* ServiceOptions::add_uninterpreted_option() {
 
5327
  return uninterpreted_option_.Add();
 
5328
}
 
5329
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
5330
ServiceOptions::uninterpreted_option() const {
 
5331
  return uninterpreted_option_;
 
5332
}
 
5333
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
5334
ServiceOptions::mutable_uninterpreted_option() {
 
5335
  return &uninterpreted_option_;
 
5336
}
 
5337
 
 
5338
// -------------------------------------------------------------------
 
5339
 
 
5340
// MethodOptions
 
5341
 
 
5342
// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
 
5343
inline int MethodOptions::uninterpreted_option_size() const {
 
5344
  return uninterpreted_option_.size();
 
5345
}
 
5346
inline void MethodOptions::clear_uninterpreted_option() {
 
5347
  uninterpreted_option_.Clear();
 
5348
}
 
5349
inline const ::google::protobuf::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const {
 
5350
  return uninterpreted_option_.Get(index);
 
5351
}
 
5352
inline ::google::protobuf::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) {
 
5353
  return uninterpreted_option_.Mutable(index);
 
5354
}
 
5355
inline ::google::protobuf::UninterpretedOption* MethodOptions::add_uninterpreted_option() {
 
5356
  return uninterpreted_option_.Add();
 
5357
}
 
5358
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
 
5359
MethodOptions::uninterpreted_option() const {
 
5360
  return uninterpreted_option_;
 
5361
}
 
5362
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
 
5363
MethodOptions::mutable_uninterpreted_option() {
 
5364
  return &uninterpreted_option_;
 
5365
}
 
5366
 
 
5367
// -------------------------------------------------------------------
 
5368
 
 
5369
// UninterpretedOption_NamePart
 
5370
 
 
5371
// required string name_part = 1;
 
5372
inline bool UninterpretedOption_NamePart::has_name_part() const {
 
5373
  return (_has_bits_[0] & 0x00000001u) != 0;
 
5374
}
 
5375
inline void UninterpretedOption_NamePart::set_has_name_part() {
 
5376
  _has_bits_[0] |= 0x00000001u;
 
5377
}
 
5378
inline void UninterpretedOption_NamePart::clear_has_name_part() {
 
5379
  _has_bits_[0] &= ~0x00000001u;
 
5380
}
 
5381
inline void UninterpretedOption_NamePart::clear_name_part() {
 
5382
  if (name_part_ != &::google::protobuf::internal::GetEmptyString()) {
 
5383
    name_part_->clear();
 
5384
  }
 
5385
  clear_has_name_part();
 
5386
}
 
5387
inline const ::std::string& UninterpretedOption_NamePart::name_part() const {
 
5388
  return *name_part_;
 
5389
}
 
5390
inline void UninterpretedOption_NamePart::set_name_part(const ::std::string& value) {
 
5391
  set_has_name_part();
 
5392
  if (name_part_ == &::google::protobuf::internal::GetEmptyString()) {
 
5393
    name_part_ = new ::std::string;
 
5394
  }
 
5395
  name_part_->assign(value);
 
5396
}
 
5397
inline void UninterpretedOption_NamePart::set_name_part(const char* value) {
 
5398
  set_has_name_part();
 
5399
  if (name_part_ == &::google::protobuf::internal::GetEmptyString()) {
 
5400
    name_part_ = new ::std::string;
 
5401
  }
 
5402
  name_part_->assign(value);
 
5403
}
 
5404
inline void UninterpretedOption_NamePart::set_name_part(const char* value, size_t size) {
 
5405
  set_has_name_part();
 
5406
  if (name_part_ == &::google::protobuf::internal::GetEmptyString()) {
 
5407
    name_part_ = new ::std::string;
 
5408
  }
 
5409
  name_part_->assign(reinterpret_cast<const char*>(value), size);
 
5410
}
 
5411
inline ::std::string* UninterpretedOption_NamePart::mutable_name_part() {
 
5412
  set_has_name_part();
 
5413
  if (name_part_ == &::google::protobuf::internal::GetEmptyString()) {
 
5414
    name_part_ = new ::std::string;
 
5415
  }
 
5416
  return name_part_;
 
5417
}
 
5418
inline ::std::string* UninterpretedOption_NamePart::release_name_part() {
 
5419
  clear_has_name_part();
 
5420
  if (name_part_ == &::google::protobuf::internal::GetEmptyString()) {
 
5421
    return NULL;
 
5422
  } else {
 
5423
    ::std::string* temp = name_part_;
 
5424
    name_part_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5425
    return temp;
 
5426
  }
 
5427
}
 
5428
inline void UninterpretedOption_NamePart::set_allocated_name_part(::std::string* name_part) {
 
5429
  if (name_part_ != &::google::protobuf::internal::GetEmptyString()) {
 
5430
    delete name_part_;
 
5431
  }
 
5432
  if (name_part) {
 
5433
    set_has_name_part();
 
5434
    name_part_ = name_part;
 
5435
  } else {
 
5436
    clear_has_name_part();
 
5437
    name_part_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5438
  }
 
5439
}
 
5440
 
 
5441
// required bool is_extension = 2;
 
5442
inline bool UninterpretedOption_NamePart::has_is_extension() const {
 
5443
  return (_has_bits_[0] & 0x00000002u) != 0;
 
5444
}
 
5445
inline void UninterpretedOption_NamePart::set_has_is_extension() {
 
5446
  _has_bits_[0] |= 0x00000002u;
 
5447
}
 
5448
inline void UninterpretedOption_NamePart::clear_has_is_extension() {
 
5449
  _has_bits_[0] &= ~0x00000002u;
 
5450
}
 
5451
inline void UninterpretedOption_NamePart::clear_is_extension() {
 
5452
  is_extension_ = false;
 
5453
  clear_has_is_extension();
 
5454
}
 
5455
inline bool UninterpretedOption_NamePart::is_extension() const {
 
5456
  return is_extension_;
 
5457
}
 
5458
inline void UninterpretedOption_NamePart::set_is_extension(bool value) {
 
5459
  set_has_is_extension();
 
5460
  is_extension_ = value;
 
5461
}
 
5462
 
 
5463
// -------------------------------------------------------------------
 
5464
 
 
5465
// UninterpretedOption
 
5466
 
 
5467
// repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
 
5468
inline int UninterpretedOption::name_size() const {
 
5469
  return name_.size();
 
5470
}
 
5471
inline void UninterpretedOption::clear_name() {
 
5472
  name_.Clear();
 
5473
}
 
5474
inline const ::google::protobuf::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const {
 
5475
  return name_.Get(index);
 
5476
}
 
5477
inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) {
 
5478
  return name_.Mutable(index);
 
5479
}
 
5480
inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::add_name() {
 
5481
  return name_.Add();
 
5482
}
 
5483
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >&
 
5484
UninterpretedOption::name() const {
 
5485
  return name_;
 
5486
}
 
5487
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >*
 
5488
UninterpretedOption::mutable_name() {
 
5489
  return &name_;
 
5490
}
 
5491
 
 
5492
// optional string identifier_value = 3;
 
5493
inline bool UninterpretedOption::has_identifier_value() const {
 
5494
  return (_has_bits_[0] & 0x00000002u) != 0;
 
5495
}
 
5496
inline void UninterpretedOption::set_has_identifier_value() {
 
5497
  _has_bits_[0] |= 0x00000002u;
 
5498
}
 
5499
inline void UninterpretedOption::clear_has_identifier_value() {
 
5500
  _has_bits_[0] &= ~0x00000002u;
 
5501
}
 
5502
inline void UninterpretedOption::clear_identifier_value() {
 
5503
  if (identifier_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
5504
    identifier_value_->clear();
 
5505
  }
 
5506
  clear_has_identifier_value();
 
5507
}
 
5508
inline const ::std::string& UninterpretedOption::identifier_value() const {
 
5509
  return *identifier_value_;
 
5510
}
 
5511
inline void UninterpretedOption::set_identifier_value(const ::std::string& value) {
 
5512
  set_has_identifier_value();
 
5513
  if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5514
    identifier_value_ = new ::std::string;
 
5515
  }
 
5516
  identifier_value_->assign(value);
 
5517
}
 
5518
inline void UninterpretedOption::set_identifier_value(const char* value) {
 
5519
  set_has_identifier_value();
 
5520
  if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5521
    identifier_value_ = new ::std::string;
 
5522
  }
 
5523
  identifier_value_->assign(value);
 
5524
}
 
5525
inline void UninterpretedOption::set_identifier_value(const char* value, size_t size) {
 
5526
  set_has_identifier_value();
 
5527
  if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5528
    identifier_value_ = new ::std::string;
 
5529
  }
 
5530
  identifier_value_->assign(reinterpret_cast<const char*>(value), size);
 
5531
}
 
5532
inline ::std::string* UninterpretedOption::mutable_identifier_value() {
 
5533
  set_has_identifier_value();
 
5534
  if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5535
    identifier_value_ = new ::std::string;
 
5536
  }
 
5537
  return identifier_value_;
 
5538
}
 
5539
inline ::std::string* UninterpretedOption::release_identifier_value() {
 
5540
  clear_has_identifier_value();
 
5541
  if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5542
    return NULL;
 
5543
  } else {
 
5544
    ::std::string* temp = identifier_value_;
 
5545
    identifier_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5546
    return temp;
 
5547
  }
 
5548
}
 
5549
inline void UninterpretedOption::set_allocated_identifier_value(::std::string* identifier_value) {
 
5550
  if (identifier_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
5551
    delete identifier_value_;
 
5552
  }
 
5553
  if (identifier_value) {
 
5554
    set_has_identifier_value();
 
5555
    identifier_value_ = identifier_value;
 
5556
  } else {
 
5557
    clear_has_identifier_value();
 
5558
    identifier_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5559
  }
 
5560
}
 
5561
 
 
5562
// optional uint64 positive_int_value = 4;
 
5563
inline bool UninterpretedOption::has_positive_int_value() const {
 
5564
  return (_has_bits_[0] & 0x00000004u) != 0;
 
5565
}
 
5566
inline void UninterpretedOption::set_has_positive_int_value() {
 
5567
  _has_bits_[0] |= 0x00000004u;
 
5568
}
 
5569
inline void UninterpretedOption::clear_has_positive_int_value() {
 
5570
  _has_bits_[0] &= ~0x00000004u;
 
5571
}
 
5572
inline void UninterpretedOption::clear_positive_int_value() {
 
5573
  positive_int_value_ = GOOGLE_ULONGLONG(0);
 
5574
  clear_has_positive_int_value();
 
5575
}
 
5576
inline ::google::protobuf::uint64 UninterpretedOption::positive_int_value() const {
 
5577
  return positive_int_value_;
 
5578
}
 
5579
inline void UninterpretedOption::set_positive_int_value(::google::protobuf::uint64 value) {
 
5580
  set_has_positive_int_value();
 
5581
  positive_int_value_ = value;
 
5582
}
 
5583
 
 
5584
// optional int64 negative_int_value = 5;
 
5585
inline bool UninterpretedOption::has_negative_int_value() const {
 
5586
  return (_has_bits_[0] & 0x00000008u) != 0;
 
5587
}
 
5588
inline void UninterpretedOption::set_has_negative_int_value() {
 
5589
  _has_bits_[0] |= 0x00000008u;
 
5590
}
 
5591
inline void UninterpretedOption::clear_has_negative_int_value() {
 
5592
  _has_bits_[0] &= ~0x00000008u;
 
5593
}
 
5594
inline void UninterpretedOption::clear_negative_int_value() {
 
5595
  negative_int_value_ = GOOGLE_LONGLONG(0);
 
5596
  clear_has_negative_int_value();
 
5597
}
 
5598
inline ::google::protobuf::int64 UninterpretedOption::negative_int_value() const {
 
5599
  return negative_int_value_;
 
5600
}
 
5601
inline void UninterpretedOption::set_negative_int_value(::google::protobuf::int64 value) {
 
5602
  set_has_negative_int_value();
 
5603
  negative_int_value_ = value;
 
5604
}
 
5605
 
 
5606
// optional double double_value = 6;
 
5607
inline bool UninterpretedOption::has_double_value() const {
 
5608
  return (_has_bits_[0] & 0x00000010u) != 0;
 
5609
}
 
5610
inline void UninterpretedOption::set_has_double_value() {
 
5611
  _has_bits_[0] |= 0x00000010u;
 
5612
}
 
5613
inline void UninterpretedOption::clear_has_double_value() {
 
5614
  _has_bits_[0] &= ~0x00000010u;
 
5615
}
 
5616
inline void UninterpretedOption::clear_double_value() {
 
5617
  double_value_ = 0;
 
5618
  clear_has_double_value();
 
5619
}
 
5620
inline double UninterpretedOption::double_value() const {
 
5621
  return double_value_;
 
5622
}
 
5623
inline void UninterpretedOption::set_double_value(double value) {
 
5624
  set_has_double_value();
 
5625
  double_value_ = value;
 
5626
}
 
5627
 
 
5628
// optional bytes string_value = 7;
 
5629
inline bool UninterpretedOption::has_string_value() const {
 
5630
  return (_has_bits_[0] & 0x00000020u) != 0;
 
5631
}
 
5632
inline void UninterpretedOption::set_has_string_value() {
 
5633
  _has_bits_[0] |= 0x00000020u;
 
5634
}
 
5635
inline void UninterpretedOption::clear_has_string_value() {
 
5636
  _has_bits_[0] &= ~0x00000020u;
 
5637
}
 
5638
inline void UninterpretedOption::clear_string_value() {
 
5639
  if (string_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
5640
    string_value_->clear();
 
5641
  }
 
5642
  clear_has_string_value();
 
5643
}
 
5644
inline const ::std::string& UninterpretedOption::string_value() const {
 
5645
  return *string_value_;
 
5646
}
 
5647
inline void UninterpretedOption::set_string_value(const ::std::string& value) {
 
5648
  set_has_string_value();
 
5649
  if (string_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5650
    string_value_ = new ::std::string;
 
5651
  }
 
5652
  string_value_->assign(value);
 
5653
}
 
5654
inline void UninterpretedOption::set_string_value(const char* value) {
 
5655
  set_has_string_value();
 
5656
  if (string_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5657
    string_value_ = new ::std::string;
 
5658
  }
 
5659
  string_value_->assign(value);
 
5660
}
 
5661
inline void UninterpretedOption::set_string_value(const void* value, size_t size) {
 
5662
  set_has_string_value();
 
5663
  if (string_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5664
    string_value_ = new ::std::string;
 
5665
  }
 
5666
  string_value_->assign(reinterpret_cast<const char*>(value), size);
 
5667
}
 
5668
inline ::std::string* UninterpretedOption::mutable_string_value() {
 
5669
  set_has_string_value();
 
5670
  if (string_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5671
    string_value_ = new ::std::string;
 
5672
  }
 
5673
  return string_value_;
 
5674
}
 
5675
inline ::std::string* UninterpretedOption::release_string_value() {
 
5676
  clear_has_string_value();
 
5677
  if (string_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5678
    return NULL;
 
5679
  } else {
 
5680
    ::std::string* temp = string_value_;
 
5681
    string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5682
    return temp;
 
5683
  }
 
5684
}
 
5685
inline void UninterpretedOption::set_allocated_string_value(::std::string* string_value) {
 
5686
  if (string_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
5687
    delete string_value_;
 
5688
  }
 
5689
  if (string_value) {
 
5690
    set_has_string_value();
 
5691
    string_value_ = string_value;
 
5692
  } else {
 
5693
    clear_has_string_value();
 
5694
    string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5695
  }
 
5696
}
 
5697
 
 
5698
// optional string aggregate_value = 8;
 
5699
inline bool UninterpretedOption::has_aggregate_value() const {
 
5700
  return (_has_bits_[0] & 0x00000040u) != 0;
 
5701
}
 
5702
inline void UninterpretedOption::set_has_aggregate_value() {
 
5703
  _has_bits_[0] |= 0x00000040u;
 
5704
}
 
5705
inline void UninterpretedOption::clear_has_aggregate_value() {
 
5706
  _has_bits_[0] &= ~0x00000040u;
 
5707
}
 
5708
inline void UninterpretedOption::clear_aggregate_value() {
 
5709
  if (aggregate_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
5710
    aggregate_value_->clear();
 
5711
  }
 
5712
  clear_has_aggregate_value();
 
5713
}
 
5714
inline const ::std::string& UninterpretedOption::aggregate_value() const {
 
5715
  return *aggregate_value_;
 
5716
}
 
5717
inline void UninterpretedOption::set_aggregate_value(const ::std::string& value) {
 
5718
  set_has_aggregate_value();
 
5719
  if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5720
    aggregate_value_ = new ::std::string;
 
5721
  }
 
5722
  aggregate_value_->assign(value);
 
5723
}
 
5724
inline void UninterpretedOption::set_aggregate_value(const char* value) {
 
5725
  set_has_aggregate_value();
 
5726
  if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5727
    aggregate_value_ = new ::std::string;
 
5728
  }
 
5729
  aggregate_value_->assign(value);
 
5730
}
 
5731
inline void UninterpretedOption::set_aggregate_value(const char* value, size_t size) {
 
5732
  set_has_aggregate_value();
 
5733
  if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5734
    aggregate_value_ = new ::std::string;
 
5735
  }
 
5736
  aggregate_value_->assign(reinterpret_cast<const char*>(value), size);
 
5737
}
 
5738
inline ::std::string* UninterpretedOption::mutable_aggregate_value() {
 
5739
  set_has_aggregate_value();
 
5740
  if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5741
    aggregate_value_ = new ::std::string;
 
5742
  }
 
5743
  return aggregate_value_;
 
5744
}
 
5745
inline ::std::string* UninterpretedOption::release_aggregate_value() {
 
5746
  clear_has_aggregate_value();
 
5747
  if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) {
 
5748
    return NULL;
 
5749
  } else {
 
5750
    ::std::string* temp = aggregate_value_;
 
5751
    aggregate_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5752
    return temp;
 
5753
  }
 
5754
}
 
5755
inline void UninterpretedOption::set_allocated_aggregate_value(::std::string* aggregate_value) {
 
5756
  if (aggregate_value_ != &::google::protobuf::internal::GetEmptyString()) {
 
5757
    delete aggregate_value_;
 
5758
  }
 
5759
  if (aggregate_value) {
 
5760
    set_has_aggregate_value();
 
5761
    aggregate_value_ = aggregate_value;
 
5762
  } else {
 
5763
    clear_has_aggregate_value();
 
5764
    aggregate_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5765
  }
 
5766
}
 
5767
 
 
5768
// -------------------------------------------------------------------
 
5769
 
 
5770
// SourceCodeInfo_Location
 
5771
 
 
5772
// repeated int32 path = 1 [packed = true];
 
5773
inline int SourceCodeInfo_Location::path_size() const {
 
5774
  return path_.size();
 
5775
}
 
5776
inline void SourceCodeInfo_Location::clear_path() {
 
5777
  path_.Clear();
 
5778
}
 
5779
inline ::google::protobuf::int32 SourceCodeInfo_Location::path(int index) const {
 
5780
  return path_.Get(index);
 
5781
}
 
5782
inline void SourceCodeInfo_Location::set_path(int index, ::google::protobuf::int32 value) {
 
5783
  path_.Set(index, value);
 
5784
}
 
5785
inline void SourceCodeInfo_Location::add_path(::google::protobuf::int32 value) {
 
5786
  path_.Add(value);
 
5787
}
 
5788
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
5789
SourceCodeInfo_Location::path() const {
 
5790
  return path_;
 
5791
}
 
5792
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
5793
SourceCodeInfo_Location::mutable_path() {
 
5794
  return &path_;
 
5795
}
 
5796
 
 
5797
// repeated int32 span = 2 [packed = true];
 
5798
inline int SourceCodeInfo_Location::span_size() const {
 
5799
  return span_.size();
 
5800
}
 
5801
inline void SourceCodeInfo_Location::clear_span() {
 
5802
  span_.Clear();
 
5803
}
 
5804
inline ::google::protobuf::int32 SourceCodeInfo_Location::span(int index) const {
 
5805
  return span_.Get(index);
 
5806
}
 
5807
inline void SourceCodeInfo_Location::set_span(int index, ::google::protobuf::int32 value) {
 
5808
  span_.Set(index, value);
 
5809
}
 
5810
inline void SourceCodeInfo_Location::add_span(::google::protobuf::int32 value) {
 
5811
  span_.Add(value);
 
5812
}
 
5813
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 
5814
SourceCodeInfo_Location::span() const {
 
5815
  return span_;
 
5816
}
 
5817
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 
5818
SourceCodeInfo_Location::mutable_span() {
 
5819
  return &span_;
 
5820
}
 
5821
 
 
5822
// optional string leading_comments = 3;
 
5823
inline bool SourceCodeInfo_Location::has_leading_comments() const {
 
5824
  return (_has_bits_[0] & 0x00000004u) != 0;
 
5825
}
 
5826
inline void SourceCodeInfo_Location::set_has_leading_comments() {
 
5827
  _has_bits_[0] |= 0x00000004u;
 
5828
}
 
5829
inline void SourceCodeInfo_Location::clear_has_leading_comments() {
 
5830
  _has_bits_[0] &= ~0x00000004u;
 
5831
}
 
5832
inline void SourceCodeInfo_Location::clear_leading_comments() {
 
5833
  if (leading_comments_ != &::google::protobuf::internal::GetEmptyString()) {
 
5834
    leading_comments_->clear();
 
5835
  }
 
5836
  clear_has_leading_comments();
 
5837
}
 
5838
inline const ::std::string& SourceCodeInfo_Location::leading_comments() const {
 
5839
  return *leading_comments_;
 
5840
}
 
5841
inline void SourceCodeInfo_Location::set_leading_comments(const ::std::string& value) {
 
5842
  set_has_leading_comments();
 
5843
  if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5844
    leading_comments_ = new ::std::string;
 
5845
  }
 
5846
  leading_comments_->assign(value);
 
5847
}
 
5848
inline void SourceCodeInfo_Location::set_leading_comments(const char* value) {
 
5849
  set_has_leading_comments();
 
5850
  if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5851
    leading_comments_ = new ::std::string;
 
5852
  }
 
5853
  leading_comments_->assign(value);
 
5854
}
 
5855
inline void SourceCodeInfo_Location::set_leading_comments(const char* value, size_t size) {
 
5856
  set_has_leading_comments();
 
5857
  if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5858
    leading_comments_ = new ::std::string;
 
5859
  }
 
5860
  leading_comments_->assign(reinterpret_cast<const char*>(value), size);
 
5861
}
 
5862
inline ::std::string* SourceCodeInfo_Location::mutable_leading_comments() {
 
5863
  set_has_leading_comments();
 
5864
  if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5865
    leading_comments_ = new ::std::string;
 
5866
  }
 
5867
  return leading_comments_;
 
5868
}
 
5869
inline ::std::string* SourceCodeInfo_Location::release_leading_comments() {
 
5870
  clear_has_leading_comments();
 
5871
  if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5872
    return NULL;
 
5873
  } else {
 
5874
    ::std::string* temp = leading_comments_;
 
5875
    leading_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5876
    return temp;
 
5877
  }
 
5878
}
 
5879
inline void SourceCodeInfo_Location::set_allocated_leading_comments(::std::string* leading_comments) {
 
5880
  if (leading_comments_ != &::google::protobuf::internal::GetEmptyString()) {
 
5881
    delete leading_comments_;
 
5882
  }
 
5883
  if (leading_comments) {
 
5884
    set_has_leading_comments();
 
5885
    leading_comments_ = leading_comments;
 
5886
  } else {
 
5887
    clear_has_leading_comments();
 
5888
    leading_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5889
  }
 
5890
}
 
5891
 
 
5892
// optional string trailing_comments = 4;
 
5893
inline bool SourceCodeInfo_Location::has_trailing_comments() const {
 
5894
  return (_has_bits_[0] & 0x00000008u) != 0;
 
5895
}
 
5896
inline void SourceCodeInfo_Location::set_has_trailing_comments() {
 
5897
  _has_bits_[0] |= 0x00000008u;
 
5898
}
 
5899
inline void SourceCodeInfo_Location::clear_has_trailing_comments() {
 
5900
  _has_bits_[0] &= ~0x00000008u;
 
5901
}
 
5902
inline void SourceCodeInfo_Location::clear_trailing_comments() {
 
5903
  if (trailing_comments_ != &::google::protobuf::internal::GetEmptyString()) {
 
5904
    trailing_comments_->clear();
 
5905
  }
 
5906
  clear_has_trailing_comments();
 
5907
}
 
5908
inline const ::std::string& SourceCodeInfo_Location::trailing_comments() const {
 
5909
  return *trailing_comments_;
 
5910
}
 
5911
inline void SourceCodeInfo_Location::set_trailing_comments(const ::std::string& value) {
 
5912
  set_has_trailing_comments();
 
5913
  if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5914
    trailing_comments_ = new ::std::string;
 
5915
  }
 
5916
  trailing_comments_->assign(value);
 
5917
}
 
5918
inline void SourceCodeInfo_Location::set_trailing_comments(const char* value) {
 
5919
  set_has_trailing_comments();
 
5920
  if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5921
    trailing_comments_ = new ::std::string;
 
5922
  }
 
5923
  trailing_comments_->assign(value);
 
5924
}
 
5925
inline void SourceCodeInfo_Location::set_trailing_comments(const char* value, size_t size) {
 
5926
  set_has_trailing_comments();
 
5927
  if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5928
    trailing_comments_ = new ::std::string;
 
5929
  }
 
5930
  trailing_comments_->assign(reinterpret_cast<const char*>(value), size);
 
5931
}
 
5932
inline ::std::string* SourceCodeInfo_Location::mutable_trailing_comments() {
 
5933
  set_has_trailing_comments();
 
5934
  if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5935
    trailing_comments_ = new ::std::string;
 
5936
  }
 
5937
  return trailing_comments_;
 
5938
}
 
5939
inline ::std::string* SourceCodeInfo_Location::release_trailing_comments() {
 
5940
  clear_has_trailing_comments();
 
5941
  if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) {
 
5942
    return NULL;
 
5943
  } else {
 
5944
    ::std::string* temp = trailing_comments_;
 
5945
    trailing_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5946
    return temp;
 
5947
  }
 
5948
}
 
5949
inline void SourceCodeInfo_Location::set_allocated_trailing_comments(::std::string* trailing_comments) {
 
5950
  if (trailing_comments_ != &::google::protobuf::internal::GetEmptyString()) {
 
5951
    delete trailing_comments_;
 
5952
  }
 
5953
  if (trailing_comments) {
 
5954
    set_has_trailing_comments();
 
5955
    trailing_comments_ = trailing_comments;
 
5956
  } else {
 
5957
    clear_has_trailing_comments();
 
5958
    trailing_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 
5959
  }
 
5960
}
 
5961
 
 
5962
// -------------------------------------------------------------------
 
5963
 
 
5964
// SourceCodeInfo
 
5965
 
 
5966
// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
 
5967
inline int SourceCodeInfo::location_size() const {
 
5968
  return location_.size();
 
5969
}
 
5970
inline void SourceCodeInfo::clear_location() {
 
5971
  location_.Clear();
 
5972
}
 
5973
inline const ::google::protobuf::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const {
 
5974
  return location_.Get(index);
 
5975
}
 
5976
inline ::google::protobuf::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index) {
 
5977
  return location_.Mutable(index);
 
5978
}
 
5979
inline ::google::protobuf::SourceCodeInfo_Location* SourceCodeInfo::add_location() {
 
5980
  return location_.Add();
 
5981
}
 
5982
inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >&
 
5983
SourceCodeInfo::location() const {
 
5984
  return location_;
 
5985
}
 
5986
inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >*
 
5987
SourceCodeInfo::mutable_location() {
 
5988
  return &location_;
 
5989
}
 
5990
 
 
5991
 
 
5992
// @@protoc_insertion_point(namespace_scope)
 
5993
 
 
5994
}  // namespace protobuf
 
5995
}  // namespace google
 
5996
 
 
5997
#ifndef SWIG
 
5998
namespace google {
 
5999
namespace protobuf {
 
6000
 
 
6001
template <>
 
6002
inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type>() {
 
6003
  return ::google::protobuf::FieldDescriptorProto_Type_descriptor();
 
6004
}
 
6005
template <>
 
6006
inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label>() {
 
6007
  return ::google::protobuf::FieldDescriptorProto_Label_descriptor();
 
6008
}
 
6009
template <>
 
6010
inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode>() {
 
6011
  return ::google::protobuf::FileOptions_OptimizeMode_descriptor();
 
6012
}
 
6013
template <>
 
6014
inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldOptions_CType>() {
 
6015
  return ::google::protobuf::FieldOptions_CType_descriptor();
 
6016
}
 
6017
 
 
6018
}  // namespace google
 
6019
}  // namespace protobuf
 
6020
#endif  // SWIG
 
6021
 
 
6022
// @@protoc_insertion_point(global_scope)
 
6023
 
 
6024
#endif  // PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED