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