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