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 28 namespace google { 29 namespace protobuf { 30 31 // Internal implementation detail -- do not call these. 32 void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 33 void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 34 void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 35 36 class FileDescriptorSet; 37 class FileDescriptorProto; 38 class DescriptorProto; 39 class DescriptorProto_ExtensionRange; 40 class FieldDescriptorProto; 41 class EnumDescriptorProto; 42 class EnumValueDescriptorProto; 43 class ServiceDescriptorProto; 44 class MethodDescriptorProto; 45 class FileOptions; 46 class MessageOptions; 47 class FieldOptions; 48 class EnumOptions; 49 class EnumValueOptions; 50 class ServiceOptions; 51 class MethodOptions; 52 class UninterpretedOption; 53 class UninterpretedOption_NamePart; 54 55 enum 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 }; 75 LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value); 76 const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE; 77 const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64; 78 const int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1; 79 80 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor(); 81 inline const ::std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) { 82 return ::google::protobuf::internal::NameOfEnum( 83 FieldDescriptorProto_Type_descriptor(), value); 84 } 85 inline 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 } 90 enum FieldDescriptorProto_Label { 91 FieldDescriptorProto_Label_LABEL_OPTIONAL = 1, 92 FieldDescriptorProto_Label_LABEL_REQUIRED = 2, 93 FieldDescriptorProto_Label_LABEL_REPEATED = 3 94 }; 95 LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value); 96 const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL; 97 const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED; 98 const int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1; 99 100 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor(); 101 inline const ::std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) { 102 return ::google::protobuf::internal::NameOfEnum( 103 FieldDescriptorProto_Label_descriptor(), value); 104 } 105 inline 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 } 110 enum FileOptions_OptimizeMode { 111 FileOptions_OptimizeMode_SPEED = 1, 112 FileOptions_OptimizeMode_CODE_SIZE = 2, 113 FileOptions_OptimizeMode_LITE_RUNTIME = 3 114 }; 115 LIBPROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value); 116 const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED; 117 const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME; 118 const int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1; 119 120 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor(); 121 inline const ::std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) { 122 return ::google::protobuf::internal::NameOfEnum( 123 FileOptions_OptimizeMode_descriptor(), value); 124 } 125 inline 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 } 130 enum FieldOptions_CType { 131 FieldOptions_CType_STRING = 0, 132 FieldOptions_CType_CORD = 1, 133 FieldOptions_CType_STRING_PIECE = 2 134 }; 135 LIBPROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value); 136 const FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING; 137 const FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE; 138 const int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1; 139 140 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor(); 141 inline const ::std::string& FieldOptions_CType_Name(FieldOptions_CType value) { 142 return ::google::protobuf::internal::NameOfEnum( 143 FieldOptions_CType_descriptor(), value); 144 } 145 inline 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 152 class 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 246 class 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 428 class 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 525 class 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 693 class 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 919 class 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 1033 class 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 1142 class 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 1256 class 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 1381 class 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 1566 class 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 1678 class 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 1835 class 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 1931 class 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 2027 class 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 2123 class 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 2219 class 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 2320 class 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; 2470 inline int FileDescriptorSet::file_size() const { 2471 return file_.size(); 2472 } 2473 inline void FileDescriptorSet::clear_file() { 2474 file_.Clear(); 2475 } 2476 inline const ::google::protobuf::FileDescriptorProto& FileDescriptorSet::file(int index) const { 2477 return file_.Get(index); 2478 } 2479 inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) { 2480 return file_.Mutable(index); 2481 } 2482 inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::add_file() { 2483 return file_.Add(); 2484 } 2485 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >& 2486 FileDescriptorSet::file() const { 2487 return file_; 2488 } 2489 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >* 2490 FileDescriptorSet::mutable_file() { 2491 return &file_; 2492 } 2493 2494 // ------------------------------------------------------------------- 2495 2496 // FileDescriptorProto 2497 2498 // optional string name = 1; 2499 inline bool FileDescriptorProto::has_name() const { 2500 return _has_bit(0); 2501 } 2502 inline void FileDescriptorProto::clear_name() { 2503 if (name_ != &_default_name_) { 2504 name_->clear(); 2505 } 2506 _clear_bit(0); 2507 } 2508 inline const ::std::string& FileDescriptorProto::name() const { 2509 return *name_; 2510 } 2511 inline 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 } 2518 inline 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 } 2525 inline 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 } 2532 inline ::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; 2541 inline bool FileDescriptorProto::has_package() const { 2542 return _has_bit(1); 2543 } 2544 inline void FileDescriptorProto::clear_package() { 2545 if (package_ != &_default_package_) { 2546 package_->clear(); 2547 } 2548 _clear_bit(1); 2549 } 2550 inline const ::std::string& FileDescriptorProto::package() const { 2551 return *package_; 2552 } 2553 inline 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 } 2560 inline 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 } 2567 inline 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 } 2574 inline ::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; 2583 inline int FileDescriptorProto::dependency_size() const { 2584 return dependency_.size(); 2585 } 2586 inline void FileDescriptorProto::clear_dependency() { 2587 dependency_.Clear(); 2588 } 2589 inline const ::std::string& FileDescriptorProto::dependency(int index) const { 2590 return dependency_.Get(index); 2591 } 2592 inline ::std::string* FileDescriptorProto::mutable_dependency(int index) { 2593 return dependency_.Mutable(index); 2594 } 2595 inline void FileDescriptorProto::set_dependency(int index, const ::std::string& value) { 2596 dependency_.Mutable(index)->assign(value); 2597 } 2598 inline void FileDescriptorProto::set_dependency(int index, const char* value) { 2599 dependency_.Mutable(index)->assign(value); 2600 } 2601 inline 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 } 2605 inline ::std::string* FileDescriptorProto::add_dependency() { 2606 return dependency_.Add(); 2607 } 2608 inline void FileDescriptorProto::add_dependency(const ::std::string& value) { 2609 dependency_.Add()->assign(value); 2610 } 2611 inline void FileDescriptorProto::add_dependency(const char* value) { 2612 dependency_.Add()->assign(value); 2613 } 2614 inline void FileDescriptorProto::add_dependency(const char* value, size_t size) { 2615 dependency_.Add()->assign(reinterpret_cast<const char*>(value), size); 2616 } 2617 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& 2618 FileDescriptorProto::dependency() const { 2619 return dependency_; 2620 } 2621 inline ::google::protobuf::RepeatedPtrField< ::std::string>* 2622 FileDescriptorProto::mutable_dependency() { 2623 return &dependency_; 2624 } 2625 2626 // repeated .google.protobuf.DescriptorProto message_type = 4; 2627 inline int FileDescriptorProto::message_type_size() const { 2628 return message_type_.size(); 2629 } 2630 inline void FileDescriptorProto::clear_message_type() { 2631 message_type_.Clear(); 2632 } 2633 inline const ::google::protobuf::DescriptorProto& FileDescriptorProto::message_type(int index) const { 2634 return message_type_.Get(index); 2635 } 2636 inline ::google::protobuf::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) { 2637 return message_type_.Mutable(index); 2638 } 2639 inline ::google::protobuf::DescriptorProto* FileDescriptorProto::add_message_type() { 2640 return message_type_.Add(); 2641 } 2642 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 2643 FileDescriptorProto::message_type() const { 2644 return message_type_; 2645 } 2646 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 2647 FileDescriptorProto::mutable_message_type() { 2648 return &message_type_; 2649 } 2650 2651 // repeated .google.protobuf.EnumDescriptorProto enum_type = 5; 2652 inline int FileDescriptorProto::enum_type_size() const { 2653 return enum_type_.size(); 2654 } 2655 inline void FileDescriptorProto::clear_enum_type() { 2656 enum_type_.Clear(); 2657 } 2658 inline const ::google::protobuf::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const { 2659 return enum_type_.Get(index); 2660 } 2661 inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) { 2662 return enum_type_.Mutable(index); 2663 } 2664 inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::add_enum_type() { 2665 return enum_type_.Add(); 2666 } 2667 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 2668 FileDescriptorProto::enum_type() const { 2669 return enum_type_; 2670 } 2671 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 2672 FileDescriptorProto::mutable_enum_type() { 2673 return &enum_type_; 2674 } 2675 2676 // repeated .google.protobuf.ServiceDescriptorProto service = 6; 2677 inline int FileDescriptorProto::service_size() const { 2678 return service_.size(); 2679 } 2680 inline void FileDescriptorProto::clear_service() { 2681 service_.Clear(); 2682 } 2683 inline const ::google::protobuf::ServiceDescriptorProto& FileDescriptorProto::service(int index) const { 2684 return service_.Get(index); 2685 } 2686 inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) { 2687 return service_.Mutable(index); 2688 } 2689 inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::add_service() { 2690 return service_.Add(); 2691 } 2692 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >& 2693 FileDescriptorProto::service() const { 2694 return service_; 2695 } 2696 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >* 2697 FileDescriptorProto::mutable_service() { 2698 return &service_; 2699 } 2700 2701 // repeated .google.protobuf.FieldDescriptorProto extension = 7; 2702 inline int FileDescriptorProto::extension_size() const { 2703 return extension_.size(); 2704 } 2705 inline void FileDescriptorProto::clear_extension() { 2706 extension_.Clear(); 2707 } 2708 inline const ::google::protobuf::FieldDescriptorProto& FileDescriptorProto::extension(int index) const { 2709 return extension_.Get(index); 2710 } 2711 inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) { 2712 return extension_.Mutable(index); 2713 } 2714 inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::add_extension() { 2715 return extension_.Add(); 2716 } 2717 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 2718 FileDescriptorProto::extension() const { 2719 return extension_; 2720 } 2721 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 2722 FileDescriptorProto::mutable_extension() { 2723 return &extension_; 2724 } 2725 2726 // optional .google.protobuf.FileOptions options = 8; 2727 inline bool FileDescriptorProto::has_options() const { 2728 return _has_bit(7); 2729 } 2730 inline void FileDescriptorProto::clear_options() { 2731 if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear(); 2732 _clear_bit(7); 2733 } 2734 inline const ::google::protobuf::FileOptions& FileDescriptorProto::options() const { 2735 return options_ != NULL ? *options_ : *default_instance_->options_; 2736 } 2737 inline ::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; 2748 inline bool DescriptorProto_ExtensionRange::has_start() const { 2749 return _has_bit(0); 2750 } 2751 inline void DescriptorProto_ExtensionRange::clear_start() { 2752 start_ = 0; 2753 _clear_bit(0); 2754 } 2755 inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::start() const { 2756 return start_; 2757 } 2758 inline void DescriptorProto_ExtensionRange::set_start(::google::protobuf::int32 value) { 2759 _set_bit(0); 2760 start_ = value; 2761 } 2762 2763 // optional int32 end = 2; 2764 inline bool DescriptorProto_ExtensionRange::has_end() const { 2765 return _has_bit(1); 2766 } 2767 inline void DescriptorProto_ExtensionRange::clear_end() { 2768 end_ = 0; 2769 _clear_bit(1); 2770 } 2771 inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::end() const { 2772 return end_; 2773 } 2774 inline 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; 2784 inline bool DescriptorProto::has_name() const { 2785 return _has_bit(0); 2786 } 2787 inline void DescriptorProto::clear_name() { 2788 if (name_ != &_default_name_) { 2789 name_->clear(); 2790 } 2791 _clear_bit(0); 2792 } 2793 inline const ::std::string& DescriptorProto::name() const { 2794 return *name_; 2795 } 2796 inline 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 } 2803 inline 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 } 2810 inline 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 } 2817 inline ::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; 2826 inline int DescriptorProto::field_size() const { 2827 return field_.size(); 2828 } 2829 inline void DescriptorProto::clear_field() { 2830 field_.Clear(); 2831 } 2832 inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::field(int index) const { 2833 return field_.Get(index); 2834 } 2835 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_field(int index) { 2836 return field_.Mutable(index); 2837 } 2838 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_field() { 2839 return field_.Add(); 2840 } 2841 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 2842 DescriptorProto::field() const { 2843 return field_; 2844 } 2845 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 2846 DescriptorProto::mutable_field() { 2847 return &field_; 2848 } 2849 2850 // repeated .google.protobuf.FieldDescriptorProto extension = 6; 2851 inline int DescriptorProto::extension_size() const { 2852 return extension_.size(); 2853 } 2854 inline void DescriptorProto::clear_extension() { 2855 extension_.Clear(); 2856 } 2857 inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::extension(int index) const { 2858 return extension_.Get(index); 2859 } 2860 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) { 2861 return extension_.Mutable(index); 2862 } 2863 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_extension() { 2864 return extension_.Add(); 2865 } 2866 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 2867 DescriptorProto::extension() const { 2868 return extension_; 2869 } 2870 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 2871 DescriptorProto::mutable_extension() { 2872 return &extension_; 2873 } 2874 2875 // repeated .google.protobuf.DescriptorProto nested_type = 3; 2876 inline int DescriptorProto::nested_type_size() const { 2877 return nested_type_.size(); 2878 } 2879 inline void DescriptorProto::clear_nested_type() { 2880 nested_type_.Clear(); 2881 } 2882 inline const ::google::protobuf::DescriptorProto& DescriptorProto::nested_type(int index) const { 2883 return nested_type_.Get(index); 2884 } 2885 inline ::google::protobuf::DescriptorProto* DescriptorProto::mutable_nested_type(int index) { 2886 return nested_type_.Mutable(index); 2887 } 2888 inline ::google::protobuf::DescriptorProto* DescriptorProto::add_nested_type() { 2889 return nested_type_.Add(); 2890 } 2891 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 2892 DescriptorProto::nested_type() const { 2893 return nested_type_; 2894 } 2895 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 2896 DescriptorProto::mutable_nested_type() { 2897 return &nested_type_; 2898 } 2899 2900 // repeated .google.protobuf.EnumDescriptorProto enum_type = 4; 2901 inline int DescriptorProto::enum_type_size() const { 2902 return enum_type_.size(); 2903 } 2904 inline void DescriptorProto::clear_enum_type() { 2905 enum_type_.Clear(); 2906 } 2907 inline const ::google::protobuf::EnumDescriptorProto& DescriptorProto::enum_type(int index) const { 2908 return enum_type_.Get(index); 2909 } 2910 inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) { 2911 return enum_type_.Mutable(index); 2912 } 2913 inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::add_enum_type() { 2914 return enum_type_.Add(); 2915 } 2916 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 2917 DescriptorProto::enum_type() const { 2918 return enum_type_; 2919 } 2920 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 2921 DescriptorProto::mutable_enum_type() { 2922 return &enum_type_; 2923 } 2924 2925 // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; 2926 inline int DescriptorProto::extension_range_size() const { 2927 return extension_range_.size(); 2928 } 2929 inline void DescriptorProto::clear_extension_range() { 2930 extension_range_.Clear(); 2931 } 2932 inline const ::google::protobuf::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const { 2933 return extension_range_.Get(index); 2934 } 2935 inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) { 2936 return extension_range_.Mutable(index); 2937 } 2938 inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() { 2939 return extension_range_.Add(); 2940 } 2941 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >& 2942 DescriptorProto::extension_range() const { 2943 return extension_range_; 2944 } 2945 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >* 2946 DescriptorProto::mutable_extension_range() { 2947 return &extension_range_; 2948 } 2949 2950 // optional .google.protobuf.MessageOptions options = 7; 2951 inline bool DescriptorProto::has_options() const { 2952 return _has_bit(6); 2953 } 2954 inline void DescriptorProto::clear_options() { 2955 if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear(); 2956 _clear_bit(6); 2957 } 2958 inline const ::google::protobuf::MessageOptions& DescriptorProto::options() const { 2959 return options_ != NULL ? *options_ : *default_instance_->options_; 2960 } 2961 inline ::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; 2972 inline bool FieldDescriptorProto::has_name() const { 2973 return _has_bit(0); 2974 } 2975 inline void FieldDescriptorProto::clear_name() { 2976 if (name_ != &_default_name_) { 2977 name_->clear(); 2978 } 2979 _clear_bit(0); 2980 } 2981 inline const ::std::string& FieldDescriptorProto::name() const { 2982 return *name_; 2983 } 2984 inline 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 } 2991 inline 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 } 2998 inline 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 } 3005 inline ::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; 3014 inline bool FieldDescriptorProto::has_number() const { 3015 return _has_bit(1); 3016 } 3017 inline void FieldDescriptorProto::clear_number() { 3018 number_ = 0; 3019 _clear_bit(1); 3020 } 3021 inline ::google::protobuf::int32 FieldDescriptorProto::number() const { 3022 return number_; 3023 } 3024 inline 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; 3030 inline bool FieldDescriptorProto::has_label() const { 3031 return _has_bit(2); 3032 } 3033 inline void FieldDescriptorProto::clear_label() { 3034 label_ = 1; 3035 _clear_bit(2); 3036 } 3037 inline ::google::protobuf::FieldDescriptorProto_Label FieldDescriptorProto::label() const { 3038 return static_cast< ::google::protobuf::FieldDescriptorProto_Label >(label_); 3039 } 3040 inline 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; 3047 inline bool FieldDescriptorProto::has_type() const { 3048 return _has_bit(3); 3049 } 3050 inline void FieldDescriptorProto::clear_type() { 3051 type_ = 1; 3052 _clear_bit(3); 3053 } 3054 inline ::google::protobuf::FieldDescriptorProto_Type FieldDescriptorProto::type() const { 3055 return static_cast< ::google::protobuf::FieldDescriptorProto_Type >(type_); 3056 } 3057 inline 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; 3064 inline bool FieldDescriptorProto::has_type_name() const { 3065 return _has_bit(4); 3066 } 3067 inline void FieldDescriptorProto::clear_type_name() { 3068 if (type_name_ != &_default_type_name_) { 3069 type_name_->clear(); 3070 } 3071 _clear_bit(4); 3072 } 3073 inline const ::std::string& FieldDescriptorProto::type_name() const { 3074 return *type_name_; 3075 } 3076 inline 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 } 3083 inline 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 } 3090 inline 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 } 3097 inline ::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; 3106 inline bool FieldDescriptorProto::has_extendee() const { 3107 return _has_bit(5); 3108 } 3109 inline void FieldDescriptorProto::clear_extendee() { 3110 if (extendee_ != &_default_extendee_) { 3111 extendee_->clear(); 3112 } 3113 _clear_bit(5); 3114 } 3115 inline const ::std::string& FieldDescriptorProto::extendee() const { 3116 return *extendee_; 3117 } 3118 inline 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 } 3125 inline 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 } 3132 inline 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 } 3139 inline ::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; 3148 inline bool FieldDescriptorProto::has_default_value() const { 3149 return _has_bit(6); 3150 } 3151 inline void FieldDescriptorProto::clear_default_value() { 3152 if (default_value_ != &_default_default_value_) { 3153 default_value_->clear(); 3154 } 3155 _clear_bit(6); 3156 } 3157 inline const ::std::string& FieldDescriptorProto::default_value() const { 3158 return *default_value_; 3159 } 3160 inline 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 } 3167 inline 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 } 3174 inline 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 } 3181 inline ::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; 3190 inline bool FieldDescriptorProto::has_options() const { 3191 return _has_bit(7); 3192 } 3193 inline void FieldDescriptorProto::clear_options() { 3194 if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear(); 3195 _clear_bit(7); 3196 } 3197 inline const ::google::protobuf::FieldOptions& FieldDescriptorProto::options() const { 3198 return options_ != NULL ? *options_ : *default_instance_->options_; 3199 } 3200 inline ::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; 3211 inline bool EnumDescriptorProto::has_name() const { 3212 return _has_bit(0); 3213 } 3214 inline void EnumDescriptorProto::clear_name() { 3215 if (name_ != &_default_name_) { 3216 name_->clear(); 3217 } 3218 _clear_bit(0); 3219 } 3220 inline const ::std::string& EnumDescriptorProto::name() const { 3221 return *name_; 3222 } 3223 inline 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 } 3230 inline 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 } 3237 inline 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 } 3244 inline ::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; 3253 inline int EnumDescriptorProto::value_size() const { 3254 return value_.size(); 3255 } 3256 inline void EnumDescriptorProto::clear_value() { 3257 value_.Clear(); 3258 } 3259 inline const ::google::protobuf::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const { 3260 return value_.Get(index); 3261 } 3262 inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) { 3263 return value_.Mutable(index); 3264 } 3265 inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::add_value() { 3266 return value_.Add(); 3267 } 3268 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >& 3269 EnumDescriptorProto::value() const { 3270 return value_; 3271 } 3272 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >* 3273 EnumDescriptorProto::mutable_value() { 3274 return &value_; 3275 } 3276 3277 // optional .google.protobuf.EnumOptions options = 3; 3278 inline bool EnumDescriptorProto::has_options() const { 3279 return _has_bit(2); 3280 } 3281 inline void EnumDescriptorProto::clear_options() { 3282 if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear(); 3283 _clear_bit(2); 3284 } 3285 inline const ::google::protobuf::EnumOptions& EnumDescriptorProto::options() const { 3286 return options_ != NULL ? *options_ : *default_instance_->options_; 3287 } 3288 inline ::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; 3299 inline bool EnumValueDescriptorProto::has_name() const { 3300 return _has_bit(0); 3301 } 3302 inline void EnumValueDescriptorProto::clear_name() { 3303 if (name_ != &_default_name_) { 3304 name_->clear(); 3305 } 3306 _clear_bit(0); 3307 } 3308 inline const ::std::string& EnumValueDescriptorProto::name() const { 3309 return *name_; 3310 } 3311 inline 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 } 3318 inline 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 } 3325 inline 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 } 3332 inline ::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; 3341 inline bool EnumValueDescriptorProto::has_number() const { 3342 return _has_bit(1); 3343 } 3344 inline void EnumValueDescriptorProto::clear_number() { 3345 number_ = 0; 3346 _clear_bit(1); 3347 } 3348 inline ::google::protobuf::int32 EnumValueDescriptorProto::number() const { 3349 return number_; 3350 } 3351 inline void EnumValueDescriptorProto::set_number(::google::protobuf::int32 value) { 3352 _set_bit(1); 3353 number_ = value; 3354 } 3355 3356 // optional .google.protobuf.EnumValueOptions options = 3; 3357 inline bool EnumValueDescriptorProto::has_options() const { 3358 return _has_bit(2); 3359 } 3360 inline void EnumValueDescriptorProto::clear_options() { 3361 if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear(); 3362 _clear_bit(2); 3363 } 3364 inline const ::google::protobuf::EnumValueOptions& EnumValueDescriptorProto::options() const { 3365 return options_ != NULL ? *options_ : *default_instance_->options_; 3366 } 3367 inline ::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; 3378 inline bool ServiceDescriptorProto::has_name() const { 3379 return _has_bit(0); 3380 } 3381 inline void ServiceDescriptorProto::clear_name() { 3382 if (name_ != &_default_name_) { 3383 name_->clear(); 3384 } 3385 _clear_bit(0); 3386 } 3387 inline const ::std::string& ServiceDescriptorProto::name() const { 3388 return *name_; 3389 } 3390 inline 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 } 3397 inline 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 } 3404 inline 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 } 3411 inline ::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; 3420 inline int ServiceDescriptorProto::method_size() const { 3421 return method_.size(); 3422 } 3423 inline void ServiceDescriptorProto::clear_method() { 3424 method_.Clear(); 3425 } 3426 inline const ::google::protobuf::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const { 3427 return method_.Get(index); 3428 } 3429 inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) { 3430 return method_.Mutable(index); 3431 } 3432 inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::add_method() { 3433 return method_.Add(); 3434 } 3435 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >& 3436 ServiceDescriptorProto::method() const { 3437 return method_; 3438 } 3439 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >* 3440 ServiceDescriptorProto::mutable_method() { 3441 return &method_; 3442 } 3443 3444 // optional .google.protobuf.ServiceOptions options = 3; 3445 inline bool ServiceDescriptorProto::has_options() const { 3446 return _has_bit(2); 3447 } 3448 inline void ServiceDescriptorProto::clear_options() { 3449 if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear(); 3450 _clear_bit(2); 3451 } 3452 inline const ::google::protobuf::ServiceOptions& ServiceDescriptorProto::options() const { 3453 return options_ != NULL ? *options_ : *default_instance_->options_; 3454 } 3455 inline ::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; 3466 inline bool MethodDescriptorProto::has_name() const { 3467 return _has_bit(0); 3468 } 3469 inline void MethodDescriptorProto::clear_name() { 3470 if (name_ != &_default_name_) { 3471 name_->clear(); 3472 } 3473 _clear_bit(0); 3474 } 3475 inline const ::std::string& MethodDescriptorProto::name() const { 3476 return *name_; 3477 } 3478 inline 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 } 3485 inline 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 } 3492 inline 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 } 3499 inline ::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; 3508 inline bool MethodDescriptorProto::has_input_type() const { 3509 return _has_bit(1); 3510 } 3511 inline void MethodDescriptorProto::clear_input_type() { 3512 if (input_type_ != &_default_input_type_) { 3513 input_type_->clear(); 3514 } 3515 _clear_bit(1); 3516 } 3517 inline const ::std::string& MethodDescriptorProto::input_type() const { 3518 return *input_type_; 3519 } 3520 inline 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 } 3527 inline 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 } 3534 inline 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 } 3541 inline ::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; 3550 inline bool MethodDescriptorProto::has_output_type() const { 3551 return _has_bit(2); 3552 } 3553 inline void MethodDescriptorProto::clear_output_type() { 3554 if (output_type_ != &_default_output_type_) { 3555 output_type_->clear(); 3556 } 3557 _clear_bit(2); 3558 } 3559 inline const ::std::string& MethodDescriptorProto::output_type() const { 3560 return *output_type_; 3561 } 3562 inline 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 } 3569 inline 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 } 3576 inline 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 } 3583 inline ::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; 3592 inline bool MethodDescriptorProto::has_options() const { 3593 return _has_bit(3); 3594 } 3595 inline void MethodDescriptorProto::clear_options() { 3596 if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear(); 3597 _clear_bit(3); 3598 } 3599 inline const ::google::protobuf::MethodOptions& MethodDescriptorProto::options() const { 3600 return options_ != NULL ? *options_ : *default_instance_->options_; 3601 } 3602 inline ::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; 3613 inline bool FileOptions::has_java_package() const { 3614 return _has_bit(0); 3615 } 3616 inline void FileOptions::clear_java_package() { 3617 if (java_package_ != &_default_java_package_) { 3618 java_package_->clear(); 3619 } 3620 _clear_bit(0); 3621 } 3622 inline const ::std::string& FileOptions::java_package() const { 3623 return *java_package_; 3624 } 3625 inline 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 } 3632 inline 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 } 3639 inline 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 } 3646 inline ::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; 3655 inline bool FileOptions::has_java_outer_classname() const { 3656 return _has_bit(1); 3657 } 3658 inline 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 } 3664 inline const ::std::string& FileOptions::java_outer_classname() const { 3665 return *java_outer_classname_; 3666 } 3667 inline 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 } 3674 inline 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 } 3681 inline 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 } 3688 inline ::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]; 3697 inline bool FileOptions::has_java_multiple_files() const { 3698 return _has_bit(2); 3699 } 3700 inline void FileOptions::clear_java_multiple_files() { 3701 java_multiple_files_ = false; 3702 _clear_bit(2); 3703 } 3704 inline bool FileOptions::java_multiple_files() const { 3705 return java_multiple_files_; 3706 } 3707 inline 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]; 3713 inline bool FileOptions::has_optimize_for() const { 3714 return _has_bit(3); 3715 } 3716 inline void FileOptions::clear_optimize_for() { 3717 optimize_for_ = 1; 3718 _clear_bit(3); 3719 } 3720 inline ::google::protobuf::FileOptions_OptimizeMode FileOptions::optimize_for() const { 3721 return static_cast< ::google::protobuf::FileOptions_OptimizeMode >(optimize_for_); 3722 } 3723 inline 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]; 3730 inline bool FileOptions::has_cc_generic_services() const { 3731 return _has_bit(4); 3732 } 3733 inline void FileOptions::clear_cc_generic_services() { 3734 cc_generic_services_ = true; 3735 _clear_bit(4); 3736 } 3737 inline bool FileOptions::cc_generic_services() const { 3738 return cc_generic_services_; 3739 } 3740 inline 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]; 3746 inline bool FileOptions::has_java_generic_services() const { 3747 return _has_bit(5); 3748 } 3749 inline void FileOptions::clear_java_generic_services() { 3750 java_generic_services_ = true; 3751 _clear_bit(5); 3752 } 3753 inline bool FileOptions::java_generic_services() const { 3754 return java_generic_services_; 3755 } 3756 inline 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]; 3762 inline bool FileOptions::has_py_generic_services() const { 3763 return _has_bit(6); 3764 } 3765 inline void FileOptions::clear_py_generic_services() { 3766 py_generic_services_ = true; 3767 _clear_bit(6); 3768 } 3769 inline bool FileOptions::py_generic_services() const { 3770 return py_generic_services_; 3771 } 3772 inline 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; 3778 inline int FileOptions::uninterpreted_option_size() const { 3779 return uninterpreted_option_.size(); 3780 } 3781 inline void FileOptions::clear_uninterpreted_option() { 3782 uninterpreted_option_.Clear(); 3783 } 3784 inline const ::google::protobuf::UninterpretedOption& FileOptions::uninterpreted_option(int index) const { 3785 return uninterpreted_option_.Get(index); 3786 } 3787 inline ::google::protobuf::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) { 3788 return uninterpreted_option_.Mutable(index); 3789 } 3790 inline ::google::protobuf::UninterpretedOption* FileOptions::add_uninterpreted_option() { 3791 return uninterpreted_option_.Add(); 3792 } 3793 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 3794 FileOptions::uninterpreted_option() const { 3795 return uninterpreted_option_; 3796 } 3797 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 3798 FileOptions::mutable_uninterpreted_option() { 3799 return &uninterpreted_option_; 3800 } 3801 3802 // ------------------------------------------------------------------- 3803 3804 // MessageOptions 3805 3806 // optional bool message_set_wire_format = 1 [default = false]; 3807 inline bool MessageOptions::has_message_set_wire_format() const { 3808 return _has_bit(0); 3809 } 3810 inline void MessageOptions::clear_message_set_wire_format() { 3811 message_set_wire_format_ = false; 3812 _clear_bit(0); 3813 } 3814 inline bool MessageOptions::message_set_wire_format() const { 3815 return message_set_wire_format_; 3816 } 3817 inline 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]; 3823 inline bool MessageOptions::has_no_standard_descriptor_accessor() const { 3824 return _has_bit(1); 3825 } 3826 inline void MessageOptions::clear_no_standard_descriptor_accessor() { 3827 no_standard_descriptor_accessor_ = false; 3828 _clear_bit(1); 3829 } 3830 inline bool MessageOptions::no_standard_descriptor_accessor() const { 3831 return no_standard_descriptor_accessor_; 3832 } 3833 inline 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; 3839 inline int MessageOptions::uninterpreted_option_size() const { 3840 return uninterpreted_option_.size(); 3841 } 3842 inline void MessageOptions::clear_uninterpreted_option() { 3843 uninterpreted_option_.Clear(); 3844 } 3845 inline const ::google::protobuf::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const { 3846 return uninterpreted_option_.Get(index); 3847 } 3848 inline ::google::protobuf::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) { 3849 return uninterpreted_option_.Mutable(index); 3850 } 3851 inline ::google::protobuf::UninterpretedOption* MessageOptions::add_uninterpreted_option() { 3852 return uninterpreted_option_.Add(); 3853 } 3854 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 3855 MessageOptions::uninterpreted_option() const { 3856 return uninterpreted_option_; 3857 } 3858 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 3859 MessageOptions::mutable_uninterpreted_option() { 3860 return &uninterpreted_option_; 3861 } 3862 3863 // ------------------------------------------------------------------- 3864 3865 // FieldOptions 3866 3867 // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 3868 inline bool FieldOptions::has_ctype() const { 3869 return _has_bit(0); 3870 } 3871 inline void FieldOptions::clear_ctype() { 3872 ctype_ = 0; 3873 _clear_bit(0); 3874 } 3875 inline ::google::protobuf::FieldOptions_CType FieldOptions::ctype() const { 3876 return static_cast< ::google::protobuf::FieldOptions_CType >(ctype_); 3877 } 3878 inline 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; 3885 inline bool FieldOptions::has_packed() const { 3886 return _has_bit(1); 3887 } 3888 inline void FieldOptions::clear_packed() { 3889 packed_ = false; 3890 _clear_bit(1); 3891 } 3892 inline bool FieldOptions::packed() const { 3893 return packed_; 3894 } 3895 inline void FieldOptions::set_packed(bool value) { 3896 _set_bit(1); 3897 packed_ = value; 3898 } 3899 3900 // optional bool deprecated = 3 [default = false]; 3901 inline bool FieldOptions::has_deprecated() const { 3902 return _has_bit(2); 3903 } 3904 inline void FieldOptions::clear_deprecated() { 3905 deprecated_ = false; 3906 _clear_bit(2); 3907 } 3908 inline bool FieldOptions::deprecated() const { 3909 return deprecated_; 3910 } 3911 inline void FieldOptions::set_deprecated(bool value) { 3912 _set_bit(2); 3913 deprecated_ = value; 3914 } 3915 3916 // optional string experimental_map_key = 9; 3917 inline bool FieldOptions::has_experimental_map_key() const { 3918 return _has_bit(3); 3919 } 3920 inline 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 } 3926 inline const ::std::string& FieldOptions::experimental_map_key() const { 3927 return *experimental_map_key_; 3928 } 3929 inline 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 } 3936 inline 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 } 3943 inline 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 } 3950 inline ::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; 3959 inline int FieldOptions::uninterpreted_option_size() const { 3960 return uninterpreted_option_.size(); 3961 } 3962 inline void FieldOptions::clear_uninterpreted_option() { 3963 uninterpreted_option_.Clear(); 3964 } 3965 inline const ::google::protobuf::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const { 3966 return uninterpreted_option_.Get(index); 3967 } 3968 inline ::google::protobuf::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) { 3969 return uninterpreted_option_.Mutable(index); 3970 } 3971 inline ::google::protobuf::UninterpretedOption* FieldOptions::add_uninterpreted_option() { 3972 return uninterpreted_option_.Add(); 3973 } 3974 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 3975 FieldOptions::uninterpreted_option() const { 3976 return uninterpreted_option_; 3977 } 3978 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 3979 FieldOptions::mutable_uninterpreted_option() { 3980 return &uninterpreted_option_; 3981 } 3982 3983 // ------------------------------------------------------------------- 3984 3985 // EnumOptions 3986 3987 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 3988 inline int EnumOptions::uninterpreted_option_size() const { 3989 return uninterpreted_option_.size(); 3990 } 3991 inline void EnumOptions::clear_uninterpreted_option() { 3992 uninterpreted_option_.Clear(); 3993 } 3994 inline const ::google::protobuf::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const { 3995 return uninterpreted_option_.Get(index); 3996 } 3997 inline ::google::protobuf::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) { 3998 return uninterpreted_option_.Mutable(index); 3999 } 4000 inline ::google::protobuf::UninterpretedOption* EnumOptions::add_uninterpreted_option() { 4001 return uninterpreted_option_.Add(); 4002 } 4003 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4004 EnumOptions::uninterpreted_option() const { 4005 return uninterpreted_option_; 4006 } 4007 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4008 EnumOptions::mutable_uninterpreted_option() { 4009 return &uninterpreted_option_; 4010 } 4011 4012 // ------------------------------------------------------------------- 4013 4014 // EnumValueOptions 4015 4016 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4017 inline int EnumValueOptions::uninterpreted_option_size() const { 4018 return uninterpreted_option_.size(); 4019 } 4020 inline void EnumValueOptions::clear_uninterpreted_option() { 4021 uninterpreted_option_.Clear(); 4022 } 4023 inline const ::google::protobuf::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const { 4024 return uninterpreted_option_.Get(index); 4025 } 4026 inline ::google::protobuf::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) { 4027 return uninterpreted_option_.Mutable(index); 4028 } 4029 inline ::google::protobuf::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() { 4030 return uninterpreted_option_.Add(); 4031 } 4032 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4033 EnumValueOptions::uninterpreted_option() const { 4034 return uninterpreted_option_; 4035 } 4036 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4037 EnumValueOptions::mutable_uninterpreted_option() { 4038 return &uninterpreted_option_; 4039 } 4040 4041 // ------------------------------------------------------------------- 4042 4043 // ServiceOptions 4044 4045 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4046 inline int ServiceOptions::uninterpreted_option_size() const { 4047 return uninterpreted_option_.size(); 4048 } 4049 inline void ServiceOptions::clear_uninterpreted_option() { 4050 uninterpreted_option_.Clear(); 4051 } 4052 inline const ::google::protobuf::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const { 4053 return uninterpreted_option_.Get(index); 4054 } 4055 inline ::google::protobuf::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) { 4056 return uninterpreted_option_.Mutable(index); 4057 } 4058 inline ::google::protobuf::UninterpretedOption* ServiceOptions::add_uninterpreted_option() { 4059 return uninterpreted_option_.Add(); 4060 } 4061 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4062 ServiceOptions::uninterpreted_option() const { 4063 return uninterpreted_option_; 4064 } 4065 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4066 ServiceOptions::mutable_uninterpreted_option() { 4067 return &uninterpreted_option_; 4068 } 4069 4070 // ------------------------------------------------------------------- 4071 4072 // MethodOptions 4073 4074 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4075 inline int MethodOptions::uninterpreted_option_size() const { 4076 return uninterpreted_option_.size(); 4077 } 4078 inline void MethodOptions::clear_uninterpreted_option() { 4079 uninterpreted_option_.Clear(); 4080 } 4081 inline const ::google::protobuf::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const { 4082 return uninterpreted_option_.Get(index); 4083 } 4084 inline ::google::protobuf::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) { 4085 return uninterpreted_option_.Mutable(index); 4086 } 4087 inline ::google::protobuf::UninterpretedOption* MethodOptions::add_uninterpreted_option() { 4088 return uninterpreted_option_.Add(); 4089 } 4090 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4091 MethodOptions::uninterpreted_option() const { 4092 return uninterpreted_option_; 4093 } 4094 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4095 MethodOptions::mutable_uninterpreted_option() { 4096 return &uninterpreted_option_; 4097 } 4098 4099 // ------------------------------------------------------------------- 4100 4101 // UninterpretedOption_NamePart 4102 4103 // required string name_part = 1; 4104 inline bool UninterpretedOption_NamePart::has_name_part() const { 4105 return _has_bit(0); 4106 } 4107 inline void UninterpretedOption_NamePart::clear_name_part() { 4108 if (name_part_ != &_default_name_part_) { 4109 name_part_->clear(); 4110 } 4111 _clear_bit(0); 4112 } 4113 inline const ::std::string& UninterpretedOption_NamePart::name_part() const { 4114 return *name_part_; 4115 } 4116 inline 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 } 4123 inline 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 } 4130 inline 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 } 4137 inline ::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; 4146 inline bool UninterpretedOption_NamePart::has_is_extension() const { 4147 return _has_bit(1); 4148 } 4149 inline void UninterpretedOption_NamePart::clear_is_extension() { 4150 is_extension_ = false; 4151 _clear_bit(1); 4152 } 4153 inline bool UninterpretedOption_NamePart::is_extension() const { 4154 return is_extension_; 4155 } 4156 inline 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; 4166 inline int UninterpretedOption::name_size() const { 4167 return name_.size(); 4168 } 4169 inline void UninterpretedOption::clear_name() { 4170 name_.Clear(); 4171 } 4172 inline const ::google::protobuf::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const { 4173 return name_.Get(index); 4174 } 4175 inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) { 4176 return name_.Mutable(index); 4177 } 4178 inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::add_name() { 4179 return name_.Add(); 4180 } 4181 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 4182 UninterpretedOption::name() const { 4183 return name_; 4184 } 4185 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 4186 UninterpretedOption::mutable_name() { 4187 return &name_; 4188 } 4189 4190 // optional string identifier_value = 3; 4191 inline bool UninterpretedOption::has_identifier_value() const { 4192 return _has_bit(1); 4193 } 4194 inline void UninterpretedOption::clear_identifier_value() { 4195 if (identifier_value_ != &_default_identifier_value_) { 4196 identifier_value_->clear(); 4197 } 4198 _clear_bit(1); 4199 } 4200 inline const ::std::string& UninterpretedOption::identifier_value() const { 4201 return *identifier_value_; 4202 } 4203 inline 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 } 4210 inline 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 } 4217 inline 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 } 4224 inline ::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; 4233 inline bool UninterpretedOption::has_positive_int_value() const { 4234 return _has_bit(2); 4235 } 4236 inline void UninterpretedOption::clear_positive_int_value() { 4237 positive_int_value_ = GOOGLE_ULONGLONG(0); 4238 _clear_bit(2); 4239 } 4240 inline ::google::protobuf::uint64 UninterpretedOption::positive_int_value() const { 4241 return positive_int_value_; 4242 } 4243 inline 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; 4249 inline bool UninterpretedOption::has_negative_int_value() const { 4250 return _has_bit(3); 4251 } 4252 inline void UninterpretedOption::clear_negative_int_value() { 4253 negative_int_value_ = GOOGLE_LONGLONG(0); 4254 _clear_bit(3); 4255 } 4256 inline ::google::protobuf::int64 UninterpretedOption::negative_int_value() const { 4257 return negative_int_value_; 4258 } 4259 inline 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; 4265 inline bool UninterpretedOption::has_double_value() const { 4266 return _has_bit(4); 4267 } 4268 inline void UninterpretedOption::clear_double_value() { 4269 double_value_ = 0; 4270 _clear_bit(4); 4271 } 4272 inline double UninterpretedOption::double_value() const { 4273 return double_value_; 4274 } 4275 inline void UninterpretedOption::set_double_value(double value) { 4276 _set_bit(4); 4277 double_value_ = value; 4278 } 4279 4280 // optional bytes string_value = 7; 4281 inline bool UninterpretedOption::has_string_value() const { 4282 return _has_bit(5); 4283 } 4284 inline void UninterpretedOption::clear_string_value() { 4285 if (string_value_ != &_default_string_value_) { 4286 string_value_->clear(); 4287 } 4288 _clear_bit(5); 4289 } 4290 inline const ::std::string& UninterpretedOption::string_value() const { 4291 return *string_value_; 4292 } 4293 inline 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 } 4300 inline 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 } 4307 inline 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 } 4314 inline ::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 4329 namespace google { 4330 namespace protobuf { 4331 4332 template <> 4333 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type>() { 4334 return ::google::protobuf::FieldDescriptorProto_Type_descriptor(); 4335 } 4336 template <> 4337 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label>() { 4338 return ::google::protobuf::FieldDescriptorProto_Label_descriptor(); 4339 } 4340 template <> 4341 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode>() { 4342 return ::google::protobuf::FileOptions_OptimizeMode_descriptor(); 4343 } 4344 template <> 4345 inline 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
