src/third_party/protobuf/src/google/protobuf/descriptor.pb.h

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