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 < 2003000 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 2003000 < 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/repeated_field.h> 24#include <google/protobuf/extension_set.h> 25#include <google/protobuf/generated_message_reflection.h> 26// @@protoc_insertion_point(includes) 27 28namespace google { 29namespace protobuf { 30 31// Internal implementation detail -- do not call these. 32void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 33void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 34void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 35 36class FileDescriptorSet; 37class FileDescriptorProto; 38class DescriptorProto; 39class DescriptorProto_ExtensionRange; 40class FieldDescriptorProto; 41class EnumDescriptorProto; 42class EnumValueDescriptorProto; 43class ServiceDescriptorProto; 44class MethodDescriptorProto; 45class FileOptions; 46class MessageOptions; 47class FieldOptions; 48class EnumOptions; 49class EnumValueOptions; 50class ServiceOptions; 51class MethodOptions; 52class UninterpretedOption; 53class UninterpretedOption_NamePart; 54 55enum FieldDescriptorProto_Type { 56 FieldDescriptorProto_Type_TYPE_DOUBLE = 1, 57 FieldDescriptorProto_Type_TYPE_FLOAT = 2, 58 FieldDescriptorProto_Type_TYPE_INT64 = 3, 59 FieldDescriptorProto_Type_TYPE_UINT64 = 4, 60 FieldDescriptorProto_Type_TYPE_INT32 = 5, 61 FieldDescriptorProto_Type_TYPE_FIXED64 = 6, 62 FieldDescriptorProto_Type_TYPE_FIXED32 = 7, 63 FieldDescriptorProto_Type_TYPE_BOOL = 8, 64 FieldDescriptorProto_Type_TYPE_STRING = 9, 65 FieldDescriptorProto_Type_TYPE_GROUP = 10, 66 FieldDescriptorProto_Type_TYPE_MESSAGE = 11, 67 FieldDescriptorProto_Type_TYPE_BYTES = 12, 68 FieldDescriptorProto_Type_TYPE_UINT32 = 13, 69 FieldDescriptorProto_Type_TYPE_ENUM = 14, 70 FieldDescriptorProto_Type_TYPE_SFIXED32 = 15, 71 FieldDescriptorProto_Type_TYPE_SFIXED64 = 16, 72 FieldDescriptorProto_Type_TYPE_SINT32 = 17, 73 FieldDescriptorProto_Type_TYPE_SINT64 = 18 74}; 75LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value); 76const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE; 77const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64; 78const int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1; 79 80LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor(); 81inline const ::std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) { 82 return ::google::protobuf::internal::NameOfEnum( 83 FieldDescriptorProto_Type_descriptor(), value); 84} 85inline bool FieldDescriptorProto_Type_Parse( 86 const ::std::string& name, FieldDescriptorProto_Type* value) { 87 return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Type>( 88 FieldDescriptorProto_Type_descriptor(), name, value); 89} 90enum FieldDescriptorProto_Label { 91 FieldDescriptorProto_Label_LABEL_OPTIONAL = 1, 92 FieldDescriptorProto_Label_LABEL_REQUIRED = 2, 93 FieldDescriptorProto_Label_LABEL_REPEATED = 3 94}; 95LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value); 96const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL; 97const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED; 98const int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1; 99 100LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor(); 101inline const ::std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) { 102 return ::google::protobuf::internal::NameOfEnum( 103 FieldDescriptorProto_Label_descriptor(), value); 104} 105inline bool FieldDescriptorProto_Label_Parse( 106 const ::std::string& name, FieldDescriptorProto_Label* value) { 107 return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Label>( 108 FieldDescriptorProto_Label_descriptor(), name, value); 109} 110enum FileOptions_OptimizeMode { 111 FileOptions_OptimizeMode_SPEED = 1, 112 FileOptions_OptimizeMode_CODE_SIZE = 2, 113 FileOptions_OptimizeMode_LITE_RUNTIME = 3 114}; 115LIBPROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value); 116const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED; 117const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME; 118const int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1; 119 120LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor(); 121inline const ::std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) { 122 return ::google::protobuf::internal::NameOfEnum( 123 FileOptions_OptimizeMode_descriptor(), value); 124} 125inline bool FileOptions_OptimizeMode_Parse( 126 const ::std::string& name, FileOptions_OptimizeMode* value) { 127 return ::google::protobuf::internal::ParseNamedEnum<FileOptions_OptimizeMode>( 128 FileOptions_OptimizeMode_descriptor(), name, value); 129} 130enum FieldOptions_CType { 131 FieldOptions_CType_STRING = 0, 132 FieldOptions_CType_CORD = 1, 133 FieldOptions_CType_STRING_PIECE = 2 134}; 135LIBPROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value); 136const FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING; 137const FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE; 138const int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1; 139 140LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor(); 141inline const ::std::string& FieldOptions_CType_Name(FieldOptions_CType value) { 142 return ::google::protobuf::internal::NameOfEnum( 143 FieldOptions_CType_descriptor(), value); 144} 145inline bool FieldOptions_CType_Parse( 146 const ::std::string& name, FieldOptions_CType* value) { 147 return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_CType>( 148 FieldOptions_CType_descriptor(), name, value); 149} 150// =================================================================== 151 152class LIBPROTOBUF_EXPORT FileDescriptorSet : public ::google::protobuf::Message { 153 public: 154 FileDescriptorSet(); 155 virtual ~FileDescriptorSet(); 156 157 FileDescriptorSet(const FileDescriptorSet& from); 158 159 inline FileDescriptorSet& operator=(const FileDescriptorSet& from) { 160 CopyFrom(from); 161 return *this; 162 } 163 164 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 165 return _unknown_fields_; 166 } 167 168 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 169 return &_unknown_fields_; 170 } 171 172 static const ::google::protobuf::Descriptor* descriptor(); 173 static const FileDescriptorSet& default_instance(); 174 175 void Swap(FileDescriptorSet* other); 176 177 // implements Message ---------------------------------------------- 178 179 FileDescriptorSet* New() const; 180 void CopyFrom(const ::google::protobuf::Message& from); 181 void MergeFrom(const ::google::protobuf::Message& from); 182 void CopyFrom(const FileDescriptorSet& from); 183 void MergeFrom(const FileDescriptorSet& from); 184 void Clear(); 185 bool IsInitialized() const; 186 187 int ByteSize() const; 188 bool MergePartialFromCodedStream( 189 ::google::protobuf::io::CodedInputStream* input); 190 void SerializeWithCachedSizes( 191 ::google::protobuf::io::CodedOutputStream* output) const; 192 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 193 int GetCachedSize() const { return _cached_size_; } 194 private: 195 void SharedCtor(); 196 void SharedDtor(); 197 void SetCachedSize(int size) const; 198 public: 199 200 ::google::protobuf::Metadata GetMetadata() const; 201 202 // nested types ---------------------------------------------------- 203 204 // accessors ------------------------------------------------------- 205 206 // repeated .google.protobuf.FileDescriptorProto file = 1; 207 inline int file_size() const; 208 inline void clear_file(); 209 static const int kFileFieldNumber = 1; 210 inline const ::google::protobuf::FileDescriptorProto& file(int index) const; 211 inline ::google::protobuf::FileDescriptorProto* mutable_file(int index); 212 inline ::google::protobuf::FileDescriptorProto* add_file(); 213 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >& 214 file() const; 215 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >* 216 mutable_file(); 217 218 // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet) 219 private: 220 ::google::protobuf::UnknownFieldSet _unknown_fields_; 221 mutable int _cached_size_; 222 223 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > file_; 224 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 225 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 226 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 227 228 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 229 230 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 231 inline bool _has_bit(int index) const { 232 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 233 } 234 inline void _set_bit(int index) { 235 _has_bits_[index / 32] |= (1u << (index % 32)); 236 } 237 inline void _clear_bit(int index) { 238 _has_bits_[index / 32] &= ~(1u << (index % 32)); 239 } 240 241 void InitAsDefaultInstance(); 242 static FileDescriptorSet* default_instance_; 243}; 244// ------------------------------------------------------------------- 245 246class LIBPROTOBUF_EXPORT FileDescriptorProto : public ::google::protobuf::Message { 247 public: 248 FileDescriptorProto(); 249 virtual ~FileDescriptorProto(); 250 251 FileDescriptorProto(const FileDescriptorProto& from); 252 253 inline FileDescriptorProto& operator=(const FileDescriptorProto& from) { 254 CopyFrom(from); 255 return *this; 256 } 257 258 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 259 return _unknown_fields_; 260 } 261 262 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 263 return &_unknown_fields_; 264 } 265 266 static const ::google::protobuf::Descriptor* descriptor(); 267 static const FileDescriptorProto& default_instance(); 268 269 void Swap(FileDescriptorProto* other); 270 271 // implements Message ---------------------------------------------- 272 273 FileDescriptorProto* New() const; 274 void CopyFrom(const ::google::protobuf::Message& from); 275 void MergeFrom(const ::google::protobuf::Message& from); 276 void CopyFrom(const FileDescriptorProto& from); 277 void MergeFrom(const FileDescriptorProto& from); 278 void Clear(); 279 bool IsInitialized() const; 280 281 int ByteSize() const; 282 bool MergePartialFromCodedStream( 283 ::google::protobuf::io::CodedInputStream* input); 284 void SerializeWithCachedSizes( 285 ::google::protobuf::io::CodedOutputStream* output) const; 286 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 287 int GetCachedSize() const { return _cached_size_; } 288 private: 289 void SharedCtor(); 290 void SharedDtor(); 291 void SetCachedSize(int size) const; 292 public: 293 294 ::google::protobuf::Metadata GetMetadata() const; 295 296 // nested types ---------------------------------------------------- 297 298 // accessors ------------------------------------------------------- 299 300 // optional string name = 1; 301 inline bool has_name() const; 302 inline void clear_name(); 303 static const int kNameFieldNumber = 1; 304 inline const ::std::string& name() const; 305 inline void set_name(const ::std::string& value); 306 inline void set_name(const char* value); 307 inline void set_name(const char* value, size_t size); 308 inline ::std::string* mutable_name(); 309 310 // optional string package = 2; 311 inline bool has_package() const; 312 inline void clear_package(); 313 static const int kPackageFieldNumber = 2; 314 inline const ::std::string& package() const; 315 inline void set_package(const ::std::string& value); 316 inline void set_package(const char* value); 317 inline void set_package(const char* value, size_t size); 318 inline ::std::string* mutable_package(); 319 320 // repeated string dependency = 3; 321 inline int dependency_size() const; 322 inline void clear_dependency(); 323 static const int kDependencyFieldNumber = 3; 324 inline const ::std::string& dependency(int index) const; 325 inline ::std::string* mutable_dependency(int index); 326 inline void set_dependency(int index, const ::std::string& value); 327 inline void set_dependency(int index, const char* value); 328 inline void set_dependency(int index, const char* value, size_t size); 329 inline ::std::string* add_dependency(); 330 inline void add_dependency(const ::std::string& value); 331 inline void add_dependency(const char* value); 332 inline void add_dependency(const char* value, size_t size); 333 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& dependency() const; 334 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_dependency(); 335 336 // repeated .google.protobuf.DescriptorProto message_type = 4; 337 inline int message_type_size() const; 338 inline void clear_message_type(); 339 static const int kMessageTypeFieldNumber = 4; 340 inline const ::google::protobuf::DescriptorProto& message_type(int index) const; 341 inline ::google::protobuf::DescriptorProto* mutable_message_type(int index); 342 inline ::google::protobuf::DescriptorProto* add_message_type(); 343 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 344 message_type() const; 345 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 346 mutable_message_type(); 347 348 // repeated .google.protobuf.EnumDescriptorProto enum_type = 5; 349 inline int enum_type_size() const; 350 inline void clear_enum_type(); 351 static const int kEnumTypeFieldNumber = 5; 352 inline const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const; 353 inline ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index); 354 inline ::google::protobuf::EnumDescriptorProto* add_enum_type(); 355 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 356 enum_type() const; 357 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 358 mutable_enum_type(); 359 360 // repeated .google.protobuf.ServiceDescriptorProto service = 6; 361 inline int service_size() const; 362 inline void clear_service(); 363 static const int kServiceFieldNumber = 6; 364 inline const ::google::protobuf::ServiceDescriptorProto& service(int index) const; 365 inline ::google::protobuf::ServiceDescriptorProto* mutable_service(int index); 366 inline ::google::protobuf::ServiceDescriptorProto* add_service(); 367 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >& 368 service() const; 369 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >* 370 mutable_service(); 371 372 // repeated .google.protobuf.FieldDescriptorProto extension = 7; 373 inline int extension_size() const; 374 inline void clear_extension(); 375 static const int kExtensionFieldNumber = 7; 376 inline const ::google::protobuf::FieldDescriptorProto& extension(int index) const; 377 inline ::google::protobuf::FieldDescriptorProto* mutable_extension(int index); 378 inline ::google::protobuf::FieldDescriptorProto* add_extension(); 379 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 380 extension() const; 381 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 382 mutable_extension(); 383 384 // optional .google.protobuf.FileOptions options = 8; 385 inline bool has_options() const; 386 inline void clear_options(); 387 static const int kOptionsFieldNumber = 8; 388 inline const ::google::protobuf::FileOptions& options() const; 389 inline ::google::protobuf::FileOptions* mutable_options(); 390 391 // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto) 392 private: 393 ::google::protobuf::UnknownFieldSet _unknown_fields_; 394 mutable int _cached_size_; 395 396 ::std::string* name_; 397 static const ::std::string _default_name_; 398 ::std::string* package_; 399 static const ::std::string _default_package_; 400 ::google::protobuf::RepeatedPtrField< ::std::string> dependency_; 401 ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > message_type_; 402 ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_; 403 ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto > service_; 404 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_; 405 ::google::protobuf::FileOptions* options_; 406 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 407 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 408 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 409 410 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 411 412 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 413 inline bool _has_bit(int index) const { 414 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 415 } 416 inline void _set_bit(int index) { 417 _has_bits_[index / 32] |= (1u << (index % 32)); 418 } 419 inline void _clear_bit(int index) { 420 _has_bits_[index / 32] &= ~(1u << (index % 32)); 421 } 422 423 void InitAsDefaultInstance(); 424 static FileDescriptorProto* default_instance_; 425}; 426// ------------------------------------------------------------------- 427 428class LIBPROTOBUF_EXPORT DescriptorProto_ExtensionRange : public ::google::protobuf::Message { 429 public: 430 DescriptorProto_ExtensionRange(); 431 virtual ~DescriptorProto_ExtensionRange(); 432 433 DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from); 434 435 inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) { 436 CopyFrom(from); 437 return *this; 438 } 439 440 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 441 return _unknown_fields_; 442 } 443 444 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 445 return &_unknown_fields_; 446 } 447 448 static const ::google::protobuf::Descriptor* descriptor(); 449 static const DescriptorProto_ExtensionRange& default_instance(); 450 451 void Swap(DescriptorProto_ExtensionRange* other); 452 453 // implements Message ---------------------------------------------- 454 455 DescriptorProto_ExtensionRange* New() const; 456 void CopyFrom(const ::google::protobuf::Message& from); 457 void MergeFrom(const ::google::protobuf::Message& from); 458 void CopyFrom(const DescriptorProto_ExtensionRange& from); 459 void MergeFrom(const DescriptorProto_ExtensionRange& from); 460 void Clear(); 461 bool IsInitialized() const; 462 463 int ByteSize() const; 464 bool MergePartialFromCodedStream( 465 ::google::protobuf::io::CodedInputStream* input); 466 void SerializeWithCachedSizes( 467 ::google::protobuf::io::CodedOutputStream* output) const; 468 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 469 int GetCachedSize() const { return _cached_size_; } 470 private: 471 void SharedCtor(); 472 void SharedDtor(); 473 void SetCachedSize(int size) const; 474 public: 475 476 ::google::protobuf::Metadata GetMetadata() const; 477 478 // nested types ---------------------------------------------------- 479 480 // accessors ------------------------------------------------------- 481 482 // optional int32 start = 1; 483 inline bool has_start() const; 484 inline void clear_start(); 485 static const int kStartFieldNumber = 1; 486 inline ::google::protobuf::int32 start() const; 487 inline void set_start(::google::protobuf::int32 value); 488 489 // optional int32 end = 2; 490 inline bool has_end() const; 491 inline void clear_end(); 492 static const int kEndFieldNumber = 2; 493 inline ::google::protobuf::int32 end() const; 494 inline void set_end(::google::protobuf::int32 value); 495 496 // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange) 497 private: 498 ::google::protobuf::UnknownFieldSet _unknown_fields_; 499 mutable int _cached_size_; 500 501 ::google::protobuf::int32 start_; 502 ::google::protobuf::int32 end_; 503 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 504 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 505 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 506 507 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 508 509 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 510 inline bool _has_bit(int index) const { 511 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 512 } 513 inline void _set_bit(int index) { 514 _has_bits_[index / 32] |= (1u << (index % 32)); 515 } 516 inline void _clear_bit(int index) { 517 _has_bits_[index / 32] &= ~(1u << (index % 32)); 518 } 519 520 void InitAsDefaultInstance(); 521 static DescriptorProto_ExtensionRange* default_instance_; 522}; 523// ------------------------------------------------------------------- 524 525class LIBPROTOBUF_EXPORT DescriptorProto : public ::google::protobuf::Message { 526 public: 527 DescriptorProto(); 528 virtual ~DescriptorProto(); 529 530 DescriptorProto(const DescriptorProto& from); 531 532 inline DescriptorProto& operator=(const DescriptorProto& from) { 533 CopyFrom(from); 534 return *this; 535 } 536 537 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 538 return _unknown_fields_; 539 } 540 541 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 542 return &_unknown_fields_; 543 } 544 545 static const ::google::protobuf::Descriptor* descriptor(); 546 static const DescriptorProto& default_instance(); 547 548 void Swap(DescriptorProto* other); 549 550 // implements Message ---------------------------------------------- 551 552 DescriptorProto* New() const; 553 void CopyFrom(const ::google::protobuf::Message& from); 554 void MergeFrom(const ::google::protobuf::Message& from); 555 void CopyFrom(const DescriptorProto& from); 556 void MergeFrom(const DescriptorProto& from); 557 void Clear(); 558 bool IsInitialized() const; 559 560 int ByteSize() const; 561 bool MergePartialFromCodedStream( 562 ::google::protobuf::io::CodedInputStream* input); 563 void SerializeWithCachedSizes( 564 ::google::protobuf::io::CodedOutputStream* output) const; 565 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 566 int GetCachedSize() const { return _cached_size_; } 567 private: 568 void SharedCtor(); 569 void SharedDtor(); 570 void SetCachedSize(int size) const; 571 public: 572 573 ::google::protobuf::Metadata GetMetadata() const; 574 575 // nested types ---------------------------------------------------- 576 577 typedef DescriptorProto_ExtensionRange ExtensionRange; 578 579 // accessors ------------------------------------------------------- 580 581 // optional string name = 1; 582 inline bool has_name() const; 583 inline void clear_name(); 584 static const int kNameFieldNumber = 1; 585 inline const ::std::string& name() const; 586 inline void set_name(const ::std::string& value); 587 inline void set_name(const char* value); 588 inline void set_name(const char* value, size_t size); 589 inline ::std::string* mutable_name(); 590 591 // repeated .google.protobuf.FieldDescriptorProto field = 2; 592 inline int field_size() const; 593 inline void clear_field(); 594 static const int kFieldFieldNumber = 2; 595 inline const ::google::protobuf::FieldDescriptorProto& field(int index) const; 596 inline ::google::protobuf::FieldDescriptorProto* mutable_field(int index); 597 inline ::google::protobuf::FieldDescriptorProto* add_field(); 598 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 599 field() const; 600 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 601 mutable_field(); 602 603 // repeated .google.protobuf.FieldDescriptorProto extension = 6; 604 inline int extension_size() const; 605 inline void clear_extension(); 606 static const int kExtensionFieldNumber = 6; 607 inline const ::google::protobuf::FieldDescriptorProto& extension(int index) const; 608 inline ::google::protobuf::FieldDescriptorProto* mutable_extension(int index); 609 inline ::google::protobuf::FieldDescriptorProto* add_extension(); 610 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 611 extension() const; 612 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 613 mutable_extension(); 614 615 // repeated .google.protobuf.DescriptorProto nested_type = 3; 616 inline int nested_type_size() const; 617 inline void clear_nested_type(); 618 static const int kNestedTypeFieldNumber = 3; 619 inline const ::google::protobuf::DescriptorProto& nested_type(int index) const; 620 inline ::google::protobuf::DescriptorProto* mutable_nested_type(int index); 621 inline ::google::protobuf::DescriptorProto* add_nested_type(); 622 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 623 nested_type() const; 624 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 625 mutable_nested_type(); 626 627 // repeated .google.protobuf.EnumDescriptorProto enum_type = 4; 628 inline int enum_type_size() const; 629 inline void clear_enum_type(); 630 static const int kEnumTypeFieldNumber = 4; 631 inline const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const; 632 inline ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index); 633 inline ::google::protobuf::EnumDescriptorProto* add_enum_type(); 634 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 635 enum_type() const; 636 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 637 mutable_enum_type(); 638 639 // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; 640 inline int extension_range_size() const; 641 inline void clear_extension_range(); 642 static const int kExtensionRangeFieldNumber = 5; 643 inline const ::google::protobuf::DescriptorProto_ExtensionRange& extension_range(int index) const; 644 inline ::google::protobuf::DescriptorProto_ExtensionRange* mutable_extension_range(int index); 645 inline ::google::protobuf::DescriptorProto_ExtensionRange* add_extension_range(); 646 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >& 647 extension_range() const; 648 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >* 649 mutable_extension_range(); 650 651 // optional .google.protobuf.MessageOptions options = 7; 652 inline bool has_options() const; 653 inline void clear_options(); 654 static const int kOptionsFieldNumber = 7; 655 inline const ::google::protobuf::MessageOptions& options() const; 656 inline ::google::protobuf::MessageOptions* mutable_options(); 657 658 // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto) 659 private: 660 ::google::protobuf::UnknownFieldSet _unknown_fields_; 661 mutable int _cached_size_; 662 663 ::std::string* name_; 664 static const ::std::string _default_name_; 665 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > field_; 666 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_; 667 ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > nested_type_; 668 ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_; 669 ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange > extension_range_; 670 ::google::protobuf::MessageOptions* options_; 671 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 672 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 673 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 674 675 ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; 676 677 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 678 inline bool _has_bit(int index) const { 679 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 680 } 681 inline void _set_bit(int index) { 682 _has_bits_[index / 32] |= (1u << (index % 32)); 683 } 684 inline void _clear_bit(int index) { 685 _has_bits_[index / 32] &= ~(1u << (index % 32)); 686 } 687 688 void InitAsDefaultInstance(); 689 static DescriptorProto* default_instance_; 690}; 691// ------------------------------------------------------------------- 692 693class LIBPROTOBUF_EXPORT FieldDescriptorProto : public ::google::protobuf::Message { 694 public: 695 FieldDescriptorProto(); 696 virtual ~FieldDescriptorProto(); 697 698 FieldDescriptorProto(const FieldDescriptorProto& from); 699 700 inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) { 701 CopyFrom(from); 702 return *this; 703 } 704 705 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 706 return _unknown_fields_; 707 } 708 709 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 710 return &_unknown_fields_; 711 } 712 713 static const ::google::protobuf::Descriptor* descriptor(); 714 static const FieldDescriptorProto& default_instance(); 715 716 void Swap(FieldDescriptorProto* other); 717 718 // implements Message ---------------------------------------------- 719 720 FieldDescriptorProto* New() const; 721 void CopyFrom(const ::google::protobuf::Message& from); 722 void MergeFrom(const ::google::protobuf::Message& from); 723 void CopyFrom(const FieldDescriptorProto& from); 724 void MergeFrom(const FieldDescriptorProto& from); 725 void Clear(); 726 bool IsInitialized() const; 727 728 int ByteSize() const; 729 bool MergePartialFromCodedStream( 730 ::google::protobuf::io::CodedInputStream* input); 731 void SerializeWithCachedSizes( 732 ::google::protobuf::io::CodedOutputStream* output) const; 733 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 734 int GetCachedSize() const { return _cached_size_; } 735 private: 736 void SharedCtor(); 737 void SharedDtor(); 738 void SetCachedSize(int size) const; 739 public: 740 741 ::google::protobuf::Metadata GetMetadata() const; 742 743 // nested types ---------------------------------------------------- 744 745 typedef FieldDescriptorProto_Type Type; 746 static const Type TYPE_DOUBLE = FieldDescriptorProto_Type_TYPE_DOUBLE; 747 static const Type TYPE_FLOAT = FieldDescriptorProto_Type_TYPE_FLOAT; 748 static const Type TYPE_INT64 = FieldDescriptorProto_Type_TYPE_INT64; 749 static const Type TYPE_UINT64 = FieldDescriptorProto_Type_TYPE_UINT64; 750 static const Type TYPE_INT32 = FieldDescriptorProto_Type_TYPE_INT32; 751 static const Type TYPE_FIXED64 = FieldDescriptorProto_Type_TYPE_FIXED64; 752 static const Type TYPE_FIXED32 = FieldDescriptorProto_Type_TYPE_FIXED32; 753 static const Type TYPE_BOOL = FieldDescriptorProto_Type_TYPE_BOOL; 754 static const Type TYPE_STRING = FieldDescriptorProto_Type_TYPE_STRING; 755 static const Type TYPE_GROUP = FieldDescriptorProto_Type_TYPE_GROUP; 756 static const Type TYPE_MESSAGE = FieldDescriptorProto_Type_TYPE_MESSAGE; 757 static const Type TYPE_BYTES = FieldDescriptorProto_Type_TYPE_BYTES; 758 static const Type TYPE_UINT32 = FieldDescriptorProto_Type_TYPE_UINT32; 759 static const Type TYPE_ENUM = FieldDescriptorProto_Type_TYPE_ENUM; 760 static const Type TYPE_SFIXED32 = FieldDescriptorProto_Type_TYPE_SFIXED32; 761 static const Type TYPE_SFIXED64 = FieldDescriptorProto_Type_TYPE_SFIXED64; 762 static const Type TYPE_SINT32 = FieldDescriptorProto_Type_TYPE_SINT32; 763 static const Type TYPE_SINT64 = FieldDescriptorProto_Type_TYPE_SINT64; 764 static inline bool Type_IsValid(int value) { 765 return FieldDescriptorProto_Type_IsValid(value); 766 } 767 static const Type Type_MIN = 768 FieldDescriptorProto_Type_Type_MIN; 769 static const Type Type_MAX = 770 FieldDescriptorProto_Type_Type_MAX; 771 static const int Type_ARRAYSIZE = 772 FieldDescriptorProto_Type_Type_ARRAYSIZE; 773 static inline const ::google::protobuf::EnumDescriptor* 774 Type_descriptor() { 775 return FieldDescriptorProto_Type_descriptor(); 776 } 777 static inline const ::std::string& Type_Name(Type value) { 778 return FieldDescriptorProto_Type_Name(value); 779 } 780 static inline bool Type_Parse(const ::std::string& name, 781 Type* value) { 782 return FieldDescriptorProto_Type_Parse(name, value); 783 } 784 785 typedef FieldDescriptorProto_Label Label; 786 static const Label LABEL_OPTIONAL = FieldDescriptorProto_Label_LABEL_OPTIONAL; 787 static const Label LABEL_REQUIRED = FieldDescriptorProto_Label_LABEL_REQUIRED; 788 static const Label LABEL_REPEATED = FieldDescriptorProto_Label_LABEL_REPEATED; 789 static inline bool Label_IsValid(int value) { 790 return FieldDescriptorProto_Label_IsValid(value); 791 } 792 static const Label Label_MIN = 793 FieldDescriptorProto_Label_Label_MIN; 794 static const Label Label_MAX = 795 FieldDescriptorProto_Label_Label_MAX; 796 static const int Label_ARRAYSIZE = 797 FieldDescriptorProto_Label_Label_ARRAYSIZE; 798 static inline const ::google::protobuf::EnumDescriptor* 799 Label_descriptor() { 800 return FieldDescriptorProto_Label_descriptor(); 801 } 802 static inline const ::std::string& Label_Name(Label value) { 803 return FieldDescriptorProto_Label_Name(value); 804 } 805 static inline bool Label_Parse(const ::std::string& name, 806 Label* value) { 807 return FieldDescriptorProto_Label_Parse(name, value); 808 } 809 810 // accessors ------------------------------------------------------- 811 812 // optional string name = 1; 813 inline bool has_name() const; 814 inline void clear_name(); 815 static const int kNameFieldNumber = 1; 816 inline const ::std::string& name() const; 817 inline void set_name(const ::std::string& value); 818 inline void set_name(const char* value); 819 inline void set_name(const char* value, size_t size); 820 inline ::std::string* mutable_name(); 821 822 // optional int32 number = 3; 823 inline bool has_number() const; 824 inline void clear_number(); 825 static const int kNumberFieldNumber = 3; 826 inline ::google::protobuf::int32 number() const; 827 inline void set_number(::google::protobuf::int32 value); 828 829 // optional .google.protobuf.FieldDescriptorProto.Label label = 4; 830 inline bool has_label() const; 831 inline void clear_label(); 832 static const int kLabelFieldNumber = 4; 833 inline ::google::protobuf::FieldDescriptorProto_Label label() const; 834 inline void set_label(::google::protobuf::FieldDescriptorProto_Label value); 835 836 // optional .google.protobuf.FieldDescriptorProto.Type type = 5; 837 inline bool has_type() const; 838 inline void clear_type(); 839 static const int kTypeFieldNumber = 5; 840 inline ::google::protobuf::FieldDescriptorProto_Type type() const; 841 inline void set_type(::google::protobuf::FieldDescriptorProto_Type value); 842 843 // optional string type_name = 6; 844 inline bool has_type_name() const; 845 inline void clear_type_name(); 846 static const int kTypeNameFieldNumber = 6; 847 inline const ::std::string& type_name() const; 848 inline void set_type_name(const ::std::string& value); 849 inline void set_type_name(const char* value); 850 inline void set_type_name(const char* value, size_t size); 851 inline ::std::string* mutable_type_name(); 852 853 // optional string extendee = 2; 854 inline bool has_extendee() const; 855 inline void clear_extendee(); 856 static const int kExtendeeFieldNumber = 2; 857 inline const ::std::string& extendee() const; 858 inline void set_extendee(const ::std::string& value); 859 inline void set_extendee(const char* value); 860 inline void set_extendee(const char* value, size_t size); 861 inline ::std::string* mutable_extendee(); 862 863 // optional string default_value = 7; 864 inline bool has_default_value() const; 865 inline void clear_default_value(); 866 static const int kDefaultValueFieldNumber = 7; 867 inline const ::std::string& default_value() const; 868 inline void set_default_value(const ::std::string& value); 869 inline void set_default_value(const char* value); 870 inline void set_default_value(const char* value, size_t size); 871 inline ::std::string* mutable_default_value(); 872 873 // optional .google.protobuf.FieldOptions options = 8; 874 inline bool has_options() const; 875 inline void clear_options(); 876 static const int kOptionsFieldNumber = 8; 877 inline const ::google::protobuf::FieldOptions& options() const; 878 inline ::google::protobuf::FieldOptions* mutable_options(); 879 880 // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto) 881 private: 882 ::google::protobuf::UnknownFieldSet _unknown_fields_; 883 mutable int _cached_size_; 884 885 ::std::string* name_; 886 static const ::std::string _default_name_; 887 ::google::protobuf::int32 number_; 888 int label_; 889 int type_; 890 ::std::string* type_name_; 891 static const ::std::string _default_type_name_; 892 ::std::string* extendee_; 893 static const ::std::string _default_extendee_; 894 ::std::string* default_value_; 895 static const ::std::string _default_default_value_; 896 ::google::protobuf::FieldOptions* options_; 897 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 898 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 899 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 900 901 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 902 903 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 904 inline bool _has_bit(int index) const { 905 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 906 } 907 inline void _set_bit(int index) { 908 _has_bits_[index / 32] |= (1u << (index % 32)); 909 } 910 inline void _clear_bit(int index) { 911 _has_bits_[index / 32] &= ~(1u << (index % 32)); 912 } 913 914 void InitAsDefaultInstance(); 915 static FieldDescriptorProto* default_instance_; 916}; 917// ------------------------------------------------------------------- 918 919class LIBPROTOBUF_EXPORT EnumDescriptorProto : public ::google::protobuf::Message { 920 public: 921 EnumDescriptorProto(); 922 virtual ~EnumDescriptorProto(); 923 924 EnumDescriptorProto(const EnumDescriptorProto& from); 925 926 inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) { 927 CopyFrom(from); 928 return *this; 929 } 930 931 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 932 return _unknown_fields_; 933 } 934 935 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 936 return &_unknown_fields_; 937 } 938 939 static const ::google::protobuf::Descriptor* descriptor(); 940 static const EnumDescriptorProto& default_instance(); 941 942 void Swap(EnumDescriptorProto* other); 943 944 // implements Message ---------------------------------------------- 945 946 EnumDescriptorProto* New() const; 947 void CopyFrom(const ::google::protobuf::Message& from); 948 void MergeFrom(const ::google::protobuf::Message& from); 949 void CopyFrom(const EnumDescriptorProto& from); 950 void MergeFrom(const EnumDescriptorProto& from); 951 void Clear(); 952 bool IsInitialized() const; 953 954 int ByteSize() const; 955 bool MergePartialFromCodedStream( 956 ::google::protobuf::io::CodedInputStream* input); 957 void SerializeWithCachedSizes( 958 ::google::protobuf::io::CodedOutputStream* output) const; 959 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 960 int GetCachedSize() const { return _cached_size_; } 961 private: 962 void SharedCtor(); 963 void SharedDtor(); 964 void SetCachedSize(int size) const; 965 public: 966 967 ::google::protobuf::Metadata GetMetadata() const; 968 969 // nested types ---------------------------------------------------- 970 971 // accessors ------------------------------------------------------- 972 973 // optional string name = 1; 974 inline bool has_name() const; 975 inline void clear_name(); 976 static const int kNameFieldNumber = 1; 977 inline const ::std::string& name() const; 978 inline void set_name(const ::std::string& value); 979 inline void set_name(const char* value); 980 inline void set_name(const char* value, size_t size); 981 inline ::std::string* mutable_name(); 982 983 // repeated .google.protobuf.EnumValueDescriptorProto value = 2; 984 inline int value_size() const; 985 inline void clear_value(); 986 static const int kValueFieldNumber = 2; 987 inline const ::google::protobuf::EnumValueDescriptorProto& value(int index) const; 988 inline ::google::protobuf::EnumValueDescriptorProto* mutable_value(int index); 989 inline ::google::protobuf::EnumValueDescriptorProto* add_value(); 990 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >& 991 value() const; 992 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >* 993 mutable_value(); 994 995 // optional .google.protobuf.EnumOptions options = 3; 996 inline bool has_options() const; 997 inline void clear_options(); 998 static const int kOptionsFieldNumber = 3; 999 inline const ::google::protobuf::EnumOptions& options() const; 1000 inline ::google::protobuf::EnumOptions* mutable_options(); 1001 1002 // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto) 1003 private: 1004 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1005 mutable int _cached_size_; 1006 1007 ::std::string* name_; 1008 static const ::std::string _default_name_; 1009 ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto > value_; 1010 ::google::protobuf::EnumOptions* options_; 1011 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1012 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1013 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1014 1015 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1016 1017 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1018 inline bool _has_bit(int index) const { 1019 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1020 } 1021 inline void _set_bit(int index) { 1022 _has_bits_[index / 32] |= (1u << (index % 32)); 1023 } 1024 inline void _clear_bit(int index) { 1025 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1026 } 1027 1028 void InitAsDefaultInstance(); 1029 static EnumDescriptorProto* default_instance_; 1030}; 1031// ------------------------------------------------------------------- 1032 1033class LIBPROTOBUF_EXPORT EnumValueDescriptorProto : public ::google::protobuf::Message { 1034 public: 1035 EnumValueDescriptorProto(); 1036 virtual ~EnumValueDescriptorProto(); 1037 1038 EnumValueDescriptorProto(const EnumValueDescriptorProto& from); 1039 1040 inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) { 1041 CopyFrom(from); 1042 return *this; 1043 } 1044 1045 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1046 return _unknown_fields_; 1047 } 1048 1049 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1050 return &_unknown_fields_; 1051 } 1052 1053 static const ::google::protobuf::Descriptor* descriptor(); 1054 static const EnumValueDescriptorProto& default_instance(); 1055 1056 void Swap(EnumValueDescriptorProto* other); 1057 1058 // implements Message ---------------------------------------------- 1059 1060 EnumValueDescriptorProto* New() const; 1061 void CopyFrom(const ::google::protobuf::Message& from); 1062 void MergeFrom(const ::google::protobuf::Message& from); 1063 void CopyFrom(const EnumValueDescriptorProto& from); 1064 void MergeFrom(const EnumValueDescriptorProto& from); 1065 void Clear(); 1066 bool IsInitialized() const; 1067 1068 int ByteSize() const; 1069 bool MergePartialFromCodedStream( 1070 ::google::protobuf::io::CodedInputStream* input); 1071 void SerializeWithCachedSizes( 1072 ::google::protobuf::io::CodedOutputStream* output) const; 1073 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1074 int GetCachedSize() const { return _cached_size_; } 1075 private: 1076 void SharedCtor(); 1077 void SharedDtor(); 1078 void SetCachedSize(int size) const; 1079 public: 1080 1081 ::google::protobuf::Metadata GetMetadata() const; 1082 1083 // nested types ---------------------------------------------------- 1084 1085 // accessors ------------------------------------------------------- 1086 1087 // optional string name = 1; 1088 inline bool has_name() const; 1089 inline void clear_name(); 1090 static const int kNameFieldNumber = 1; 1091 inline const ::std::string& name() const; 1092 inline void set_name(const ::std::string& value); 1093 inline void set_name(const char* value); 1094 inline void set_name(const char* value, size_t size); 1095 inline ::std::string* mutable_name(); 1096 1097 // optional int32 number = 2; 1098 inline bool has_number() const; 1099 inline void clear_number(); 1100 static const int kNumberFieldNumber = 2; 1101 inline ::google::protobuf::int32 number() const; 1102 inline void set_number(::google::protobuf::int32 value); 1103 1104 // optional .google.protobuf.EnumValueOptions options = 3; 1105 inline bool has_options() const; 1106 inline void clear_options(); 1107 static const int kOptionsFieldNumber = 3; 1108 inline const ::google::protobuf::EnumValueOptions& options() const; 1109 inline ::google::protobuf::EnumValueOptions* mutable_options(); 1110 1111 // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto) 1112 private: 1113 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1114 mutable int _cached_size_; 1115 1116 ::std::string* name_; 1117 static const ::std::string _default_name_; 1118 ::google::protobuf::int32 number_; 1119 ::google::protobuf::EnumValueOptions* options_; 1120 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1121 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1122 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1123 1124 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1125 1126 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1127 inline bool _has_bit(int index) const { 1128 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1129 } 1130 inline void _set_bit(int index) { 1131 _has_bits_[index / 32] |= (1u << (index % 32)); 1132 } 1133 inline void _clear_bit(int index) { 1134 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1135 } 1136 1137 void InitAsDefaultInstance(); 1138 static EnumValueDescriptorProto* default_instance_; 1139}; 1140// ------------------------------------------------------------------- 1141 1142class LIBPROTOBUF_EXPORT ServiceDescriptorProto : public ::google::protobuf::Message { 1143 public: 1144 ServiceDescriptorProto(); 1145 virtual ~ServiceDescriptorProto(); 1146 1147 ServiceDescriptorProto(const ServiceDescriptorProto& from); 1148 1149 inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) { 1150 CopyFrom(from); 1151 return *this; 1152 } 1153 1154 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1155 return _unknown_fields_; 1156 } 1157 1158 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1159 return &_unknown_fields_; 1160 } 1161 1162 static const ::google::protobuf::Descriptor* descriptor(); 1163 static const ServiceDescriptorProto& default_instance(); 1164 1165 void Swap(ServiceDescriptorProto* other); 1166 1167 // implements Message ---------------------------------------------- 1168 1169 ServiceDescriptorProto* New() const; 1170 void CopyFrom(const ::google::protobuf::Message& from); 1171 void MergeFrom(const ::google::protobuf::Message& from); 1172 void CopyFrom(const ServiceDescriptorProto& from); 1173 void MergeFrom(const ServiceDescriptorProto& from); 1174 void Clear(); 1175 bool IsInitialized() const; 1176 1177 int ByteSize() const; 1178 bool MergePartialFromCodedStream( 1179 ::google::protobuf::io::CodedInputStream* input); 1180 void SerializeWithCachedSizes( 1181 ::google::protobuf::io::CodedOutputStream* output) const; 1182 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1183 int GetCachedSize() const { return _cached_size_; } 1184 private: 1185 void SharedCtor(); 1186 void SharedDtor(); 1187 void SetCachedSize(int size) const; 1188 public: 1189 1190 ::google::protobuf::Metadata GetMetadata() const; 1191 1192 // nested types ---------------------------------------------------- 1193 1194 // accessors ------------------------------------------------------- 1195 1196 // optional string name = 1; 1197 inline bool has_name() const; 1198 inline void clear_name(); 1199 static const int kNameFieldNumber = 1; 1200 inline const ::std::string& name() const; 1201 inline void set_name(const ::std::string& value); 1202 inline void set_name(const char* value); 1203 inline void set_name(const char* value, size_t size); 1204 inline ::std::string* mutable_name(); 1205 1206 // repeated .google.protobuf.MethodDescriptorProto method = 2; 1207 inline int method_size() const; 1208 inline void clear_method(); 1209 static const int kMethodFieldNumber = 2; 1210 inline const ::google::protobuf::MethodDescriptorProto& method(int index) const; 1211 inline ::google::protobuf::MethodDescriptorProto* mutable_method(int index); 1212 inline ::google::protobuf::MethodDescriptorProto* add_method(); 1213 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >& 1214 method() const; 1215 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >* 1216 mutable_method(); 1217 1218 // optional .google.protobuf.ServiceOptions options = 3; 1219 inline bool has_options() const; 1220 inline void clear_options(); 1221 static const int kOptionsFieldNumber = 3; 1222 inline const ::google::protobuf::ServiceOptions& options() const; 1223 inline ::google::protobuf::ServiceOptions* mutable_options(); 1224 1225 // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto) 1226 private: 1227 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1228 mutable int _cached_size_; 1229 1230 ::std::string* name_; 1231 static const ::std::string _default_name_; 1232 ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto > method_; 1233 ::google::protobuf::ServiceOptions* options_; 1234 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1235 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1236 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1237 1238 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1239 1240 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1241 inline bool _has_bit(int index) const { 1242 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1243 } 1244 inline void _set_bit(int index) { 1245 _has_bits_[index / 32] |= (1u << (index % 32)); 1246 } 1247 inline void _clear_bit(int index) { 1248 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1249 } 1250 1251 void InitAsDefaultInstance(); 1252 static ServiceDescriptorProto* default_instance_; 1253}; 1254// ------------------------------------------------------------------- 1255 1256class LIBPROTOBUF_EXPORT MethodDescriptorProto : public ::google::protobuf::Message { 1257 public: 1258 MethodDescriptorProto(); 1259 virtual ~MethodDescriptorProto(); 1260 1261 MethodDescriptorProto(const MethodDescriptorProto& from); 1262 1263 inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) { 1264 CopyFrom(from); 1265 return *this; 1266 } 1267 1268 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1269 return _unknown_fields_; 1270 } 1271 1272 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1273 return &_unknown_fields_; 1274 } 1275 1276 static const ::google::protobuf::Descriptor* descriptor(); 1277 static const MethodDescriptorProto& default_instance(); 1278 1279 void Swap(MethodDescriptorProto* other); 1280 1281 // implements Message ---------------------------------------------- 1282 1283 MethodDescriptorProto* New() const; 1284 void CopyFrom(const ::google::protobuf::Message& from); 1285 void MergeFrom(const ::google::protobuf::Message& from); 1286 void CopyFrom(const MethodDescriptorProto& from); 1287 void MergeFrom(const MethodDescriptorProto& from); 1288 void Clear(); 1289 bool IsInitialized() const; 1290 1291 int ByteSize() const; 1292 bool MergePartialFromCodedStream( 1293 ::google::protobuf::io::CodedInputStream* input); 1294 void SerializeWithCachedSizes( 1295 ::google::protobuf::io::CodedOutputStream* output) const; 1296 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1297 int GetCachedSize() const { return _cached_size_; } 1298 private: 1299 void SharedCtor(); 1300 void SharedDtor(); 1301 void SetCachedSize(int size) const; 1302 public: 1303 1304 ::google::protobuf::Metadata GetMetadata() const; 1305 1306 // nested types ---------------------------------------------------- 1307 1308 // accessors ------------------------------------------------------- 1309 1310 // optional string name = 1; 1311 inline bool has_name() const; 1312 inline void clear_name(); 1313 static const int kNameFieldNumber = 1; 1314 inline const ::std::string& name() const; 1315 inline void set_name(const ::std::string& value); 1316 inline void set_name(const char* value); 1317 inline void set_name(const char* value, size_t size); 1318 inline ::std::string* mutable_name(); 1319 1320 // optional string input_type = 2; 1321 inline bool has_input_type() const; 1322 inline void clear_input_type(); 1323 static const int kInputTypeFieldNumber = 2; 1324 inline const ::std::string& input_type() const; 1325 inline void set_input_type(const ::std::string& value); 1326 inline void set_input_type(const char* value); 1327 inline void set_input_type(const char* value, size_t size); 1328 inline ::std::string* mutable_input_type(); 1329 1330 // optional string output_type = 3; 1331 inline bool has_output_type() const; 1332 inline void clear_output_type(); 1333 static const int kOutputTypeFieldNumber = 3; 1334 inline const ::std::string& output_type() const; 1335 inline void set_output_type(const ::std::string& value); 1336 inline void set_output_type(const char* value); 1337 inline void set_output_type(const char* value, size_t size); 1338 inline ::std::string* mutable_output_type(); 1339 1340 // optional .google.protobuf.MethodOptions options = 4; 1341 inline bool has_options() const; 1342 inline void clear_options(); 1343 static const int kOptionsFieldNumber = 4; 1344 inline const ::google::protobuf::MethodOptions& options() const; 1345 inline ::google::protobuf::MethodOptions* mutable_options(); 1346 1347 // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto) 1348 private: 1349 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1350 mutable int _cached_size_; 1351 1352 ::std::string* name_; 1353 static const ::std::string _default_name_; 1354 ::std::string* input_type_; 1355 static const ::std::string _default_input_type_; 1356 ::std::string* output_type_; 1357 static const ::std::string _default_output_type_; 1358 ::google::protobuf::MethodOptions* options_; 1359 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1360 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1361 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1362 1363 ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; 1364 1365 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1366 inline bool _has_bit(int index) const { 1367 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1368 } 1369 inline void _set_bit(int index) { 1370 _has_bits_[index / 32] |= (1u << (index % 32)); 1371 } 1372 inline void _clear_bit(int index) { 1373 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1374 } 1375 1376 void InitAsDefaultInstance(); 1377 static MethodDescriptorProto* default_instance_; 1378}; 1379// ------------------------------------------------------------------- 1380 1381class LIBPROTOBUF_EXPORT FileOptions : public ::google::protobuf::Message { 1382 public: 1383 FileOptions(); 1384 virtual ~FileOptions(); 1385 1386 FileOptions(const FileOptions& from); 1387 1388 inline FileOptions& operator=(const FileOptions& from) { 1389 CopyFrom(from); 1390 return *this; 1391 } 1392 1393 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1394 return _unknown_fields_; 1395 } 1396 1397 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1398 return &_unknown_fields_; 1399 } 1400 1401 static const ::google::protobuf::Descriptor* descriptor(); 1402 static const FileOptions& default_instance(); 1403 1404 void Swap(FileOptions* other); 1405 1406 // implements Message ---------------------------------------------- 1407 1408 FileOptions* New() const; 1409 void CopyFrom(const ::google::protobuf::Message& from); 1410 void MergeFrom(const ::google::protobuf::Message& from); 1411 void CopyFrom(const FileOptions& from); 1412 void MergeFrom(const FileOptions& from); 1413 void Clear(); 1414 bool IsInitialized() const; 1415 1416 int ByteSize() const; 1417 bool MergePartialFromCodedStream( 1418 ::google::protobuf::io::CodedInputStream* input); 1419 void SerializeWithCachedSizes( 1420 ::google::protobuf::io::CodedOutputStream* output) const; 1421 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1422 int GetCachedSize() const { return _cached_size_; } 1423 private: 1424 void SharedCtor(); 1425 void SharedDtor(); 1426 void SetCachedSize(int size) const; 1427 public: 1428 1429 ::google::protobuf::Metadata GetMetadata() const; 1430 1431 // nested types ---------------------------------------------------- 1432 1433 typedef FileOptions_OptimizeMode OptimizeMode; 1434 static const OptimizeMode SPEED = FileOptions_OptimizeMode_SPEED; 1435 static const OptimizeMode CODE_SIZE = FileOptions_OptimizeMode_CODE_SIZE; 1436 static const OptimizeMode LITE_RUNTIME = FileOptions_OptimizeMode_LITE_RUNTIME; 1437 static inline bool OptimizeMode_IsValid(int value) { 1438 return FileOptions_OptimizeMode_IsValid(value); 1439 } 1440 static const OptimizeMode OptimizeMode_MIN = 1441 FileOptions_OptimizeMode_OptimizeMode_MIN; 1442 static const OptimizeMode OptimizeMode_MAX = 1443 FileOptions_OptimizeMode_OptimizeMode_MAX; 1444 static const int OptimizeMode_ARRAYSIZE = 1445 FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE; 1446 static inline const ::google::protobuf::EnumDescriptor* 1447 OptimizeMode_descriptor() { 1448 return FileOptions_OptimizeMode_descriptor(); 1449 } 1450 static inline const ::std::string& OptimizeMode_Name(OptimizeMode value) { 1451 return FileOptions_OptimizeMode_Name(value); 1452 } 1453 static inline bool OptimizeMode_Parse(const ::std::string& name, 1454 OptimizeMode* value) { 1455 return FileOptions_OptimizeMode_Parse(name, value); 1456 } 1457 1458 // accessors ------------------------------------------------------- 1459 1460 // optional string java_package = 1; 1461 inline bool has_java_package() const; 1462 inline void clear_java_package(); 1463 static const int kJavaPackageFieldNumber = 1; 1464 inline const ::std::string& java_package() const; 1465 inline void set_java_package(const ::std::string& value); 1466 inline void set_java_package(const char* value); 1467 inline void set_java_package(const char* value, size_t size); 1468 inline ::std::string* mutable_java_package(); 1469 1470 // optional string java_outer_classname = 8; 1471 inline bool has_java_outer_classname() const; 1472 inline void clear_java_outer_classname(); 1473 static const int kJavaOuterClassnameFieldNumber = 8; 1474 inline const ::std::string& java_outer_classname() const; 1475 inline void set_java_outer_classname(const ::std::string& value); 1476 inline void set_java_outer_classname(const char* value); 1477 inline void set_java_outer_classname(const char* value, size_t size); 1478 inline ::std::string* mutable_java_outer_classname(); 1479 1480 // optional bool java_multiple_files = 10 [default = false]; 1481 inline bool has_java_multiple_files() const; 1482 inline void clear_java_multiple_files(); 1483 static const int kJavaMultipleFilesFieldNumber = 10; 1484 inline bool java_multiple_files() const; 1485 inline void set_java_multiple_files(bool value); 1486 1487 // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; 1488 inline bool has_optimize_for() const; 1489 inline void clear_optimize_for(); 1490 static const int kOptimizeForFieldNumber = 9; 1491 inline ::google::protobuf::FileOptions_OptimizeMode optimize_for() const; 1492 inline void set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value); 1493 1494 // optional bool cc_generic_services = 16 [default = true]; 1495 inline bool has_cc_generic_services() const; 1496 inline void clear_cc_generic_services(); 1497 static const int kCcGenericServicesFieldNumber = 16; 1498 inline bool cc_generic_services() const; 1499 inline void set_cc_generic_services(bool value); 1500 1501 // optional bool java_generic_services = 17 [default = true]; 1502 inline bool has_java_generic_services() const; 1503 inline void clear_java_generic_services(); 1504 static const int kJavaGenericServicesFieldNumber = 17; 1505 inline bool java_generic_services() const; 1506 inline void set_java_generic_services(bool value); 1507 1508 // optional bool py_generic_services = 18 [default = true]; 1509 inline bool has_py_generic_services() const; 1510 inline void clear_py_generic_services(); 1511 static const int kPyGenericServicesFieldNumber = 18; 1512 inline bool py_generic_services() const; 1513 inline void set_py_generic_services(bool value); 1514 1515 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1516 inline int uninterpreted_option_size() const; 1517 inline void clear_uninterpreted_option(); 1518 static const int kUninterpretedOptionFieldNumber = 999; 1519 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1520 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1521 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1522 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1523 uninterpreted_option() const; 1524 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1525 mutable_uninterpreted_option(); 1526 1527 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FileOptions) 1528 // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions) 1529 private: 1530 ::google::protobuf::internal::ExtensionSet _extensions_; 1531 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1532 mutable int _cached_size_; 1533 1534 ::std::string* java_package_; 1535 static const ::std::string _default_java_package_; 1536 ::std::string* java_outer_classname_; 1537 static const ::std::string _default_java_outer_classname_; 1538 bool java_multiple_files_; 1539 int optimize_for_; 1540 bool cc_generic_services_; 1541 bool java_generic_services_; 1542 bool py_generic_services_; 1543 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1544 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1545 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1546 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1547 1548 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 1549 1550 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1551 inline bool _has_bit(int index) const { 1552 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1553 } 1554 inline void _set_bit(int index) { 1555 _has_bits_[index / 32] |= (1u << (index % 32)); 1556 } 1557 inline void _clear_bit(int index) { 1558 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1559 } 1560 1561 void InitAsDefaultInstance(); 1562 static FileOptions* default_instance_; 1563}; 1564// ------------------------------------------------------------------- 1565 1566class LIBPROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message { 1567 public: 1568 MessageOptions(); 1569 virtual ~MessageOptions(); 1570 1571 MessageOptions(const MessageOptions& from); 1572 1573 inline MessageOptions& operator=(const MessageOptions& from) { 1574 CopyFrom(from); 1575 return *this; 1576 } 1577 1578 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1579 return _unknown_fields_; 1580 } 1581 1582 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1583 return &_unknown_fields_; 1584 } 1585 1586 static const ::google::protobuf::Descriptor* descriptor(); 1587 static const MessageOptions& default_instance(); 1588 1589 void Swap(MessageOptions* other); 1590 1591 // implements Message ---------------------------------------------- 1592 1593 MessageOptions* New() const; 1594 void CopyFrom(const ::google::protobuf::Message& from); 1595 void MergeFrom(const ::google::protobuf::Message& from); 1596 void CopyFrom(const MessageOptions& from); 1597 void MergeFrom(const MessageOptions& from); 1598 void Clear(); 1599 bool IsInitialized() const; 1600 1601 int ByteSize() const; 1602 bool MergePartialFromCodedStream( 1603 ::google::protobuf::io::CodedInputStream* input); 1604 void SerializeWithCachedSizes( 1605 ::google::protobuf::io::CodedOutputStream* output) const; 1606 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1607 int GetCachedSize() const { return _cached_size_; } 1608 private: 1609 void SharedCtor(); 1610 void SharedDtor(); 1611 void SetCachedSize(int size) const; 1612 public: 1613 1614 ::google::protobuf::Metadata GetMetadata() const; 1615 1616 // nested types ---------------------------------------------------- 1617 1618 // accessors ------------------------------------------------------- 1619 1620 // optional bool message_set_wire_format = 1 [default = false]; 1621 inline bool has_message_set_wire_format() const; 1622 inline void clear_message_set_wire_format(); 1623 static const int kMessageSetWireFormatFieldNumber = 1; 1624 inline bool message_set_wire_format() const; 1625 inline void set_message_set_wire_format(bool value); 1626 1627 // optional bool no_standard_descriptor_accessor = 2 [default = false]; 1628 inline bool has_no_standard_descriptor_accessor() const; 1629 inline void clear_no_standard_descriptor_accessor(); 1630 static const int kNoStandardDescriptorAccessorFieldNumber = 2; 1631 inline bool no_standard_descriptor_accessor() const; 1632 inline void set_no_standard_descriptor_accessor(bool value); 1633 1634 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1635 inline int uninterpreted_option_size() const; 1636 inline void clear_uninterpreted_option(); 1637 static const int kUninterpretedOptionFieldNumber = 999; 1638 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1639 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1640 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1641 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1642 uninterpreted_option() const; 1643 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1644 mutable_uninterpreted_option(); 1645 1646 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MessageOptions) 1647 // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions) 1648 private: 1649 ::google::protobuf::internal::ExtensionSet _extensions_; 1650 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1651 mutable int _cached_size_; 1652 1653 bool message_set_wire_format_; 1654 bool no_standard_descriptor_accessor_; 1655 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1656 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1657 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1658 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1659 1660 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1661 1662 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1663 inline bool _has_bit(int index) const { 1664 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1665 } 1666 inline void _set_bit(int index) { 1667 _has_bits_[index / 32] |= (1u << (index % 32)); 1668 } 1669 inline void _clear_bit(int index) { 1670 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1671 } 1672 1673 void InitAsDefaultInstance(); 1674 static MessageOptions* default_instance_; 1675}; 1676// ------------------------------------------------------------------- 1677 1678class LIBPROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message { 1679 public: 1680 FieldOptions(); 1681 virtual ~FieldOptions(); 1682 1683 FieldOptions(const FieldOptions& from); 1684 1685 inline FieldOptions& operator=(const FieldOptions& from) { 1686 CopyFrom(from); 1687 return *this; 1688 } 1689 1690 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1691 return _unknown_fields_; 1692 } 1693 1694 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1695 return &_unknown_fields_; 1696 } 1697 1698 static const ::google::protobuf::Descriptor* descriptor(); 1699 static const FieldOptions& default_instance(); 1700 1701 void Swap(FieldOptions* other); 1702 1703 // implements Message ---------------------------------------------- 1704 1705 FieldOptions* New() const; 1706 void CopyFrom(const ::google::protobuf::Message& from); 1707 void MergeFrom(const ::google::protobuf::Message& from); 1708 void CopyFrom(const FieldOptions& from); 1709 void MergeFrom(const FieldOptions& from); 1710 void Clear(); 1711 bool IsInitialized() const; 1712 1713 int ByteSize() const; 1714 bool MergePartialFromCodedStream( 1715 ::google::protobuf::io::CodedInputStream* input); 1716 void SerializeWithCachedSizes( 1717 ::google::protobuf::io::CodedOutputStream* output) const; 1718 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1719 int GetCachedSize() const { return _cached_size_; } 1720 private: 1721 void SharedCtor(); 1722 void SharedDtor(); 1723 void SetCachedSize(int size) const; 1724 public: 1725 1726 ::google::protobuf::Metadata GetMetadata() const; 1727 1728 // nested types ---------------------------------------------------- 1729 1730 typedef FieldOptions_CType CType; 1731 static const CType STRING = FieldOptions_CType_STRING; 1732 static const CType CORD = FieldOptions_CType_CORD; 1733 static const CType STRING_PIECE = FieldOptions_CType_STRING_PIECE; 1734 static inline bool CType_IsValid(int value) { 1735 return FieldOptions_CType_IsValid(value); 1736 } 1737 static const CType CType_MIN = 1738 FieldOptions_CType_CType_MIN; 1739 static const CType CType_MAX = 1740 FieldOptions_CType_CType_MAX; 1741 static const int CType_ARRAYSIZE = 1742 FieldOptions_CType_CType_ARRAYSIZE; 1743 static inline const ::google::protobuf::EnumDescriptor* 1744 CType_descriptor() { 1745 return FieldOptions_CType_descriptor(); 1746 } 1747 static inline const ::std::string& CType_Name(CType value) { 1748 return FieldOptions_CType_Name(value); 1749 } 1750 static inline bool CType_Parse(const ::std::string& name, 1751 CType* value) { 1752 return FieldOptions_CType_Parse(name, value); 1753 } 1754 1755 // accessors ------------------------------------------------------- 1756 1757 // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 1758 inline bool has_ctype() const; 1759 inline void clear_ctype(); 1760 static const int kCtypeFieldNumber = 1; 1761 inline ::google::protobuf::FieldOptions_CType ctype() const; 1762 inline void set_ctype(::google::protobuf::FieldOptions_CType value); 1763 1764 // optional bool packed = 2; 1765 inline bool has_packed() const; 1766 inline void clear_packed(); 1767 static const int kPackedFieldNumber = 2; 1768 inline bool packed() const; 1769 inline void set_packed(bool value); 1770 1771 // optional bool deprecated = 3 [default = false]; 1772 inline bool has_deprecated() const; 1773 inline void clear_deprecated(); 1774 static const int kDeprecatedFieldNumber = 3; 1775 inline bool deprecated() const; 1776 inline void set_deprecated(bool value); 1777 1778 // optional string experimental_map_key = 9; 1779 inline bool has_experimental_map_key() const; 1780 inline void clear_experimental_map_key(); 1781 static const int kExperimentalMapKeyFieldNumber = 9; 1782 inline const ::std::string& experimental_map_key() const; 1783 inline void set_experimental_map_key(const ::std::string& value); 1784 inline void set_experimental_map_key(const char* value); 1785 inline void set_experimental_map_key(const char* value, size_t size); 1786 inline ::std::string* mutable_experimental_map_key(); 1787 1788 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1789 inline int uninterpreted_option_size() const; 1790 inline void clear_uninterpreted_option(); 1791 static const int kUninterpretedOptionFieldNumber = 999; 1792 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1793 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1794 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1795 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1796 uninterpreted_option() const; 1797 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1798 mutable_uninterpreted_option(); 1799 1800 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FieldOptions) 1801 // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions) 1802 private: 1803 ::google::protobuf::internal::ExtensionSet _extensions_; 1804 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1805 mutable int _cached_size_; 1806 1807 int ctype_; 1808 bool packed_; 1809 bool deprecated_; 1810 ::std::string* experimental_map_key_; 1811 static const ::std::string _default_experimental_map_key_; 1812 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1813 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1814 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1815 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1816 1817 ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; 1818 1819 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1820 inline bool _has_bit(int index) const { 1821 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1822 } 1823 inline void _set_bit(int index) { 1824 _has_bits_[index / 32] |= (1u << (index % 32)); 1825 } 1826 inline void _clear_bit(int index) { 1827 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1828 } 1829 1830 void InitAsDefaultInstance(); 1831 static FieldOptions* default_instance_; 1832}; 1833// ------------------------------------------------------------------- 1834 1835class LIBPROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message { 1836 public: 1837 EnumOptions(); 1838 virtual ~EnumOptions(); 1839 1840 EnumOptions(const EnumOptions& from); 1841 1842 inline EnumOptions& operator=(const EnumOptions& from) { 1843 CopyFrom(from); 1844 return *this; 1845 } 1846 1847 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1848 return _unknown_fields_; 1849 } 1850 1851 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1852 return &_unknown_fields_; 1853 } 1854 1855 static const ::google::protobuf::Descriptor* descriptor(); 1856 static const EnumOptions& default_instance(); 1857 1858 void Swap(EnumOptions* other); 1859 1860 // implements Message ---------------------------------------------- 1861 1862 EnumOptions* New() const; 1863 void CopyFrom(const ::google::protobuf::Message& from); 1864 void MergeFrom(const ::google::protobuf::Message& from); 1865 void CopyFrom(const EnumOptions& from); 1866 void MergeFrom(const EnumOptions& from); 1867 void Clear(); 1868 bool IsInitialized() const; 1869 1870 int ByteSize() const; 1871 bool MergePartialFromCodedStream( 1872 ::google::protobuf::io::CodedInputStream* input); 1873 void SerializeWithCachedSizes( 1874 ::google::protobuf::io::CodedOutputStream* output) const; 1875 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1876 int GetCachedSize() const { return _cached_size_; } 1877 private: 1878 void SharedCtor(); 1879 void SharedDtor(); 1880 void SetCachedSize(int size) const; 1881 public: 1882 1883 ::google::protobuf::Metadata GetMetadata() const; 1884 1885 // nested types ---------------------------------------------------- 1886 1887 // accessors ------------------------------------------------------- 1888 1889 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1890 inline int uninterpreted_option_size() const; 1891 inline void clear_uninterpreted_option(); 1892 static const int kUninterpretedOptionFieldNumber = 999; 1893 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1894 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1895 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1896 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1897 uninterpreted_option() const; 1898 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1899 mutable_uninterpreted_option(); 1900 1901 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumOptions) 1902 // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions) 1903 private: 1904 ::google::protobuf::internal::ExtensionSet _extensions_; 1905 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1906 mutable int _cached_size_; 1907 1908 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1909 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1910 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1911 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1912 1913 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1914 1915 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1916 inline bool _has_bit(int index) const { 1917 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1918 } 1919 inline void _set_bit(int index) { 1920 _has_bits_[index / 32] |= (1u << (index % 32)); 1921 } 1922 inline void _clear_bit(int index) { 1923 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1924 } 1925 1926 void InitAsDefaultInstance(); 1927 static EnumOptions* default_instance_; 1928}; 1929// ------------------------------------------------------------------- 1930 1931class LIBPROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message { 1932 public: 1933 EnumValueOptions(); 1934 virtual ~EnumValueOptions(); 1935 1936 EnumValueOptions(const EnumValueOptions& from); 1937 1938 inline EnumValueOptions& operator=(const EnumValueOptions& from) { 1939 CopyFrom(from); 1940 return *this; 1941 } 1942 1943 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1944 return _unknown_fields_; 1945 } 1946 1947 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1948 return &_unknown_fields_; 1949 } 1950 1951 static const ::google::protobuf::Descriptor* descriptor(); 1952 static const EnumValueOptions& default_instance(); 1953 1954 void Swap(EnumValueOptions* other); 1955 1956 // implements Message ---------------------------------------------- 1957 1958 EnumValueOptions* New() const; 1959 void CopyFrom(const ::google::protobuf::Message& from); 1960 void MergeFrom(const ::google::protobuf::Message& from); 1961 void CopyFrom(const EnumValueOptions& from); 1962 void MergeFrom(const EnumValueOptions& from); 1963 void Clear(); 1964 bool IsInitialized() const; 1965 1966 int ByteSize() const; 1967 bool MergePartialFromCodedStream( 1968 ::google::protobuf::io::CodedInputStream* input); 1969 void SerializeWithCachedSizes( 1970 ::google::protobuf::io::CodedOutputStream* output) const; 1971 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1972 int GetCachedSize() const { return _cached_size_; } 1973 private: 1974 void SharedCtor(); 1975 void SharedDtor(); 1976 void SetCachedSize(int size) const; 1977 public: 1978 1979 ::google::protobuf::Metadata GetMetadata() const; 1980 1981 // nested types ---------------------------------------------------- 1982 1983 // accessors ------------------------------------------------------- 1984 1985 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1986 inline int uninterpreted_option_size() const; 1987 inline void clear_uninterpreted_option(); 1988 static const int kUninterpretedOptionFieldNumber = 999; 1989 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1990 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1991 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1992 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1993 uninterpreted_option() const; 1994 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1995 mutable_uninterpreted_option(); 1996 1997 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumValueOptions) 1998 // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions) 1999 private: 2000 ::google::protobuf::internal::ExtensionSet _extensions_; 2001 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2002 mutable int _cached_size_; 2003 2004 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2005 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2006 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2007 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2008 2009 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2010 2011 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2012 inline bool _has_bit(int index) const { 2013 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2014 } 2015 inline void _set_bit(int index) { 2016 _has_bits_[index / 32] |= (1u << (index % 32)); 2017 } 2018 inline void _clear_bit(int index) { 2019 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2020 } 2021 2022 void InitAsDefaultInstance(); 2023 static EnumValueOptions* default_instance_; 2024}; 2025// ------------------------------------------------------------------- 2026 2027class LIBPROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message { 2028 public: 2029 ServiceOptions(); 2030 virtual ~ServiceOptions(); 2031 2032 ServiceOptions(const ServiceOptions& from); 2033 2034 inline ServiceOptions& operator=(const ServiceOptions& from) { 2035 CopyFrom(from); 2036 return *this; 2037 } 2038 2039 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2040 return _unknown_fields_; 2041 } 2042 2043 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2044 return &_unknown_fields_; 2045 } 2046 2047 static const ::google::protobuf::Descriptor* descriptor(); 2048 static const ServiceOptions& default_instance(); 2049 2050 void Swap(ServiceOptions* other); 2051 2052 // implements Message ---------------------------------------------- 2053 2054 ServiceOptions* New() const; 2055 void CopyFrom(const ::google::protobuf::Message& from); 2056 void MergeFrom(const ::google::protobuf::Message& from); 2057 void CopyFrom(const ServiceOptions& from); 2058 void MergeFrom(const ServiceOptions& from); 2059 void Clear(); 2060 bool IsInitialized() const; 2061 2062 int ByteSize() const; 2063 bool MergePartialFromCodedStream( 2064 ::google::protobuf::io::CodedInputStream* input); 2065 void SerializeWithCachedSizes( 2066 ::google::protobuf::io::CodedOutputStream* output) const; 2067 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2068 int GetCachedSize() const { return _cached_size_; } 2069 private: 2070 void SharedCtor(); 2071 void SharedDtor(); 2072 void SetCachedSize(int size) const; 2073 public: 2074 2075 ::google::protobuf::Metadata GetMetadata() const; 2076 2077 // nested types ---------------------------------------------------- 2078 2079 // accessors ------------------------------------------------------- 2080 2081 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 2082 inline int uninterpreted_option_size() const; 2083 inline void clear_uninterpreted_option(); 2084 static const int kUninterpretedOptionFieldNumber = 999; 2085 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 2086 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 2087 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 2088 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 2089 uninterpreted_option() const; 2090 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 2091 mutable_uninterpreted_option(); 2092 2093 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ServiceOptions) 2094 // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions) 2095 private: 2096 ::google::protobuf::internal::ExtensionSet _extensions_; 2097 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2098 mutable int _cached_size_; 2099 2100 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2101 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2102 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2103 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2104 2105 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2106 2107 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2108 inline bool _has_bit(int index) const { 2109 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2110 } 2111 inline void _set_bit(int index) { 2112 _has_bits_[index / 32] |= (1u << (index % 32)); 2113 } 2114 inline void _clear_bit(int index) { 2115 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2116 } 2117 2118 void InitAsDefaultInstance(); 2119 static ServiceOptions* default_instance_; 2120}; 2121// ------------------------------------------------------------------- 2122 2123class LIBPROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message { 2124 public: 2125 MethodOptions(); 2126 virtual ~MethodOptions(); 2127 2128 MethodOptions(const MethodOptions& from); 2129 2130 inline MethodOptions& operator=(const MethodOptions& from) { 2131 CopyFrom(from); 2132 return *this; 2133 } 2134 2135 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2136 return _unknown_fields_; 2137 } 2138 2139 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2140 return &_unknown_fields_; 2141 } 2142 2143 static const ::google::protobuf::Descriptor* descriptor(); 2144 static const MethodOptions& default_instance(); 2145 2146 void Swap(MethodOptions* other); 2147 2148 // implements Message ---------------------------------------------- 2149 2150 MethodOptions* New() const; 2151 void CopyFrom(const ::google::protobuf::Message& from); 2152 void MergeFrom(const ::google::protobuf::Message& from); 2153 void CopyFrom(const MethodOptions& from); 2154 void MergeFrom(const MethodOptions& from); 2155 void Clear(); 2156 bool IsInitialized() const; 2157 2158 int ByteSize() const; 2159 bool MergePartialFromCodedStream( 2160 ::google::protobuf::io::CodedInputStream* input); 2161 void SerializeWithCachedSizes( 2162 ::google::protobuf::io::CodedOutputStream* output) const; 2163 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2164 int GetCachedSize() const { return _cached_size_; } 2165 private: 2166 void SharedCtor(); 2167 void SharedDtor(); 2168 void SetCachedSize(int size) const; 2169 public: 2170 2171 ::google::protobuf::Metadata GetMetadata() const; 2172 2173 // nested types ---------------------------------------------------- 2174 2175 // accessors ------------------------------------------------------- 2176 2177 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 2178 inline int uninterpreted_option_size() const; 2179 inline void clear_uninterpreted_option(); 2180 static const int kUninterpretedOptionFieldNumber = 999; 2181 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 2182 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 2183 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 2184 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 2185 uninterpreted_option() const; 2186 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 2187 mutable_uninterpreted_option(); 2188 2189 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MethodOptions) 2190 // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions) 2191 private: 2192 ::google::protobuf::internal::ExtensionSet _extensions_; 2193 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2194 mutable int _cached_size_; 2195 2196 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2197 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2198 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2199 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2200 2201 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2202 2203 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2204 inline bool _has_bit(int index) const { 2205 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2206 } 2207 inline void _set_bit(int index) { 2208 _has_bits_[index / 32] |= (1u << (index % 32)); 2209 } 2210 inline void _clear_bit(int index) { 2211 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2212 } 2213 2214 void InitAsDefaultInstance(); 2215 static MethodOptions* default_instance_; 2216}; 2217// ------------------------------------------------------------------- 2218 2219class LIBPROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf::Message { 2220 public: 2221 UninterpretedOption_NamePart(); 2222 virtual ~UninterpretedOption_NamePart(); 2223 2224 UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from); 2225 2226 inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) { 2227 CopyFrom(from); 2228 return *this; 2229 } 2230 2231 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2232 return _unknown_fields_; 2233 } 2234 2235 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2236 return &_unknown_fields_; 2237 } 2238 2239 static const ::google::protobuf::Descriptor* descriptor(); 2240 static const UninterpretedOption_NamePart& default_instance(); 2241 2242 void Swap(UninterpretedOption_NamePart* other); 2243 2244 // implements Message ---------------------------------------------- 2245 2246 UninterpretedOption_NamePart* New() const; 2247 void CopyFrom(const ::google::protobuf::Message& from); 2248 void MergeFrom(const ::google::protobuf::Message& from); 2249 void CopyFrom(const UninterpretedOption_NamePart& from); 2250 void MergeFrom(const UninterpretedOption_NamePart& from); 2251 void Clear(); 2252 bool IsInitialized() const; 2253 2254 int ByteSize() const; 2255 bool MergePartialFromCodedStream( 2256 ::google::protobuf::io::CodedInputStream* input); 2257 void SerializeWithCachedSizes( 2258 ::google::protobuf::io::CodedOutputStream* output) const; 2259 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2260 int GetCachedSize() const { return _cached_size_; } 2261 private: 2262 void SharedCtor(); 2263 void SharedDtor(); 2264 void SetCachedSize(int size) const; 2265 public: 2266 2267 ::google::protobuf::Metadata GetMetadata() const; 2268 2269 // nested types ---------------------------------------------------- 2270 2271 // accessors ------------------------------------------------------- 2272 2273 // required string name_part = 1; 2274 inline bool has_name_part() const; 2275 inline void clear_name_part(); 2276 static const int kNamePartFieldNumber = 1; 2277 inline const ::std::string& name_part() const; 2278 inline void set_name_part(const ::std::string& value); 2279 inline void set_name_part(const char* value); 2280 inline void set_name_part(const char* value, size_t size); 2281 inline ::std::string* mutable_name_part(); 2282 2283 // required bool is_extension = 2; 2284 inline bool has_is_extension() const; 2285 inline void clear_is_extension(); 2286 static const int kIsExtensionFieldNumber = 2; 2287 inline bool is_extension() const; 2288 inline void set_is_extension(bool value); 2289 2290 // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart) 2291 private: 2292 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2293 mutable int _cached_size_; 2294 2295 ::std::string* name_part_; 2296 static const ::std::string _default_name_part_; 2297 bool is_extension_; 2298 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2299 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2300 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2301 2302 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 2303 2304 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2305 inline bool _has_bit(int index) const { 2306 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2307 } 2308 inline void _set_bit(int index) { 2309 _has_bits_[index / 32] |= (1u << (index % 32)); 2310 } 2311 inline void _clear_bit(int index) { 2312 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2313 } 2314 2315 void InitAsDefaultInstance(); 2316 static UninterpretedOption_NamePart* default_instance_; 2317}; 2318// ------------------------------------------------------------------- 2319 2320class LIBPROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message { 2321 public: 2322 UninterpretedOption(); 2323 virtual ~UninterpretedOption(); 2324 2325 UninterpretedOption(const UninterpretedOption& from); 2326 2327 inline UninterpretedOption& operator=(const UninterpretedOption& from) { 2328 CopyFrom(from); 2329 return *this; 2330 } 2331 2332 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2333 return _unknown_fields_; 2334 } 2335 2336 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2337 return &_unknown_fields_; 2338 } 2339 2340 static const ::google::protobuf::Descriptor* descriptor(); 2341 static const UninterpretedOption& default_instance(); 2342 2343 void Swap(UninterpretedOption* other); 2344 2345 // implements Message ---------------------------------------------- 2346 2347 UninterpretedOption* New() const; 2348 void CopyFrom(const ::google::protobuf::Message& from); 2349 void MergeFrom(const ::google::protobuf::Message& from); 2350 void CopyFrom(const UninterpretedOption& from); 2351 void MergeFrom(const UninterpretedOption& from); 2352 void Clear(); 2353 bool IsInitialized() const; 2354 2355 int ByteSize() const; 2356 bool MergePartialFromCodedStream( 2357 ::google::protobuf::io::CodedInputStream* input); 2358 void SerializeWithCachedSizes( 2359 ::google::protobuf::io::CodedOutputStream* output) const; 2360 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2361 int GetCachedSize() const { return _cached_size_; } 2362 private: 2363 void SharedCtor(); 2364 void SharedDtor(); 2365 void SetCachedSize(int size) const; 2366 public: 2367 2368 ::google::protobuf::Metadata GetMetadata() const; 2369 2370 // nested types ---------------------------------------------------- 2371 2372 typedef UninterpretedOption_NamePart NamePart; 2373 2374 // accessors ------------------------------------------------------- 2375 2376 // repeated .google.protobuf.UninterpretedOption.NamePart name = 2; 2377 inline int name_size() const; 2378 inline void clear_name(); 2379 static const int kNameFieldNumber = 2; 2380 inline const ::google::protobuf::UninterpretedOption_NamePart& name(int index) const; 2381 inline ::google::protobuf::UninterpretedOption_NamePart* mutable_name(int index); 2382 inline ::google::protobuf::UninterpretedOption_NamePart* add_name(); 2383 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 2384 name() const; 2385 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 2386 mutable_name(); 2387 2388 // optional string identifier_value = 3; 2389 inline bool has_identifier_value() const; 2390 inline void clear_identifier_value(); 2391 static const int kIdentifierValueFieldNumber = 3; 2392 inline const ::std::string& identifier_value() const; 2393 inline void set_identifier_value(const ::std::string& value); 2394 inline void set_identifier_value(const char* value); 2395 inline void set_identifier_value(const char* value, size_t size); 2396 inline ::std::string* mutable_identifier_value(); 2397 2398 // optional uint64 positive_int_value = 4; 2399 inline bool has_positive_int_value() const; 2400 inline void clear_positive_int_value(); 2401 static const int kPositiveIntValueFieldNumber = 4; 2402 inline ::google::protobuf::uint64 positive_int_value() const; 2403 inline void set_positive_int_value(::google::protobuf::uint64 value); 2404 2405 // optional int64 negative_int_value = 5; 2406 inline bool has_negative_int_value() const; 2407 inline void clear_negative_int_value(); 2408 static const int kNegativeIntValueFieldNumber = 5; 2409 inline ::google::protobuf::int64 negative_int_value() const; 2410 inline void set_negative_int_value(::google::protobuf::int64 value); 2411 2412 // optional double double_value = 6; 2413 inline bool has_double_value() const; 2414 inline void clear_double_value(); 2415 static const int kDoubleValueFieldNumber = 6; 2416 inline double double_value() const; 2417 inline void set_double_value(double value); 2418 2419 // optional bytes string_value = 7; 2420 inline bool has_string_value() const; 2421 inline void clear_string_value(); 2422 static const int kStringValueFieldNumber = 7; 2423 inline const ::std::string& string_value() const; 2424 inline void set_string_value(const ::std::string& value); 2425 inline void set_string_value(const char* value); 2426 inline void set_string_value(const void* value, size_t size); 2427 inline ::std::string* mutable_string_value(); 2428 2429 // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption) 2430 private: 2431 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2432 mutable int _cached_size_; 2433 2434 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart > name_; 2435 ::std::string* identifier_value_; 2436 static const ::std::string _default_identifier_value_; 2437 ::google::protobuf::uint64 positive_int_value_; 2438 ::google::protobuf::int64 negative_int_value_; 2439 double double_value_; 2440 ::std::string* string_value_; 2441 static const ::std::string _default_string_value_; 2442 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2443 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2444 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2445 2446 ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; 2447 2448 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2449 inline bool _has_bit(int index) const { 2450 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2451 } 2452 inline void _set_bit(int index) { 2453 _has_bits_[index / 32] |= (1u << (index % 32)); 2454 } 2455 inline void _clear_bit(int index) { 2456 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2457 } 2458 2459 void InitAsDefaultInstance(); 2460 static UninterpretedOption* default_instance_; 2461}; 2462// =================================================================== 2463 2464 2465// =================================================================== 2466 2467// FileDescriptorSet 2468 2469// repeated .google.protobuf.FileDescriptorProto file = 1; 2470inline int FileDescriptorSet::file_size() const { 2471 return file_.size(); 2472} 2473inline void FileDescriptorSet::clear_file() { 2474 file_.Clear(); 2475} 2476inline const ::google::protobuf::FileDescriptorProto& FileDescriptorSet::file(int index) const { 2477 return file_.Get(index); 2478} 2479inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) { 2480 return file_.Mutable(index); 2481} 2482inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::add_file() { 2483 return file_.Add(); 2484} 2485inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >& 2486FileDescriptorSet::file() const { 2487 return file_; 2488} 2489inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >* 2490FileDescriptorSet::mutable_file() { 2491 return &file_; 2492} 2493 2494// ------------------------------------------------------------------- 2495 2496// FileDescriptorProto 2497 2498// optional string name = 1; 2499inline bool FileDescriptorProto::has_name() const { 2500 return _has_bit(0); 2501} 2502inline void FileDescriptorProto::clear_name() { 2503 if (name_ != &_default_name_) { 2504 name_->clear(); 2505 } 2506 _clear_bit(0); 2507} 2508inline const ::std::string& FileDescriptorProto::name() const { 2509 return *name_; 2510} 2511inline void FileDescriptorProto::set_name(const ::std::string& value) { 2512 _set_bit(0); 2513 if (name_ == &_default_name_) { 2514 name_ = new ::std::string; 2515 } 2516 name_->assign(value); 2517} 2518inline void FileDescriptorProto::set_name(const char* value) { 2519 _set_bit(0); 2520 if (name_ == &_default_name_) { 2521 name_ = new ::std::string; 2522 } 2523 name_->assign(value); 2524} 2525inline void FileDescriptorProto::set_name(const char* value, size_t size) { 2526 _set_bit(0); 2527 if (name_ == &_default_name_) { 2528 name_ = new ::std::string; 2529 } 2530 name_->assign(reinterpret_cast<const char*>(value), size); 2531} 2532inline ::std::string* FileDescriptorProto::mutable_name() { 2533 _set_bit(0); 2534 if (name_ == &_default_name_) { 2535 name_ = new ::std::string; 2536 } 2537 return name_; 2538} 2539 2540// optional string package = 2; 2541inline bool FileDescriptorProto::has_package() const { 2542 return _has_bit(1); 2543} 2544inline void FileDescriptorProto::clear_package() { 2545 if (package_ != &_default_package_) { 2546 package_->clear(); 2547 } 2548 _clear_bit(1); 2549} 2550inline const ::std::string& FileDescriptorProto::package() const { 2551 return *package_; 2552} 2553inline void FileDescriptorProto::set_package(const ::std::string& value) { 2554 _set_bit(1); 2555 if (package_ == &_default_package_) { 2556 package_ = new ::std::string; 2557 } 2558 package_->assign(value); 2559} 2560inline void FileDescriptorProto::set_package(const char* value) { 2561 _set_bit(1); 2562 if (package_ == &_default_package_) { 2563 package_ = new ::std::string; 2564 } 2565 package_->assign(value); 2566} 2567inline void FileDescriptorProto::set_package(const char* value, size_t size) { 2568 _set_bit(1); 2569 if (package_ == &_default_package_) { 2570 package_ = new ::std::string; 2571 } 2572 package_->assign(reinterpret_cast<const char*>(value), size); 2573} 2574inline ::std::string* FileDescriptorProto::mutable_package() { 2575 _set_bit(1); 2576 if (package_ == &_default_package_) { 2577 package_ = new ::std::string; 2578 } 2579 return package_; 2580} 2581 2582// repeated string dependency = 3; 2583inline int FileDescriptorProto::dependency_size() const { 2584 return dependency_.size(); 2585} 2586inline void FileDescriptorProto::clear_dependency() { 2587 dependency_.Clear(); 2588} 2589inline const ::std::string& FileDescriptorProto::dependency(int index) const { 2590 return dependency_.Get(index); 2591} 2592inline ::std::string* FileDescriptorProto::mutable_dependency(int index) { 2593 return dependency_.Mutable(index); 2594} 2595inline void FileDescriptorProto::set_dependency(int index, const ::std::string& value) { 2596 dependency_.Mutable(index)->assign(value); 2597} 2598inline void FileDescriptorProto::set_dependency(int index, const char* value) { 2599 dependency_.Mutable(index)->assign(value); 2600} 2601inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) { 2602 dependency_.Mutable(index)->assign( 2603 reinterpret_cast<const char*>(value), size); 2604} 2605inline ::std::string* FileDescriptorProto::add_dependency() { 2606 return dependency_.Add(); 2607} 2608inline void FileDescriptorProto::add_dependency(const ::std::string& value) { 2609 dependency_.Add()->assign(value); 2610} 2611inline void FileDescriptorProto::add_dependency(const char* value) { 2612 dependency_.Add()->assign(value); 2613} 2614inline void FileDescriptorProto::add_dependency(const char* value, size_t size) { 2615 dependency_.Add()->assign(reinterpret_cast<const char*>(value), size); 2616} 2617inline const ::google::protobuf::RepeatedPtrField< ::std::string>& 2618FileDescriptorProto::dependency() const { 2619 return dependency_; 2620} 2621inline ::google::protobuf::RepeatedPtrField< ::std::string>* 2622FileDescriptorProto::mutable_dependency() { 2623 return &dependency_; 2624} 2625 2626// repeated .google.protobuf.DescriptorProto message_type = 4; 2627inline int FileDescriptorProto::message_type_size() const { 2628 return message_type_.size(); 2629} 2630inline void FileDescriptorProto::clear_message_type() { 2631 message_type_.Clear(); 2632} 2633inline const ::google::protobuf::DescriptorProto& FileDescriptorProto::message_type(int index) const { 2634 return message_type_.Get(index); 2635} 2636inline ::google::protobuf::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) { 2637 return message_type_.Mutable(index); 2638} 2639inline ::google::protobuf::DescriptorProto* FileDescriptorProto::add_message_type() { 2640 return message_type_.Add(); 2641} 2642inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 2643FileDescriptorProto::message_type() const { 2644 return message_type_; 2645} 2646inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 2647FileDescriptorProto::mutable_message_type() { 2648 return &message_type_; 2649} 2650 2651// repeated .google.protobuf.EnumDescriptorProto enum_type = 5; 2652inline int FileDescriptorProto::enum_type_size() const { 2653 return enum_type_.size(); 2654} 2655inline void FileDescriptorProto::clear_enum_type() { 2656 enum_type_.Clear(); 2657} 2658inline const ::google::protobuf::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const { 2659 return enum_type_.Get(index); 2660} 2661inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) { 2662 return enum_type_.Mutable(index); 2663} 2664inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::add_enum_type() { 2665 return enum_type_.Add(); 2666} 2667inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 2668FileDescriptorProto::enum_type() const { 2669 return enum_type_; 2670} 2671inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 2672FileDescriptorProto::mutable_enum_type() { 2673 return &enum_type_; 2674} 2675 2676// repeated .google.protobuf.ServiceDescriptorProto service = 6; 2677inline int FileDescriptorProto::service_size() const { 2678 return service_.size(); 2679} 2680inline void FileDescriptorProto::clear_service() { 2681 service_.Clear(); 2682} 2683inline const ::google::protobuf::ServiceDescriptorProto& FileDescriptorProto::service(int index) const { 2684 return service_.Get(index); 2685} 2686inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) { 2687 return service_.Mutable(index); 2688} 2689inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::add_service() { 2690 return service_.Add(); 2691} 2692inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >& 2693FileDescriptorProto::service() const { 2694 return service_; 2695} 2696inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >* 2697FileDescriptorProto::mutable_service() { 2698 return &service_; 2699} 2700 2701// repeated .google.protobuf.FieldDescriptorProto extension = 7; 2702inline int FileDescriptorProto::extension_size() const { 2703 return extension_.size(); 2704} 2705inline void FileDescriptorProto::clear_extension() { 2706 extension_.Clear(); 2707} 2708inline const ::google::protobuf::FieldDescriptorProto& FileDescriptorProto::extension(int index) const { 2709 return extension_.Get(index); 2710} 2711inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) { 2712 return extension_.Mutable(index); 2713} 2714inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::add_extension() { 2715 return extension_.Add(); 2716} 2717inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 2718FileDescriptorProto::extension() const { 2719 return extension_; 2720} 2721inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 2722FileDescriptorProto::mutable_extension() { 2723 return &extension_; 2724} 2725 2726// optional .google.protobuf.FileOptions options = 8; 2727inline bool FileDescriptorProto::has_options() const { 2728 return _has_bit(7); 2729} 2730inline void FileDescriptorProto::clear_options() { 2731 if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear(); 2732 _clear_bit(7); 2733} 2734inline const ::google::protobuf::FileOptions& FileDescriptorProto::options() const { 2735 return options_ != NULL ? *options_ : *default_instance_->options_; 2736} 2737inline ::google::protobuf::FileOptions* FileDescriptorProto::mutable_options() { 2738 _set_bit(7); 2739 if (options_ == NULL) options_ = new ::google::protobuf::FileOptions; 2740 return options_; 2741} 2742 2743// ------------------------------------------------------------------- 2744 2745// DescriptorProto_ExtensionRange 2746 2747// optional int32 start = 1; 2748inline bool DescriptorProto_ExtensionRange::has_start() const { 2749 return _has_bit(0); 2750} 2751inline void DescriptorProto_ExtensionRange::clear_start() { 2752 start_ = 0; 2753 _clear_bit(0); 2754} 2755inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::start() const { 2756 return start_; 2757} 2758inline void DescriptorProto_ExtensionRange::set_start(::google::protobuf::int32 value) { 2759 _set_bit(0); 2760 start_ = value; 2761} 2762 2763// optional int32 end = 2; 2764inline bool DescriptorProto_ExtensionRange::has_end() const { 2765 return _has_bit(1); 2766} 2767inline void DescriptorProto_ExtensionRange::clear_end() { 2768 end_ = 0; 2769 _clear_bit(1); 2770} 2771inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::end() const { 2772 return end_; 2773} 2774inline void DescriptorProto_ExtensionRange::set_end(::google::protobuf::int32 value) { 2775 _set_bit(1); 2776 end_ = value; 2777} 2778 2779// ------------------------------------------------------------------- 2780 2781// DescriptorProto 2782 2783// optional string name = 1; 2784inline bool DescriptorProto::has_name() const { 2785 return _has_bit(0); 2786} 2787inline void DescriptorProto::clear_name() { 2788 if (name_ != &_default_name_) { 2789 name_->clear(); 2790 } 2791 _clear_bit(0); 2792} 2793inline const ::std::string& DescriptorProto::name() const { 2794 return *name_; 2795} 2796inline void DescriptorProto::set_name(const ::std::string& value) { 2797 _set_bit(0); 2798 if (name_ == &_default_name_) { 2799 name_ = new ::std::string; 2800 } 2801 name_->assign(value); 2802} 2803inline void DescriptorProto::set_name(const char* value) { 2804 _set_bit(0); 2805 if (name_ == &_default_name_) { 2806 name_ = new ::std::string; 2807 } 2808 name_->assign(value); 2809} 2810inline void DescriptorProto::set_name(const char* value, size_t size) { 2811 _set_bit(0); 2812 if (name_ == &_default_name_) { 2813 name_ = new ::std::string; 2814 } 2815 name_->assign(reinterpret_cast<const char*>(value), size); 2816} 2817inline ::std::string* DescriptorProto::mutable_name() { 2818 _set_bit(0); 2819 if (name_ == &_default_name_) { 2820 name_ = new ::std::string; 2821 } 2822 return name_; 2823} 2824 2825// repeated .google.protobuf.FieldDescriptorProto field = 2; 2826inline int DescriptorProto::field_size() const { 2827 return field_.size(); 2828} 2829inline void DescriptorProto::clear_field() { 2830 field_.Clear(); 2831} 2832inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::field(int index) const { 2833 return field_.Get(index); 2834} 2835inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_field(int index) { 2836 return field_.Mutable(index); 2837} 2838inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_field() { 2839 return field_.Add(); 2840} 2841inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 2842DescriptorProto::field() const { 2843 return field_; 2844} 2845inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 2846DescriptorProto::mutable_field() { 2847 return &field_; 2848} 2849 2850// repeated .google.protobuf.FieldDescriptorProto extension = 6; 2851inline int DescriptorProto::extension_size() const { 2852 return extension_.size(); 2853} 2854inline void DescriptorProto::clear_extension() { 2855 extension_.Clear(); 2856} 2857inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::extension(int index) const { 2858 return extension_.Get(index); 2859} 2860inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) { 2861 return extension_.Mutable(index); 2862} 2863inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_extension() { 2864 return extension_.Add(); 2865} 2866inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 2867DescriptorProto::extension() const { 2868 return extension_; 2869} 2870inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 2871DescriptorProto::mutable_extension() { 2872 return &extension_; 2873} 2874 2875// repeated .google.protobuf.DescriptorProto nested_type = 3; 2876inline int DescriptorProto::nested_type_size() const { 2877 return nested_type_.size(); 2878} 2879inline void DescriptorProto::clear_nested_type() { 2880 nested_type_.Clear(); 2881} 2882inline const ::google::protobuf::DescriptorProto& DescriptorProto::nested_type(int index) const { 2883 return nested_type_.Get(index); 2884} 2885inline ::google::protobuf::DescriptorProto* DescriptorProto::mutable_nested_type(int index) { 2886 return nested_type_.Mutable(index); 2887} 2888inline ::google::protobuf::DescriptorProto* DescriptorProto::add_nested_type() { 2889 return nested_type_.Add(); 2890} 2891inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 2892DescriptorProto::nested_type() const { 2893 return nested_type_; 2894} 2895inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 2896DescriptorProto::mutable_nested_type() { 2897 return &nested_type_; 2898} 2899 2900// repeated .google.protobuf.EnumDescriptorProto enum_type = 4; 2901inline int DescriptorProto::enum_type_size() const { 2902 return enum_type_.size(); 2903} 2904inline void DescriptorProto::clear_enum_type() { 2905 enum_type_.Clear(); 2906} 2907inline const ::google::protobuf::EnumDescriptorProto& DescriptorProto::enum_type(int index) const { 2908 return enum_type_.Get(index); 2909} 2910inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) { 2911 return enum_type_.Mutable(index); 2912} 2913inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::add_enum_type() { 2914 return enum_type_.Add(); 2915} 2916inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 2917DescriptorProto::enum_type() const { 2918 return enum_type_; 2919} 2920inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 2921DescriptorProto::mutable_enum_type() { 2922 return &enum_type_; 2923} 2924 2925// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; 2926inline int DescriptorProto::extension_range_size() const { 2927 return extension_range_.size(); 2928} 2929inline void DescriptorProto::clear_extension_range() { 2930 extension_range_.Clear(); 2931} 2932inline const ::google::protobuf::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const { 2933 return extension_range_.Get(index); 2934} 2935inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) { 2936 return extension_range_.Mutable(index); 2937} 2938inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() { 2939 return extension_range_.Add(); 2940} 2941inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >& 2942DescriptorProto::extension_range() const { 2943 return extension_range_; 2944} 2945inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >* 2946DescriptorProto::mutable_extension_range() { 2947 return &extension_range_; 2948} 2949 2950// optional .google.protobuf.MessageOptions options = 7; 2951inline bool DescriptorProto::has_options() const { 2952 return _has_bit(6); 2953} 2954inline void DescriptorProto::clear_options() { 2955 if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear(); 2956 _clear_bit(6); 2957} 2958inline const ::google::protobuf::MessageOptions& DescriptorProto::options() const { 2959 return options_ != NULL ? *options_ : *default_instance_->options_; 2960} 2961inline ::google::protobuf::MessageOptions* DescriptorProto::mutable_options() { 2962 _set_bit(6); 2963 if (options_ == NULL) options_ = new ::google::protobuf::MessageOptions; 2964 return options_; 2965} 2966 2967// ------------------------------------------------------------------- 2968 2969// FieldDescriptorProto 2970 2971// optional string name = 1; 2972inline bool FieldDescriptorProto::has_name() const { 2973 return _has_bit(0); 2974} 2975inline void FieldDescriptorProto::clear_name() { 2976 if (name_ != &_default_name_) { 2977 name_->clear(); 2978 } 2979 _clear_bit(0); 2980} 2981inline const ::std::string& FieldDescriptorProto::name() const { 2982 return *name_; 2983} 2984inline void FieldDescriptorProto::set_name(const ::std::string& value) { 2985 _set_bit(0); 2986 if (name_ == &_default_name_) { 2987 name_ = new ::std::string; 2988 } 2989 name_->assign(value); 2990} 2991inline void FieldDescriptorProto::set_name(const char* value) { 2992 _set_bit(0); 2993 if (name_ == &_default_name_) { 2994 name_ = new ::std::string; 2995 } 2996 name_->assign(value); 2997} 2998inline void FieldDescriptorProto::set_name(const char* value, size_t size) { 2999 _set_bit(0); 3000 if (name_ == &_default_name_) { 3001 name_ = new ::std::string; 3002 } 3003 name_->assign(reinterpret_cast<const char*>(value), size); 3004} 3005inline ::std::string* FieldDescriptorProto::mutable_name() { 3006 _set_bit(0); 3007 if (name_ == &_default_name_) { 3008 name_ = new ::std::string; 3009 } 3010 return name_; 3011} 3012 3013// optional int32 number = 3; 3014inline bool FieldDescriptorProto::has_number() const { 3015 return _has_bit(1); 3016} 3017inline void FieldDescriptorProto::clear_number() { 3018 number_ = 0; 3019 _clear_bit(1); 3020} 3021inline ::google::protobuf::int32 FieldDescriptorProto::number() const { 3022 return number_; 3023} 3024inline void FieldDescriptorProto::set_number(::google::protobuf::int32 value) { 3025 _set_bit(1); 3026 number_ = value; 3027} 3028 3029// optional .google.protobuf.FieldDescriptorProto.Label label = 4; 3030inline bool FieldDescriptorProto::has_label() const { 3031 return _has_bit(2); 3032} 3033inline void FieldDescriptorProto::clear_label() { 3034 label_ = 1; 3035 _clear_bit(2); 3036} 3037inline ::google::protobuf::FieldDescriptorProto_Label FieldDescriptorProto::label() const { 3038 return static_cast< ::google::protobuf::FieldDescriptorProto_Label >(label_); 3039} 3040inline void FieldDescriptorProto::set_label(::google::protobuf::FieldDescriptorProto_Label value) { 3041 GOOGLE_DCHECK(::google::protobuf::FieldDescriptorProto_Label_IsValid(value)); 3042 _set_bit(2); 3043 label_ = value; 3044} 3045 3046// optional .google.protobuf.FieldDescriptorProto.Type type = 5; 3047inline bool FieldDescriptorProto::has_type() const { 3048 return _has_bit(3); 3049} 3050inline void FieldDescriptorProto::clear_type() { 3051 type_ = 1; 3052 _clear_bit(3); 3053} 3054inline ::google::protobuf::FieldDescriptorProto_Type FieldDescriptorProto::type() const { 3055 return static_cast< ::google::protobuf::FieldDescriptorProto_Type >(type_); 3056} 3057inline void FieldDescriptorProto::set_type(::google::protobuf::FieldDescriptorProto_Type value) { 3058 GOOGLE_DCHECK(::google::protobuf::FieldDescriptorProto_Type_IsValid(value)); 3059 _set_bit(3); 3060 type_ = value; 3061} 3062 3063// optional string type_name = 6; 3064inline bool FieldDescriptorProto::has_type_name() const { 3065 return _has_bit(4); 3066} 3067inline void FieldDescriptorProto::clear_type_name() { 3068 if (type_name_ != &_default_type_name_) { 3069 type_name_->clear(); 3070 } 3071 _clear_bit(4); 3072} 3073inline const ::std::string& FieldDescriptorProto::type_name() const { 3074 return *type_name_; 3075} 3076inline void FieldDescriptorProto::set_type_name(const ::std::string& value) { 3077 _set_bit(4); 3078 if (type_name_ == &_default_type_name_) { 3079 type_name_ = new ::std::string; 3080 } 3081 type_name_->assign(value); 3082} 3083inline void FieldDescriptorProto::set_type_name(const char* value) { 3084 _set_bit(4); 3085 if (type_name_ == &_default_type_name_) { 3086 type_name_ = new ::std::string; 3087 } 3088 type_name_->assign(value); 3089} 3090inline void FieldDescriptorProto::set_type_name(const char* value, size_t size) { 3091 _set_bit(4); 3092 if (type_name_ == &_default_type_name_) { 3093 type_name_ = new ::std::string; 3094 } 3095 type_name_->assign(reinterpret_cast<const char*>(value), size); 3096} 3097inline ::std::string* FieldDescriptorProto::mutable_type_name() { 3098 _set_bit(4); 3099 if (type_name_ == &_default_type_name_) { 3100 type_name_ = new ::std::string; 3101 } 3102 return type_name_; 3103} 3104 3105// optional string extendee = 2; 3106inline bool FieldDescriptorProto::has_extendee() const { 3107 return _has_bit(5); 3108} 3109inline void FieldDescriptorProto::clear_extendee() { 3110 if (extendee_ != &_default_extendee_) { 3111 extendee_->clear(); 3112 } 3113 _clear_bit(5); 3114} 3115inline const ::std::string& FieldDescriptorProto::extendee() const { 3116 return *extendee_; 3117} 3118inline void FieldDescriptorProto::set_extendee(const ::std::string& value) { 3119 _set_bit(5); 3120 if (extendee_ == &_default_extendee_) { 3121 extendee_ = new ::std::string; 3122 } 3123 extendee_->assign(value); 3124} 3125inline void FieldDescriptorProto::set_extendee(const char* value) { 3126 _set_bit(5); 3127 if (extendee_ == &_default_extendee_) { 3128 extendee_ = new ::std::string; 3129 } 3130 extendee_->assign(value); 3131} 3132inline void FieldDescriptorProto::set_extendee(const char* value, size_t size) { 3133 _set_bit(5); 3134 if (extendee_ == &_default_extendee_) { 3135 extendee_ = new ::std::string; 3136 } 3137 extendee_->assign(reinterpret_cast<const char*>(value), size); 3138} 3139inline ::std::string* FieldDescriptorProto::mutable_extendee() { 3140 _set_bit(5); 3141 if (extendee_ == &_default_extendee_) { 3142 extendee_ = new ::std::string; 3143 } 3144 return extendee_; 3145} 3146 3147// optional string default_value = 7; 3148inline bool FieldDescriptorProto::has_default_value() const { 3149 return _has_bit(6); 3150} 3151inline void FieldDescriptorProto::clear_default_value() { 3152 if (default_value_ != &_default_default_value_) { 3153 default_value_->clear(); 3154 } 3155 _clear_bit(6); 3156} 3157inline const ::std::string& FieldDescriptorProto::default_value() const { 3158 return *default_value_; 3159} 3160inline void FieldDescriptorProto::set_default_value(const ::std::string& value) { 3161 _set_bit(6); 3162 if (default_value_ == &_default_default_value_) { 3163 default_value_ = new ::std::string; 3164 } 3165 default_value_->assign(value); 3166} 3167inline void FieldDescriptorProto::set_default_value(const char* value) { 3168 _set_bit(6); 3169 if (default_value_ == &_default_default_value_) { 3170 default_value_ = new ::std::string; 3171 } 3172 default_value_->assign(value); 3173} 3174inline void FieldDescriptorProto::set_default_value(const char* value, size_t size) { 3175 _set_bit(6); 3176 if (default_value_ == &_default_default_value_) { 3177 default_value_ = new ::std::string; 3178 } 3179 default_value_->assign(reinterpret_cast<const char*>(value), size); 3180} 3181inline ::std::string* FieldDescriptorProto::mutable_default_value() { 3182 _set_bit(6); 3183 if (default_value_ == &_default_default_value_) { 3184 default_value_ = new ::std::string; 3185 } 3186 return default_value_; 3187} 3188 3189// optional .google.protobuf.FieldOptions options = 8; 3190inline bool FieldDescriptorProto::has_options() const { 3191 return _has_bit(7); 3192} 3193inline void FieldDescriptorProto::clear_options() { 3194 if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear(); 3195 _clear_bit(7); 3196} 3197inline const ::google::protobuf::FieldOptions& FieldDescriptorProto::options() const { 3198 return options_ != NULL ? *options_ : *default_instance_->options_; 3199} 3200inline ::google::protobuf::FieldOptions* FieldDescriptorProto::mutable_options() { 3201 _set_bit(7); 3202 if (options_ == NULL) options_ = new ::google::protobuf::FieldOptions; 3203 return options_; 3204} 3205 3206// ------------------------------------------------------------------- 3207 3208// EnumDescriptorProto 3209 3210// optional string name = 1; 3211inline bool EnumDescriptorProto::has_name() const { 3212 return _has_bit(0); 3213} 3214inline void EnumDescriptorProto::clear_name() { 3215 if (name_ != &_default_name_) { 3216 name_->clear(); 3217 } 3218 _clear_bit(0); 3219} 3220inline const ::std::string& EnumDescriptorProto::name() const { 3221 return *name_; 3222} 3223inline void EnumDescriptorProto::set_name(const ::std::string& value) { 3224 _set_bit(0); 3225 if (name_ == &_default_name_) { 3226 name_ = new ::std::string; 3227 } 3228 name_->assign(value); 3229} 3230inline void EnumDescriptorProto::set_name(const char* value) { 3231 _set_bit(0); 3232 if (name_ == &_default_name_) { 3233 name_ = new ::std::string; 3234 } 3235 name_->assign(value); 3236} 3237inline void EnumDescriptorProto::set_name(const char* value, size_t size) { 3238 _set_bit(0); 3239 if (name_ == &_default_name_) { 3240 name_ = new ::std::string; 3241 } 3242 name_->assign(reinterpret_cast<const char*>(value), size); 3243} 3244inline ::std::string* EnumDescriptorProto::mutable_name() { 3245 _set_bit(0); 3246 if (name_ == &_default_name_) { 3247 name_ = new ::std::string; 3248 } 3249 return name_; 3250} 3251 3252// repeated .google.protobuf.EnumValueDescriptorProto value = 2; 3253inline int EnumDescriptorProto::value_size() const { 3254 return value_.size(); 3255} 3256inline void EnumDescriptorProto::clear_value() { 3257 value_.Clear(); 3258} 3259inline const ::google::protobuf::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const { 3260 return value_.Get(index); 3261} 3262inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) { 3263 return value_.Mutable(index); 3264} 3265inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::add_value() { 3266 return value_.Add(); 3267} 3268inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >& 3269EnumDescriptorProto::value() const { 3270 return value_; 3271} 3272inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >* 3273EnumDescriptorProto::mutable_value() { 3274 return &value_; 3275} 3276 3277// optional .google.protobuf.EnumOptions options = 3; 3278inline bool EnumDescriptorProto::has_options() const { 3279 return _has_bit(2); 3280} 3281inline void EnumDescriptorProto::clear_options() { 3282 if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear(); 3283 _clear_bit(2); 3284} 3285inline const ::google::protobuf::EnumOptions& EnumDescriptorProto::options() const { 3286 return options_ != NULL ? *options_ : *default_instance_->options_; 3287} 3288inline ::google::protobuf::EnumOptions* EnumDescriptorProto::mutable_options() { 3289 _set_bit(2); 3290 if (options_ == NULL) options_ = new ::google::protobuf::EnumOptions; 3291 return options_; 3292} 3293 3294// ------------------------------------------------------------------- 3295 3296// EnumValueDescriptorProto 3297 3298// optional string name = 1; 3299inline bool EnumValueDescriptorProto::has_name() const { 3300 return _has_bit(0); 3301} 3302inline void EnumValueDescriptorProto::clear_name() { 3303 if (name_ != &_default_name_) { 3304 name_->clear(); 3305 } 3306 _clear_bit(0); 3307} 3308inline const ::std::string& EnumValueDescriptorProto::name() const { 3309 return *name_; 3310} 3311inline void EnumValueDescriptorProto::set_name(const ::std::string& value) { 3312 _set_bit(0); 3313 if (name_ == &_default_name_) { 3314 name_ = new ::std::string; 3315 } 3316 name_->assign(value); 3317} 3318inline void EnumValueDescriptorProto::set_name(const char* value) { 3319 _set_bit(0); 3320 if (name_ == &_default_name_) { 3321 name_ = new ::std::string; 3322 } 3323 name_->assign(value); 3324} 3325inline void EnumValueDescriptorProto::set_name(const char* value, size_t size) { 3326 _set_bit(0); 3327 if (name_ == &_default_name_) { 3328 name_ = new ::std::string; 3329 } 3330 name_->assign(reinterpret_cast<const char*>(value), size); 3331} 3332inline ::std::string* EnumValueDescriptorProto::mutable_name() { 3333 _set_bit(0); 3334 if (name_ == &_default_name_) { 3335 name_ = new ::std::string; 3336 } 3337 return name_; 3338} 3339 3340// optional int32 number = 2; 3341inline bool EnumValueDescriptorProto::has_number() const { 3342 return _has_bit(1); 3343} 3344inline void EnumValueDescriptorProto::clear_number() { 3345 number_ = 0; 3346 _clear_bit(1); 3347} 3348inline ::google::protobuf::int32 EnumValueDescriptorProto::number() const { 3349 return number_; 3350} 3351inline void EnumValueDescriptorProto::set_number(::google::protobuf::int32 value) { 3352 _set_bit(1); 3353 number_ = value; 3354} 3355 3356// optional .google.protobuf.EnumValueOptions options = 3; 3357inline bool EnumValueDescriptorProto::has_options() const { 3358 return _has_bit(2); 3359} 3360inline void EnumValueDescriptorProto::clear_options() { 3361 if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear(); 3362 _clear_bit(2); 3363} 3364inline const ::google::protobuf::EnumValueOptions& EnumValueDescriptorProto::options() const { 3365 return options_ != NULL ? *options_ : *default_instance_->options_; 3366} 3367inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::mutable_options() { 3368 _set_bit(2); 3369 if (options_ == NULL) options_ = new ::google::protobuf::EnumValueOptions; 3370 return options_; 3371} 3372 3373// ------------------------------------------------------------------- 3374 3375// ServiceDescriptorProto 3376 3377// optional string name = 1; 3378inline bool ServiceDescriptorProto::has_name() const { 3379 return _has_bit(0); 3380} 3381inline void ServiceDescriptorProto::clear_name() { 3382 if (name_ != &_default_name_) { 3383 name_->clear(); 3384 } 3385 _clear_bit(0); 3386} 3387inline const ::std::string& ServiceDescriptorProto::name() const { 3388 return *name_; 3389} 3390inline void ServiceDescriptorProto::set_name(const ::std::string& value) { 3391 _set_bit(0); 3392 if (name_ == &_default_name_) { 3393 name_ = new ::std::string; 3394 } 3395 name_->assign(value); 3396} 3397inline void ServiceDescriptorProto::set_name(const char* value) { 3398 _set_bit(0); 3399 if (name_ == &_default_name_) { 3400 name_ = new ::std::string; 3401 } 3402 name_->assign(value); 3403} 3404inline void ServiceDescriptorProto::set_name(const char* value, size_t size) { 3405 _set_bit(0); 3406 if (name_ == &_default_name_) { 3407 name_ = new ::std::string; 3408 } 3409 name_->assign(reinterpret_cast<const char*>(value), size); 3410} 3411inline ::std::string* ServiceDescriptorProto::mutable_name() { 3412 _set_bit(0); 3413 if (name_ == &_default_name_) { 3414 name_ = new ::std::string; 3415 } 3416 return name_; 3417} 3418 3419// repeated .google.protobuf.MethodDescriptorProto method = 2; 3420inline int ServiceDescriptorProto::method_size() const { 3421 return method_.size(); 3422} 3423inline void ServiceDescriptorProto::clear_method() { 3424 method_.Clear(); 3425} 3426inline const ::google::protobuf::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const { 3427 return method_.Get(index); 3428} 3429inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) { 3430 return method_.Mutable(index); 3431} 3432inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::add_method() { 3433 return method_.Add(); 3434} 3435inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >& 3436ServiceDescriptorProto::method() const { 3437 return method_; 3438} 3439inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >* 3440ServiceDescriptorProto::mutable_method() { 3441 return &method_; 3442} 3443 3444// optional .google.protobuf.ServiceOptions options = 3; 3445inline bool ServiceDescriptorProto::has_options() const { 3446 return _has_bit(2); 3447} 3448inline void ServiceDescriptorProto::clear_options() { 3449 if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear(); 3450 _clear_bit(2); 3451} 3452inline const ::google::protobuf::ServiceOptions& ServiceDescriptorProto::options() const { 3453 return options_ != NULL ? *options_ : *default_instance_->options_; 3454} 3455inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::mutable_options() { 3456 _set_bit(2); 3457 if (options_ == NULL) options_ = new ::google::protobuf::ServiceOptions; 3458 return options_; 3459} 3460 3461// ------------------------------------------------------------------- 3462 3463// MethodDescriptorProto 3464 3465// optional string name = 1; 3466inline bool MethodDescriptorProto::has_name() const { 3467 return _has_bit(0); 3468} 3469inline void MethodDescriptorProto::clear_name() { 3470 if (name_ != &_default_name_) { 3471 name_->clear(); 3472 } 3473 _clear_bit(0); 3474} 3475inline const ::std::string& MethodDescriptorProto::name() const { 3476 return *name_; 3477} 3478inline void MethodDescriptorProto::set_name(const ::std::string& value) { 3479 _set_bit(0); 3480 if (name_ == &_default_name_) { 3481 name_ = new ::std::string; 3482 } 3483 name_->assign(value); 3484} 3485inline void MethodDescriptorProto::set_name(const char* value) { 3486 _set_bit(0); 3487 if (name_ == &_default_name_) { 3488 name_ = new ::std::string; 3489 } 3490 name_->assign(value); 3491} 3492inline void MethodDescriptorProto::set_name(const char* value, size_t size) { 3493 _set_bit(0); 3494 if (name_ == &_default_name_) { 3495 name_ = new ::std::string; 3496 } 3497 name_->assign(reinterpret_cast<const char*>(value), size); 3498} 3499inline ::std::string* MethodDescriptorProto::mutable_name() { 3500 _set_bit(0); 3501 if (name_ == &_default_name_) { 3502 name_ = new ::std::string; 3503 } 3504 return name_; 3505} 3506 3507// optional string input_type = 2; 3508inline bool MethodDescriptorProto::has_input_type() const { 3509 return _has_bit(1); 3510} 3511inline void MethodDescriptorProto::clear_input_type() { 3512 if (input_type_ != &_default_input_type_) { 3513 input_type_->clear(); 3514 } 3515 _clear_bit(1); 3516} 3517inline const ::std::string& MethodDescriptorProto::input_type() const { 3518 return *input_type_; 3519} 3520inline void MethodDescriptorProto::set_input_type(const ::std::string& value) { 3521 _set_bit(1); 3522 if (input_type_ == &_default_input_type_) { 3523 input_type_ = new ::std::string; 3524 } 3525 input_type_->assign(value); 3526} 3527inline void MethodDescriptorProto::set_input_type(const char* value) { 3528 _set_bit(1); 3529 if (input_type_ == &_default_input_type_) { 3530 input_type_ = new ::std::string; 3531 } 3532 input_type_->assign(value); 3533} 3534inline void MethodDescriptorProto::set_input_type(const char* value, size_t size) { 3535 _set_bit(1); 3536 if (input_type_ == &_default_input_type_) { 3537 input_type_ = new ::std::string; 3538 } 3539 input_type_->assign(reinterpret_cast<const char*>(value), size); 3540} 3541inline ::std::string* MethodDescriptorProto::mutable_input_type() { 3542 _set_bit(1); 3543 if (input_type_ == &_default_input_type_) { 3544 input_type_ = new ::std::string; 3545 } 3546 return input_type_; 3547} 3548 3549// optional string output_type = 3; 3550inline bool MethodDescriptorProto::has_output_type() const { 3551 return _has_bit(2); 3552} 3553inline void MethodDescriptorProto::clear_output_type() { 3554 if (output_type_ != &_default_output_type_) { 3555 output_type_->clear(); 3556 } 3557 _clear_bit(2); 3558} 3559inline const ::std::string& MethodDescriptorProto::output_type() const { 3560 return *output_type_; 3561} 3562inline void MethodDescriptorProto::set_output_type(const ::std::string& value) { 3563 _set_bit(2); 3564 if (output_type_ == &_default_output_type_) { 3565 output_type_ = new ::std::string; 3566 } 3567 output_type_->assign(value); 3568} 3569inline void MethodDescriptorProto::set_output_type(const char* value) { 3570 _set_bit(2); 3571 if (output_type_ == &_default_output_type_) { 3572 output_type_ = new ::std::string; 3573 } 3574 output_type_->assign(value); 3575} 3576inline void MethodDescriptorProto::set_output_type(const char* value, size_t size) { 3577 _set_bit(2); 3578 if (output_type_ == &_default_output_type_) { 3579 output_type_ = new ::std::string; 3580 } 3581 output_type_->assign(reinterpret_cast<const char*>(value), size); 3582} 3583inline ::std::string* MethodDescriptorProto::mutable_output_type() { 3584 _set_bit(2); 3585 if (output_type_ == &_default_output_type_) { 3586 output_type_ = new ::std::string; 3587 } 3588 return output_type_; 3589} 3590 3591// optional .google.protobuf.MethodOptions options = 4; 3592inline bool MethodDescriptorProto::has_options() const { 3593 return _has_bit(3); 3594} 3595inline void MethodDescriptorProto::clear_options() { 3596 if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear(); 3597 _clear_bit(3); 3598} 3599inline const ::google::protobuf::MethodOptions& MethodDescriptorProto::options() const { 3600 return options_ != NULL ? *options_ : *default_instance_->options_; 3601} 3602inline ::google::protobuf::MethodOptions* MethodDescriptorProto::mutable_options() { 3603 _set_bit(3); 3604 if (options_ == NULL) options_ = new ::google::protobuf::MethodOptions; 3605 return options_; 3606} 3607 3608// ------------------------------------------------------------------- 3609 3610// FileOptions 3611 3612// optional string java_package = 1; 3613inline bool FileOptions::has_java_package() const { 3614 return _has_bit(0); 3615} 3616inline void FileOptions::clear_java_package() { 3617 if (java_package_ != &_default_java_package_) { 3618 java_package_->clear(); 3619 } 3620 _clear_bit(0); 3621} 3622inline const ::std::string& FileOptions::java_package() const { 3623 return *java_package_; 3624} 3625inline void FileOptions::set_java_package(const ::std::string& value) { 3626 _set_bit(0); 3627 if (java_package_ == &_default_java_package_) { 3628 java_package_ = new ::std::string; 3629 } 3630 java_package_->assign(value); 3631} 3632inline void FileOptions::set_java_package(const char* value) { 3633 _set_bit(0); 3634 if (java_package_ == &_default_java_package_) { 3635 java_package_ = new ::std::string; 3636 } 3637 java_package_->assign(value); 3638} 3639inline void FileOptions::set_java_package(const char* value, size_t size) { 3640 _set_bit(0); 3641 if (java_package_ == &_default_java_package_) { 3642 java_package_ = new ::std::string; 3643 } 3644 java_package_->assign(reinterpret_cast<const char*>(value), size); 3645} 3646inline ::std::string* FileOptions::mutable_java_package() { 3647 _set_bit(0); 3648 if (java_package_ == &_default_java_package_) { 3649 java_package_ = new ::std::string; 3650 } 3651 return java_package_; 3652} 3653 3654// optional string java_outer_classname = 8; 3655inline bool FileOptions::has_java_outer_classname() const { 3656 return _has_bit(1); 3657} 3658inline void FileOptions::clear_java_outer_classname() { 3659 if (java_outer_classname_ != &_default_java_outer_classname_) { 3660 java_outer_classname_->clear(); 3661 } 3662 _clear_bit(1); 3663} 3664inline const ::std::string& FileOptions::java_outer_classname() const { 3665 return *java_outer_classname_; 3666} 3667inline void FileOptions::set_java_outer_classname(const ::std::string& value) { 3668 _set_bit(1); 3669 if (java_outer_classname_ == &_default_java_outer_classname_) { 3670 java_outer_classname_ = new ::std::string; 3671 } 3672 java_outer_classname_->assign(value); 3673} 3674inline void FileOptions::set_java_outer_classname(const char* value) { 3675 _set_bit(1); 3676 if (java_outer_classname_ == &_default_java_outer_classname_) { 3677 java_outer_classname_ = new ::std::string; 3678 } 3679 java_outer_classname_->assign(value); 3680} 3681inline void FileOptions::set_java_outer_classname(const char* value, size_t size) { 3682 _set_bit(1); 3683 if (java_outer_classname_ == &_default_java_outer_classname_) { 3684 java_outer_classname_ = new ::std::string; 3685 } 3686 java_outer_classname_->assign(reinterpret_cast<const char*>(value), size); 3687} 3688inline ::std::string* FileOptions::mutable_java_outer_classname() { 3689 _set_bit(1); 3690 if (java_outer_classname_ == &_default_java_outer_classname_) { 3691 java_outer_classname_ = new ::std::string; 3692 } 3693 return java_outer_classname_; 3694} 3695 3696// optional bool java_multiple_files = 10 [default = false]; 3697inline bool FileOptions::has_java_multiple_files() const { 3698 return _has_bit(2); 3699} 3700inline void FileOptions::clear_java_multiple_files() { 3701 java_multiple_files_ = false; 3702 _clear_bit(2); 3703} 3704inline bool FileOptions::java_multiple_files() const { 3705 return java_multiple_files_; 3706} 3707inline void FileOptions::set_java_multiple_files(bool value) { 3708 _set_bit(2); 3709 java_multiple_files_ = value; 3710} 3711 3712// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; 3713inline bool FileOptions::has_optimize_for() const { 3714 return _has_bit(3); 3715} 3716inline void FileOptions::clear_optimize_for() { 3717 optimize_for_ = 1; 3718 _clear_bit(3); 3719} 3720inline ::google::protobuf::FileOptions_OptimizeMode FileOptions::optimize_for() const { 3721 return static_cast< ::google::protobuf::FileOptions_OptimizeMode >(optimize_for_); 3722} 3723inline void FileOptions::set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value) { 3724 GOOGLE_DCHECK(::google::protobuf::FileOptions_OptimizeMode_IsValid(value)); 3725 _set_bit(3); 3726 optimize_for_ = value; 3727} 3728 3729// optional bool cc_generic_services = 16 [default = true]; 3730inline bool FileOptions::has_cc_generic_services() const { 3731 return _has_bit(4); 3732} 3733inline void FileOptions::clear_cc_generic_services() { 3734 cc_generic_services_ = true; 3735 _clear_bit(4); 3736} 3737inline bool FileOptions::cc_generic_services() const { 3738 return cc_generic_services_; 3739} 3740inline void FileOptions::set_cc_generic_services(bool value) { 3741 _set_bit(4); 3742 cc_generic_services_ = value; 3743} 3744 3745// optional bool java_generic_services = 17 [default = true]; 3746inline bool FileOptions::has_java_generic_services() const { 3747 return _has_bit(5); 3748} 3749inline void FileOptions::clear_java_generic_services() { 3750 java_generic_services_ = true; 3751 _clear_bit(5); 3752} 3753inline bool FileOptions::java_generic_services() const { 3754 return java_generic_services_; 3755} 3756inline void FileOptions::set_java_generic_services(bool value) { 3757 _set_bit(5); 3758 java_generic_services_ = value; 3759} 3760 3761// optional bool py_generic_services = 18 [default = true]; 3762inline bool FileOptions::has_py_generic_services() const { 3763 return _has_bit(6); 3764} 3765inline void FileOptions::clear_py_generic_services() { 3766 py_generic_services_ = true; 3767 _clear_bit(6); 3768} 3769inline bool FileOptions::py_generic_services() const { 3770 return py_generic_services_; 3771} 3772inline void FileOptions::set_py_generic_services(bool value) { 3773 _set_bit(6); 3774 py_generic_services_ = value; 3775} 3776 3777// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 3778inline int FileOptions::uninterpreted_option_size() const { 3779 return uninterpreted_option_.size(); 3780} 3781inline void FileOptions::clear_uninterpreted_option() { 3782 uninterpreted_option_.Clear(); 3783} 3784inline const ::google::protobuf::UninterpretedOption& FileOptions::uninterpreted_option(int index) const { 3785 return uninterpreted_option_.Get(index); 3786} 3787inline ::google::protobuf::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) { 3788 return uninterpreted_option_.Mutable(index); 3789} 3790inline ::google::protobuf::UninterpretedOption* FileOptions::add_uninterpreted_option() { 3791 return uninterpreted_option_.Add(); 3792} 3793inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 3794FileOptions::uninterpreted_option() const { 3795 return uninterpreted_option_; 3796} 3797inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 3798FileOptions::mutable_uninterpreted_option() { 3799 return &uninterpreted_option_; 3800} 3801 3802// ------------------------------------------------------------------- 3803 3804// MessageOptions 3805 3806// optional bool message_set_wire_format = 1 [default = false]; 3807inline bool MessageOptions::has_message_set_wire_format() const { 3808 return _has_bit(0); 3809} 3810inline void MessageOptions::clear_message_set_wire_format() { 3811 message_set_wire_format_ = false; 3812 _clear_bit(0); 3813} 3814inline bool MessageOptions::message_set_wire_format() const { 3815 return message_set_wire_format_; 3816} 3817inline void MessageOptions::set_message_set_wire_format(bool value) { 3818 _set_bit(0); 3819 message_set_wire_format_ = value; 3820} 3821 3822// optional bool no_standard_descriptor_accessor = 2 [default = false]; 3823inline bool MessageOptions::has_no_standard_descriptor_accessor() const { 3824 return _has_bit(1); 3825} 3826inline void MessageOptions::clear_no_standard_descriptor_accessor() { 3827 no_standard_descriptor_accessor_ = false; 3828 _clear_bit(1); 3829} 3830inline bool MessageOptions::no_standard_descriptor_accessor() const { 3831 return no_standard_descriptor_accessor_; 3832} 3833inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) { 3834 _set_bit(1); 3835 no_standard_descriptor_accessor_ = value; 3836} 3837 3838// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 3839inline int MessageOptions::uninterpreted_option_size() const { 3840 return uninterpreted_option_.size(); 3841} 3842inline void MessageOptions::clear_uninterpreted_option() { 3843 uninterpreted_option_.Clear(); 3844} 3845inline const ::google::protobuf::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const { 3846 return uninterpreted_option_.Get(index); 3847} 3848inline ::google::protobuf::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) { 3849 return uninterpreted_option_.Mutable(index); 3850} 3851inline ::google::protobuf::UninterpretedOption* MessageOptions::add_uninterpreted_option() { 3852 return uninterpreted_option_.Add(); 3853} 3854inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 3855MessageOptions::uninterpreted_option() const { 3856 return uninterpreted_option_; 3857} 3858inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 3859MessageOptions::mutable_uninterpreted_option() { 3860 return &uninterpreted_option_; 3861} 3862 3863// ------------------------------------------------------------------- 3864 3865// FieldOptions 3866 3867// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 3868inline bool FieldOptions::has_ctype() const { 3869 return _has_bit(0); 3870} 3871inline void FieldOptions::clear_ctype() { 3872 ctype_ = 0; 3873 _clear_bit(0); 3874} 3875inline ::google::protobuf::FieldOptions_CType FieldOptions::ctype() const { 3876 return static_cast< ::google::protobuf::FieldOptions_CType >(ctype_); 3877} 3878inline void FieldOptions::set_ctype(::google::protobuf::FieldOptions_CType value) { 3879 GOOGLE_DCHECK(::google::protobuf::FieldOptions_CType_IsValid(value)); 3880 _set_bit(0); 3881 ctype_ = value; 3882} 3883 3884// optional bool packed = 2; 3885inline bool FieldOptions::has_packed() const { 3886 return _has_bit(1); 3887} 3888inline void FieldOptions::clear_packed() { 3889 packed_ = false; 3890 _clear_bit(1); 3891} 3892inline bool FieldOptions::packed() const { 3893 return packed_; 3894} 3895inline void FieldOptions::set_packed(bool value) { 3896 _set_bit(1); 3897 packed_ = value; 3898} 3899 3900// optional bool deprecated = 3 [default = false]; 3901inline bool FieldOptions::has_deprecated() const { 3902 return _has_bit(2); 3903} 3904inline void FieldOptions::clear_deprecated() { 3905 deprecated_ = false; 3906 _clear_bit(2); 3907} 3908inline bool FieldOptions::deprecated() const { 3909 return deprecated_; 3910} 3911inline void FieldOptions::set_deprecated(bool value) { 3912 _set_bit(2); 3913 deprecated_ = value; 3914} 3915 3916// optional string experimental_map_key = 9; 3917inline bool FieldOptions::has_experimental_map_key() const { 3918 return _has_bit(3); 3919} 3920inline void FieldOptions::clear_experimental_map_key() { 3921 if (experimental_map_key_ != &_default_experimental_map_key_) { 3922 experimental_map_key_->clear(); 3923 } 3924 _clear_bit(3); 3925} 3926inline const ::std::string& FieldOptions::experimental_map_key() const { 3927 return *experimental_map_key_; 3928} 3929inline void FieldOptions::set_experimental_map_key(const ::std::string& value) { 3930 _set_bit(3); 3931 if (experimental_map_key_ == &_default_experimental_map_key_) { 3932 experimental_map_key_ = new ::std::string; 3933 } 3934 experimental_map_key_->assign(value); 3935} 3936inline void FieldOptions::set_experimental_map_key(const char* value) { 3937 _set_bit(3); 3938 if (experimental_map_key_ == &_default_experimental_map_key_) { 3939 experimental_map_key_ = new ::std::string; 3940 } 3941 experimental_map_key_->assign(value); 3942} 3943inline void FieldOptions::set_experimental_map_key(const char* value, size_t size) { 3944 _set_bit(3); 3945 if (experimental_map_key_ == &_default_experimental_map_key_) { 3946 experimental_map_key_ = new ::std::string; 3947 } 3948 experimental_map_key_->assign(reinterpret_cast<const char*>(value), size); 3949} 3950inline ::std::string* FieldOptions::mutable_experimental_map_key() { 3951 _set_bit(3); 3952 if (experimental_map_key_ == &_default_experimental_map_key_) { 3953 experimental_map_key_ = new ::std::string; 3954 } 3955 return experimental_map_key_; 3956} 3957 3958// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 3959inline int FieldOptions::uninterpreted_option_size() const { 3960 return uninterpreted_option_.size(); 3961} 3962inline void FieldOptions::clear_uninterpreted_option() { 3963 uninterpreted_option_.Clear(); 3964} 3965inline const ::google::protobuf::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const { 3966 return uninterpreted_option_.Get(index); 3967} 3968inline ::google::protobuf::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) { 3969 return uninterpreted_option_.Mutable(index); 3970} 3971inline ::google::protobuf::UninterpretedOption* FieldOptions::add_uninterpreted_option() { 3972 return uninterpreted_option_.Add(); 3973} 3974inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 3975FieldOptions::uninterpreted_option() const { 3976 return uninterpreted_option_; 3977} 3978inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 3979FieldOptions::mutable_uninterpreted_option() { 3980 return &uninterpreted_option_; 3981} 3982 3983// ------------------------------------------------------------------- 3984 3985// EnumOptions 3986 3987// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 3988inline int EnumOptions::uninterpreted_option_size() const { 3989 return uninterpreted_option_.size(); 3990} 3991inline void EnumOptions::clear_uninterpreted_option() { 3992 uninterpreted_option_.Clear(); 3993} 3994inline const ::google::protobuf::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const { 3995 return uninterpreted_option_.Get(index); 3996} 3997inline ::google::protobuf::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) { 3998 return uninterpreted_option_.Mutable(index); 3999} 4000inline ::google::protobuf::UninterpretedOption* EnumOptions::add_uninterpreted_option() { 4001 return uninterpreted_option_.Add(); 4002} 4003inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4004EnumOptions::uninterpreted_option() const { 4005 return uninterpreted_option_; 4006} 4007inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4008EnumOptions::mutable_uninterpreted_option() { 4009 return &uninterpreted_option_; 4010} 4011 4012// ------------------------------------------------------------------- 4013 4014// EnumValueOptions 4015 4016// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4017inline int EnumValueOptions::uninterpreted_option_size() const { 4018 return uninterpreted_option_.size(); 4019} 4020inline void EnumValueOptions::clear_uninterpreted_option() { 4021 uninterpreted_option_.Clear(); 4022} 4023inline const ::google::protobuf::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const { 4024 return uninterpreted_option_.Get(index); 4025} 4026inline ::google::protobuf::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) { 4027 return uninterpreted_option_.Mutable(index); 4028} 4029inline ::google::protobuf::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() { 4030 return uninterpreted_option_.Add(); 4031} 4032inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4033EnumValueOptions::uninterpreted_option() const { 4034 return uninterpreted_option_; 4035} 4036inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4037EnumValueOptions::mutable_uninterpreted_option() { 4038 return &uninterpreted_option_; 4039} 4040 4041// ------------------------------------------------------------------- 4042 4043// ServiceOptions 4044 4045// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4046inline int ServiceOptions::uninterpreted_option_size() const { 4047 return uninterpreted_option_.size(); 4048} 4049inline void ServiceOptions::clear_uninterpreted_option() { 4050 uninterpreted_option_.Clear(); 4051} 4052inline const ::google::protobuf::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const { 4053 return uninterpreted_option_.Get(index); 4054} 4055inline ::google::protobuf::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) { 4056 return uninterpreted_option_.Mutable(index); 4057} 4058inline ::google::protobuf::UninterpretedOption* ServiceOptions::add_uninterpreted_option() { 4059 return uninterpreted_option_.Add(); 4060} 4061inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4062ServiceOptions::uninterpreted_option() const { 4063 return uninterpreted_option_; 4064} 4065inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4066ServiceOptions::mutable_uninterpreted_option() { 4067 return &uninterpreted_option_; 4068} 4069 4070// ------------------------------------------------------------------- 4071 4072// MethodOptions 4073 4074// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4075inline int MethodOptions::uninterpreted_option_size() const { 4076 return uninterpreted_option_.size(); 4077} 4078inline void MethodOptions::clear_uninterpreted_option() { 4079 uninterpreted_option_.Clear(); 4080} 4081inline const ::google::protobuf::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const { 4082 return uninterpreted_option_.Get(index); 4083} 4084inline ::google::protobuf::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) { 4085 return uninterpreted_option_.Mutable(index); 4086} 4087inline ::google::protobuf::UninterpretedOption* MethodOptions::add_uninterpreted_option() { 4088 return uninterpreted_option_.Add(); 4089} 4090inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4091MethodOptions::uninterpreted_option() const { 4092 return uninterpreted_option_; 4093} 4094inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4095MethodOptions::mutable_uninterpreted_option() { 4096 return &uninterpreted_option_; 4097} 4098 4099// ------------------------------------------------------------------- 4100 4101// UninterpretedOption_NamePart 4102 4103// required string name_part = 1; 4104inline bool UninterpretedOption_NamePart::has_name_part() const { 4105 return _has_bit(0); 4106} 4107inline void UninterpretedOption_NamePart::clear_name_part() { 4108 if (name_part_ != &_default_name_part_) { 4109 name_part_->clear(); 4110 } 4111 _clear_bit(0); 4112} 4113inline const ::std::string& UninterpretedOption_NamePart::name_part() const { 4114 return *name_part_; 4115} 4116inline void UninterpretedOption_NamePart::set_name_part(const ::std::string& value) { 4117 _set_bit(0); 4118 if (name_part_ == &_default_name_part_) { 4119 name_part_ = new ::std::string; 4120 } 4121 name_part_->assign(value); 4122} 4123inline void UninterpretedOption_NamePart::set_name_part(const char* value) { 4124 _set_bit(0); 4125 if (name_part_ == &_default_name_part_) { 4126 name_part_ = new ::std::string; 4127 } 4128 name_part_->assign(value); 4129} 4130inline void UninterpretedOption_NamePart::set_name_part(const char* value, size_t size) { 4131 _set_bit(0); 4132 if (name_part_ == &_default_name_part_) { 4133 name_part_ = new ::std::string; 4134 } 4135 name_part_->assign(reinterpret_cast<const char*>(value), size); 4136} 4137inline ::std::string* UninterpretedOption_NamePart::mutable_name_part() { 4138 _set_bit(0); 4139 if (name_part_ == &_default_name_part_) { 4140 name_part_ = new ::std::string; 4141 } 4142 return name_part_; 4143} 4144 4145// required bool is_extension = 2; 4146inline bool UninterpretedOption_NamePart::has_is_extension() const { 4147 return _has_bit(1); 4148} 4149inline void UninterpretedOption_NamePart::clear_is_extension() { 4150 is_extension_ = false; 4151 _clear_bit(1); 4152} 4153inline bool UninterpretedOption_NamePart::is_extension() const { 4154 return is_extension_; 4155} 4156inline void UninterpretedOption_NamePart::set_is_extension(bool value) { 4157 _set_bit(1); 4158 is_extension_ = value; 4159} 4160 4161// ------------------------------------------------------------------- 4162 4163// UninterpretedOption 4164 4165// repeated .google.protobuf.UninterpretedOption.NamePart name = 2; 4166inline int UninterpretedOption::name_size() const { 4167 return name_.size(); 4168} 4169inline void UninterpretedOption::clear_name() { 4170 name_.Clear(); 4171} 4172inline const ::google::protobuf::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const { 4173 return name_.Get(index); 4174} 4175inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) { 4176 return name_.Mutable(index); 4177} 4178inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::add_name() { 4179 return name_.Add(); 4180} 4181inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 4182UninterpretedOption::name() const { 4183 return name_; 4184} 4185inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 4186UninterpretedOption::mutable_name() { 4187 return &name_; 4188} 4189 4190// optional string identifier_value = 3; 4191inline bool UninterpretedOption::has_identifier_value() const { 4192 return _has_bit(1); 4193} 4194inline void UninterpretedOption::clear_identifier_value() { 4195 if (identifier_value_ != &_default_identifier_value_) { 4196 identifier_value_->clear(); 4197 } 4198 _clear_bit(1); 4199} 4200inline const ::std::string& UninterpretedOption::identifier_value() const { 4201 return *identifier_value_; 4202} 4203inline void UninterpretedOption::set_identifier_value(const ::std::string& value) { 4204 _set_bit(1); 4205 if (identifier_value_ == &_default_identifier_value_) { 4206 identifier_value_ = new ::std::string; 4207 } 4208 identifier_value_->assign(value); 4209} 4210inline void UninterpretedOption::set_identifier_value(const char* value) { 4211 _set_bit(1); 4212 if (identifier_value_ == &_default_identifier_value_) { 4213 identifier_value_ = new ::std::string; 4214 } 4215 identifier_value_->assign(value); 4216} 4217inline void UninterpretedOption::set_identifier_value(const char* value, size_t size) { 4218 _set_bit(1); 4219 if (identifier_value_ == &_default_identifier_value_) { 4220 identifier_value_ = new ::std::string; 4221 } 4222 identifier_value_->assign(reinterpret_cast<const char*>(value), size); 4223} 4224inline ::std::string* UninterpretedOption::mutable_identifier_value() { 4225 _set_bit(1); 4226 if (identifier_value_ == &_default_identifier_value_) { 4227 identifier_value_ = new ::std::string; 4228 } 4229 return identifier_value_; 4230} 4231 4232// optional uint64 positive_int_value = 4; 4233inline bool UninterpretedOption::has_positive_int_value() const { 4234 return _has_bit(2); 4235} 4236inline void UninterpretedOption::clear_positive_int_value() { 4237 positive_int_value_ = GOOGLE_ULONGLONG(0); 4238 _clear_bit(2); 4239} 4240inline ::google::protobuf::uint64 UninterpretedOption::positive_int_value() const { 4241 return positive_int_value_; 4242} 4243inline void UninterpretedOption::set_positive_int_value(::google::protobuf::uint64 value) { 4244 _set_bit(2); 4245 positive_int_value_ = value; 4246} 4247 4248// optional int64 negative_int_value = 5; 4249inline bool UninterpretedOption::has_negative_int_value() const { 4250 return _has_bit(3); 4251} 4252inline void UninterpretedOption::clear_negative_int_value() { 4253 negative_int_value_ = GOOGLE_LONGLONG(0); 4254 _clear_bit(3); 4255} 4256inline ::google::protobuf::int64 UninterpretedOption::negative_int_value() const { 4257 return negative_int_value_; 4258} 4259inline void UninterpretedOption::set_negative_int_value(::google::protobuf::int64 value) { 4260 _set_bit(3); 4261 negative_int_value_ = value; 4262} 4263 4264// optional double double_value = 6; 4265inline bool UninterpretedOption::has_double_value() const { 4266 return _has_bit(4); 4267} 4268inline void UninterpretedOption::clear_double_value() { 4269 double_value_ = 0; 4270 _clear_bit(4); 4271} 4272inline double UninterpretedOption::double_value() const { 4273 return double_value_; 4274} 4275inline void UninterpretedOption::set_double_value(double value) { 4276 _set_bit(4); 4277 double_value_ = value; 4278} 4279 4280// optional bytes string_value = 7; 4281inline bool UninterpretedOption::has_string_value() const { 4282 return _has_bit(5); 4283} 4284inline void UninterpretedOption::clear_string_value() { 4285 if (string_value_ != &_default_string_value_) { 4286 string_value_->clear(); 4287 } 4288 _clear_bit(5); 4289} 4290inline const ::std::string& UninterpretedOption::string_value() const { 4291 return *string_value_; 4292} 4293inline void UninterpretedOption::set_string_value(const ::std::string& value) { 4294 _set_bit(5); 4295 if (string_value_ == &_default_string_value_) { 4296 string_value_ = new ::std::string; 4297 } 4298 string_value_->assign(value); 4299} 4300inline void UninterpretedOption::set_string_value(const char* value) { 4301 _set_bit(5); 4302 if (string_value_ == &_default_string_value_) { 4303 string_value_ = new ::std::string; 4304 } 4305 string_value_->assign(value); 4306} 4307inline void UninterpretedOption::set_string_value(const void* value, size_t size) { 4308 _set_bit(5); 4309 if (string_value_ == &_default_string_value_) { 4310 string_value_ = new ::std::string; 4311 } 4312 string_value_->assign(reinterpret_cast<const char*>(value), size); 4313} 4314inline ::std::string* UninterpretedOption::mutable_string_value() { 4315 _set_bit(5); 4316 if (string_value_ == &_default_string_value_) { 4317 string_value_ = new ::std::string; 4318 } 4319 return string_value_; 4320} 4321 4322 4323// @@protoc_insertion_point(namespace_scope) 4324 4325} // namespace protobuf 4326} // namespace google 4327 4328#ifndef SWIG 4329namespace google { 4330namespace protobuf { 4331 4332template <> 4333inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type>() { 4334 return ::google::protobuf::FieldDescriptorProto_Type_descriptor(); 4335} 4336template <> 4337inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label>() { 4338 return ::google::protobuf::FieldDescriptorProto_Label_descriptor(); 4339} 4340template <> 4341inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode>() { 4342 return ::google::protobuf::FileOptions_OptimizeMode_descriptor(); 4343} 4344template <> 4345inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldOptions_CType>() { 4346 return ::google::protobuf::FieldOptions_CType_descriptor(); 4347} 4348 4349} // namespace google 4350} // namespace protobuf 4351#endif // SWIG 4352 4353// @@protoc_insertion_point(global_scope) 4354 4355#endif // PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED 4356