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 retain_unknown_fields = 12 [default = false]; 1532 inline bool has_retain_unknown_fields() const; 1533 inline void clear_retain_unknown_fields(); 1534 static const int kRetainUnknownFieldsFieldNumber = 12; 1535 inline bool retain_unknown_fields() const; 1536 inline void set_retain_unknown_fields(bool value); 1537 1538 // optional bool java_generate_equals_and_hash = 20 [default = false]; 1539 inline bool has_java_generate_equals_and_hash() const; 1540 inline void clear_java_generate_equals_and_hash(); 1541 static const int kJavaGenerateEqualsAndHashFieldNumber = 20; 1542 inline bool java_generate_equals_and_hash() const; 1543 inline void set_java_generate_equals_and_hash(bool value); 1544 1545 // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; 1546 inline bool has_optimize_for() const; 1547 inline void clear_optimize_for(); 1548 static const int kOptimizeForFieldNumber = 9; 1549 inline ::google::protobuf::FileOptions_OptimizeMode optimize_for() const; 1550 inline void set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value); 1551 1552 // optional string go_package = 11; 1553 inline bool has_go_package() const; 1554 inline void clear_go_package(); 1555 static const int kGoPackageFieldNumber = 11; 1556 inline const ::std::string& go_package() const; 1557 inline void set_go_package(const ::std::string& value); 1558 inline void set_go_package(const char* value); 1559 inline void set_go_package(const char* value, size_t size); 1560 inline ::std::string* mutable_go_package(); 1561 inline ::std::string* release_go_package(); 1562 inline void set_allocated_go_package(::std::string* go_package); 1563 1564 // optional bool cc_generic_services = 16 [default = false]; 1565 inline bool has_cc_generic_services() const; 1566 inline void clear_cc_generic_services(); 1567 static const int kCcGenericServicesFieldNumber = 16; 1568 inline bool cc_generic_services() const; 1569 inline void set_cc_generic_services(bool value); 1570 1571 // optional bool java_generic_services = 17 [default = false]; 1572 inline bool has_java_generic_services() const; 1573 inline void clear_java_generic_services(); 1574 static const int kJavaGenericServicesFieldNumber = 17; 1575 inline bool java_generic_services() const; 1576 inline void set_java_generic_services(bool value); 1577 1578 // optional bool py_generic_services = 18 [default = false]; 1579 inline bool has_py_generic_services() const; 1580 inline void clear_py_generic_services(); 1581 static const int kPyGenericServicesFieldNumber = 18; 1582 inline bool py_generic_services() const; 1583 inline void set_py_generic_services(bool value); 1584 1585 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1586 inline int uninterpreted_option_size() const; 1587 inline void clear_uninterpreted_option(); 1588 static const int kUninterpretedOptionFieldNumber = 999; 1589 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1590 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1591 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1592 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1593 uninterpreted_option() const; 1594 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1595 mutable_uninterpreted_option(); 1596 1597 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FileOptions) 1598 // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions) 1599 private: 1600 inline void set_has_java_package(); 1601 inline void clear_has_java_package(); 1602 inline void set_has_java_outer_classname(); 1603 inline void clear_has_java_outer_classname(); 1604 inline void set_has_java_multiple_files(); 1605 inline void clear_has_java_multiple_files(); 1606 inline void set_has_retain_unknown_fields(); 1607 inline void clear_has_retain_unknown_fields(); 1608 inline void set_has_java_generate_equals_and_hash(); 1609 inline void clear_has_java_generate_equals_and_hash(); 1610 inline void set_has_optimize_for(); 1611 inline void clear_has_optimize_for(); 1612 inline void set_has_go_package(); 1613 inline void clear_has_go_package(); 1614 inline void set_has_cc_generic_services(); 1615 inline void clear_has_cc_generic_services(); 1616 inline void set_has_java_generic_services(); 1617 inline void clear_has_java_generic_services(); 1618 inline void set_has_py_generic_services(); 1619 inline void clear_has_py_generic_services(); 1620 1621 ::google::protobuf::internal::ExtensionSet _extensions_; 1622 1623 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1624 1625 ::std::string* java_package_; 1626 ::std::string* java_outer_classname_; 1627 bool java_multiple_files_; 1628 bool retain_unknown_fields_; 1629 bool java_generate_equals_and_hash_; 1630 bool cc_generic_services_; 1631 int optimize_for_; 1632 ::std::string* go_package_; 1633 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1634 bool java_generic_services_; 1635 bool py_generic_services_; 1636 1637 mutable int _cached_size_; 1638 ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32]; 1639 1640 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1641 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1642 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1643 1644 void InitAsDefaultInstance(); 1645 static FileOptions* default_instance_; 1646}; 1647// ------------------------------------------------------------------- 1648 1649class LIBPROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message { 1650 public: 1651 MessageOptions(); 1652 virtual ~MessageOptions(); 1653 1654 MessageOptions(const MessageOptions& from); 1655 1656 inline MessageOptions& operator=(const MessageOptions& from) { 1657 CopyFrom(from); 1658 return *this; 1659 } 1660 1661 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1662 return _unknown_fields_; 1663 } 1664 1665 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1666 return &_unknown_fields_; 1667 } 1668 1669 static const ::google::protobuf::Descriptor* descriptor(); 1670 static const MessageOptions& default_instance(); 1671 1672 void Swap(MessageOptions* other); 1673 1674 // implements Message ---------------------------------------------- 1675 1676 MessageOptions* New() const; 1677 void CopyFrom(const ::google::protobuf::Message& from); 1678 void MergeFrom(const ::google::protobuf::Message& from); 1679 void CopyFrom(const MessageOptions& from); 1680 void MergeFrom(const MessageOptions& from); 1681 void Clear(); 1682 bool IsInitialized() const; 1683 1684 int ByteSize() const; 1685 bool MergePartialFromCodedStream( 1686 ::google::protobuf::io::CodedInputStream* input); 1687 void SerializeWithCachedSizes( 1688 ::google::protobuf::io::CodedOutputStream* output) const; 1689 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1690 int GetCachedSize() const { return _cached_size_; } 1691 private: 1692 void SharedCtor(); 1693 void SharedDtor(); 1694 void SetCachedSize(int size) const; 1695 public: 1696 1697 ::google::protobuf::Metadata GetMetadata() const; 1698 1699 // nested types ---------------------------------------------------- 1700 1701 // accessors ------------------------------------------------------- 1702 1703 // optional bool message_set_wire_format = 1 [default = false]; 1704 inline bool has_message_set_wire_format() const; 1705 inline void clear_message_set_wire_format(); 1706 static const int kMessageSetWireFormatFieldNumber = 1; 1707 inline bool message_set_wire_format() const; 1708 inline void set_message_set_wire_format(bool value); 1709 1710 // optional bool no_standard_descriptor_accessor = 2 [default = false]; 1711 inline bool has_no_standard_descriptor_accessor() const; 1712 inline void clear_no_standard_descriptor_accessor(); 1713 static const int kNoStandardDescriptorAccessorFieldNumber = 2; 1714 inline bool no_standard_descriptor_accessor() const; 1715 inline void set_no_standard_descriptor_accessor(bool value); 1716 1717 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1718 inline int uninterpreted_option_size() const; 1719 inline void clear_uninterpreted_option(); 1720 static const int kUninterpretedOptionFieldNumber = 999; 1721 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1722 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1723 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1724 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1725 uninterpreted_option() const; 1726 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1727 mutable_uninterpreted_option(); 1728 1729 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MessageOptions) 1730 // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions) 1731 private: 1732 inline void set_has_message_set_wire_format(); 1733 inline void clear_has_message_set_wire_format(); 1734 inline void set_has_no_standard_descriptor_accessor(); 1735 inline void clear_has_no_standard_descriptor_accessor(); 1736 1737 ::google::protobuf::internal::ExtensionSet _extensions_; 1738 1739 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1740 1741 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1742 bool message_set_wire_format_; 1743 bool no_standard_descriptor_accessor_; 1744 1745 mutable int _cached_size_; 1746 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1747 1748 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1749 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1750 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1751 1752 void InitAsDefaultInstance(); 1753 static MessageOptions* default_instance_; 1754}; 1755// ------------------------------------------------------------------- 1756 1757class LIBPROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message { 1758 public: 1759 FieldOptions(); 1760 virtual ~FieldOptions(); 1761 1762 FieldOptions(const FieldOptions& from); 1763 1764 inline FieldOptions& operator=(const FieldOptions& from) { 1765 CopyFrom(from); 1766 return *this; 1767 } 1768 1769 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1770 return _unknown_fields_; 1771 } 1772 1773 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1774 return &_unknown_fields_; 1775 } 1776 1777 static const ::google::protobuf::Descriptor* descriptor(); 1778 static const FieldOptions& default_instance(); 1779 1780 void Swap(FieldOptions* other); 1781 1782 // implements Message ---------------------------------------------- 1783 1784 FieldOptions* New() const; 1785 void CopyFrom(const ::google::protobuf::Message& from); 1786 void MergeFrom(const ::google::protobuf::Message& from); 1787 void CopyFrom(const FieldOptions& from); 1788 void MergeFrom(const FieldOptions& from); 1789 void Clear(); 1790 bool IsInitialized() const; 1791 1792 int ByteSize() const; 1793 bool MergePartialFromCodedStream( 1794 ::google::protobuf::io::CodedInputStream* input); 1795 void SerializeWithCachedSizes( 1796 ::google::protobuf::io::CodedOutputStream* output) const; 1797 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1798 int GetCachedSize() const { return _cached_size_; } 1799 private: 1800 void SharedCtor(); 1801 void SharedDtor(); 1802 void SetCachedSize(int size) const; 1803 public: 1804 1805 ::google::protobuf::Metadata GetMetadata() const; 1806 1807 // nested types ---------------------------------------------------- 1808 1809 typedef FieldOptions_CType CType; 1810 static const CType STRING = FieldOptions_CType_STRING; 1811 static const CType CORD = FieldOptions_CType_CORD; 1812 static const CType STRING_PIECE = FieldOptions_CType_STRING_PIECE; 1813 static inline bool CType_IsValid(int value) { 1814 return FieldOptions_CType_IsValid(value); 1815 } 1816 static const CType CType_MIN = 1817 FieldOptions_CType_CType_MIN; 1818 static const CType CType_MAX = 1819 FieldOptions_CType_CType_MAX; 1820 static const int CType_ARRAYSIZE = 1821 FieldOptions_CType_CType_ARRAYSIZE; 1822 static inline const ::google::protobuf::EnumDescriptor* 1823 CType_descriptor() { 1824 return FieldOptions_CType_descriptor(); 1825 } 1826 static inline const ::std::string& CType_Name(CType value) { 1827 return FieldOptions_CType_Name(value); 1828 } 1829 static inline bool CType_Parse(const ::std::string& name, 1830 CType* value) { 1831 return FieldOptions_CType_Parse(name, value); 1832 } 1833 1834 // accessors ------------------------------------------------------- 1835 1836 // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 1837 inline bool has_ctype() const; 1838 inline void clear_ctype(); 1839 static const int kCtypeFieldNumber = 1; 1840 inline ::google::protobuf::FieldOptions_CType ctype() const; 1841 inline void set_ctype(::google::protobuf::FieldOptions_CType value); 1842 1843 // optional bool packed = 2; 1844 inline bool has_packed() const; 1845 inline void clear_packed(); 1846 static const int kPackedFieldNumber = 2; 1847 inline bool packed() const; 1848 inline void set_packed(bool value); 1849 1850 // optional bool lazy = 5 [default = false]; 1851 inline bool has_lazy() const; 1852 inline void clear_lazy(); 1853 static const int kLazyFieldNumber = 5; 1854 inline bool lazy() const; 1855 inline void set_lazy(bool value); 1856 1857 // optional bool deprecated = 3 [default = false]; 1858 inline bool has_deprecated() const; 1859 inline void clear_deprecated(); 1860 static const int kDeprecatedFieldNumber = 3; 1861 inline bool deprecated() const; 1862 inline void set_deprecated(bool value); 1863 1864 // optional string experimental_map_key = 9; 1865 inline bool has_experimental_map_key() const; 1866 inline void clear_experimental_map_key(); 1867 static const int kExperimentalMapKeyFieldNumber = 9; 1868 inline const ::std::string& experimental_map_key() const; 1869 inline void set_experimental_map_key(const ::std::string& value); 1870 inline void set_experimental_map_key(const char* value); 1871 inline void set_experimental_map_key(const char* value, size_t size); 1872 inline ::std::string* mutable_experimental_map_key(); 1873 inline ::std::string* release_experimental_map_key(); 1874 inline void set_allocated_experimental_map_key(::std::string* experimental_map_key); 1875 1876 // optional bool weak = 10 [default = false]; 1877 inline bool has_weak() const; 1878 inline void clear_weak(); 1879 static const int kWeakFieldNumber = 10; 1880 inline bool weak() const; 1881 inline void set_weak(bool value); 1882 1883 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1884 inline int uninterpreted_option_size() const; 1885 inline void clear_uninterpreted_option(); 1886 static const int kUninterpretedOptionFieldNumber = 999; 1887 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 1888 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 1889 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 1890 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 1891 uninterpreted_option() const; 1892 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 1893 mutable_uninterpreted_option(); 1894 1895 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FieldOptions) 1896 // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions) 1897 private: 1898 inline void set_has_ctype(); 1899 inline void clear_has_ctype(); 1900 inline void set_has_packed(); 1901 inline void clear_has_packed(); 1902 inline void set_has_lazy(); 1903 inline void clear_has_lazy(); 1904 inline void set_has_deprecated(); 1905 inline void clear_has_deprecated(); 1906 inline void set_has_experimental_map_key(); 1907 inline void clear_has_experimental_map_key(); 1908 inline void set_has_weak(); 1909 inline void clear_has_weak(); 1910 1911 ::google::protobuf::internal::ExtensionSet _extensions_; 1912 1913 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1914 1915 int ctype_; 1916 bool packed_; 1917 bool lazy_; 1918 bool deprecated_; 1919 bool weak_; 1920 ::std::string* experimental_map_key_; 1921 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 1922 1923 mutable int _cached_size_; 1924 ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; 1925 1926 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1927 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 1928 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 1929 1930 void InitAsDefaultInstance(); 1931 static FieldOptions* default_instance_; 1932}; 1933// ------------------------------------------------------------------- 1934 1935class LIBPROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message { 1936 public: 1937 EnumOptions(); 1938 virtual ~EnumOptions(); 1939 1940 EnumOptions(const EnumOptions& from); 1941 1942 inline EnumOptions& operator=(const EnumOptions& from) { 1943 CopyFrom(from); 1944 return *this; 1945 } 1946 1947 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1948 return _unknown_fields_; 1949 } 1950 1951 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1952 return &_unknown_fields_; 1953 } 1954 1955 static const ::google::protobuf::Descriptor* descriptor(); 1956 static const EnumOptions& default_instance(); 1957 1958 void Swap(EnumOptions* other); 1959 1960 // implements Message ---------------------------------------------- 1961 1962 EnumOptions* New() const; 1963 void CopyFrom(const ::google::protobuf::Message& from); 1964 void MergeFrom(const ::google::protobuf::Message& from); 1965 void CopyFrom(const EnumOptions& from); 1966 void MergeFrom(const EnumOptions& from); 1967 void Clear(); 1968 bool IsInitialized() const; 1969 1970 int ByteSize() const; 1971 bool MergePartialFromCodedStream( 1972 ::google::protobuf::io::CodedInputStream* input); 1973 void SerializeWithCachedSizes( 1974 ::google::protobuf::io::CodedOutputStream* output) const; 1975 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1976 int GetCachedSize() const { return _cached_size_; } 1977 private: 1978 void SharedCtor(); 1979 void SharedDtor(); 1980 void SetCachedSize(int size) const; 1981 public: 1982 1983 ::google::protobuf::Metadata GetMetadata() const; 1984 1985 // nested types ---------------------------------------------------- 1986 1987 // accessors ------------------------------------------------------- 1988 1989 // optional bool allow_alias = 2 [default = true]; 1990 inline bool has_allow_alias() const; 1991 inline void clear_allow_alias(); 1992 static const int kAllowAliasFieldNumber = 2; 1993 inline bool allow_alias() const; 1994 inline void set_allow_alias(bool value); 1995 1996 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 1997 inline int uninterpreted_option_size() const; 1998 inline void clear_uninterpreted_option(); 1999 static const int kUninterpretedOptionFieldNumber = 999; 2000 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 2001 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 2002 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 2003 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 2004 uninterpreted_option() const; 2005 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 2006 mutable_uninterpreted_option(); 2007 2008 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumOptions) 2009 // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions) 2010 private: 2011 inline void set_has_allow_alias(); 2012 inline void clear_has_allow_alias(); 2013 2014 ::google::protobuf::internal::ExtensionSet _extensions_; 2015 2016 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2017 2018 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2019 bool allow_alias_; 2020 2021 mutable int _cached_size_; 2022 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 2023 2024 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2025 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2026 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2027 2028 void InitAsDefaultInstance(); 2029 static EnumOptions* default_instance_; 2030}; 2031// ------------------------------------------------------------------- 2032 2033class LIBPROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message { 2034 public: 2035 EnumValueOptions(); 2036 virtual ~EnumValueOptions(); 2037 2038 EnumValueOptions(const EnumValueOptions& from); 2039 2040 inline EnumValueOptions& operator=(const EnumValueOptions& from) { 2041 CopyFrom(from); 2042 return *this; 2043 } 2044 2045 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2046 return _unknown_fields_; 2047 } 2048 2049 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2050 return &_unknown_fields_; 2051 } 2052 2053 static const ::google::protobuf::Descriptor* descriptor(); 2054 static const EnumValueOptions& default_instance(); 2055 2056 void Swap(EnumValueOptions* other); 2057 2058 // implements Message ---------------------------------------------- 2059 2060 EnumValueOptions* New() const; 2061 void CopyFrom(const ::google::protobuf::Message& from); 2062 void MergeFrom(const ::google::protobuf::Message& from); 2063 void CopyFrom(const EnumValueOptions& from); 2064 void MergeFrom(const EnumValueOptions& from); 2065 void Clear(); 2066 bool IsInitialized() const; 2067 2068 int ByteSize() const; 2069 bool MergePartialFromCodedStream( 2070 ::google::protobuf::io::CodedInputStream* input); 2071 void SerializeWithCachedSizes( 2072 ::google::protobuf::io::CodedOutputStream* output) const; 2073 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2074 int GetCachedSize() const { return _cached_size_; } 2075 private: 2076 void SharedCtor(); 2077 void SharedDtor(); 2078 void SetCachedSize(int size) const; 2079 public: 2080 2081 ::google::protobuf::Metadata GetMetadata() const; 2082 2083 // nested types ---------------------------------------------------- 2084 2085 // accessors ------------------------------------------------------- 2086 2087 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 2088 inline int uninterpreted_option_size() const; 2089 inline void clear_uninterpreted_option(); 2090 static const int kUninterpretedOptionFieldNumber = 999; 2091 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 2092 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 2093 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 2094 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 2095 uninterpreted_option() const; 2096 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 2097 mutable_uninterpreted_option(); 2098 2099 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumValueOptions) 2100 // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions) 2101 private: 2102 2103 ::google::protobuf::internal::ExtensionSet _extensions_; 2104 2105 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2106 2107 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2108 2109 mutable int _cached_size_; 2110 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2111 2112 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2113 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2114 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2115 2116 void InitAsDefaultInstance(); 2117 static EnumValueOptions* default_instance_; 2118}; 2119// ------------------------------------------------------------------- 2120 2121class LIBPROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message { 2122 public: 2123 ServiceOptions(); 2124 virtual ~ServiceOptions(); 2125 2126 ServiceOptions(const ServiceOptions& from); 2127 2128 inline ServiceOptions& operator=(const ServiceOptions& from) { 2129 CopyFrom(from); 2130 return *this; 2131 } 2132 2133 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2134 return _unknown_fields_; 2135 } 2136 2137 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2138 return &_unknown_fields_; 2139 } 2140 2141 static const ::google::protobuf::Descriptor* descriptor(); 2142 static const ServiceOptions& default_instance(); 2143 2144 void Swap(ServiceOptions* other); 2145 2146 // implements Message ---------------------------------------------- 2147 2148 ServiceOptions* New() const; 2149 void CopyFrom(const ::google::protobuf::Message& from); 2150 void MergeFrom(const ::google::protobuf::Message& from); 2151 void CopyFrom(const ServiceOptions& from); 2152 void MergeFrom(const ServiceOptions& from); 2153 void Clear(); 2154 bool IsInitialized() const; 2155 2156 int ByteSize() const; 2157 bool MergePartialFromCodedStream( 2158 ::google::protobuf::io::CodedInputStream* input); 2159 void SerializeWithCachedSizes( 2160 ::google::protobuf::io::CodedOutputStream* output) const; 2161 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2162 int GetCachedSize() const { return _cached_size_; } 2163 private: 2164 void SharedCtor(); 2165 void SharedDtor(); 2166 void SetCachedSize(int size) const; 2167 public: 2168 2169 ::google::protobuf::Metadata GetMetadata() const; 2170 2171 // nested types ---------------------------------------------------- 2172 2173 // accessors ------------------------------------------------------- 2174 2175 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 2176 inline int uninterpreted_option_size() const; 2177 inline void clear_uninterpreted_option(); 2178 static const int kUninterpretedOptionFieldNumber = 999; 2179 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 2180 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 2181 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 2182 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 2183 uninterpreted_option() const; 2184 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 2185 mutable_uninterpreted_option(); 2186 2187 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ServiceOptions) 2188 // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions) 2189 private: 2190 2191 ::google::protobuf::internal::ExtensionSet _extensions_; 2192 2193 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2194 2195 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2196 2197 mutable int _cached_size_; 2198 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2199 2200 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2201 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2202 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2203 2204 void InitAsDefaultInstance(); 2205 static ServiceOptions* default_instance_; 2206}; 2207// ------------------------------------------------------------------- 2208 2209class LIBPROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message { 2210 public: 2211 MethodOptions(); 2212 virtual ~MethodOptions(); 2213 2214 MethodOptions(const MethodOptions& from); 2215 2216 inline MethodOptions& operator=(const MethodOptions& from) { 2217 CopyFrom(from); 2218 return *this; 2219 } 2220 2221 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2222 return _unknown_fields_; 2223 } 2224 2225 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2226 return &_unknown_fields_; 2227 } 2228 2229 static const ::google::protobuf::Descriptor* descriptor(); 2230 static const MethodOptions& default_instance(); 2231 2232 void Swap(MethodOptions* other); 2233 2234 // implements Message ---------------------------------------------- 2235 2236 MethodOptions* New() const; 2237 void CopyFrom(const ::google::protobuf::Message& from); 2238 void MergeFrom(const ::google::protobuf::Message& from); 2239 void CopyFrom(const MethodOptions& from); 2240 void MergeFrom(const MethodOptions& from); 2241 void Clear(); 2242 bool IsInitialized() const; 2243 2244 int ByteSize() const; 2245 bool MergePartialFromCodedStream( 2246 ::google::protobuf::io::CodedInputStream* input); 2247 void SerializeWithCachedSizes( 2248 ::google::protobuf::io::CodedOutputStream* output) const; 2249 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2250 int GetCachedSize() const { return _cached_size_; } 2251 private: 2252 void SharedCtor(); 2253 void SharedDtor(); 2254 void SetCachedSize(int size) const; 2255 public: 2256 2257 ::google::protobuf::Metadata GetMetadata() const; 2258 2259 // nested types ---------------------------------------------------- 2260 2261 // accessors ------------------------------------------------------- 2262 2263 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 2264 inline int uninterpreted_option_size() const; 2265 inline void clear_uninterpreted_option(); 2266 static const int kUninterpretedOptionFieldNumber = 999; 2267 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 2268 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 2269 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 2270 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 2271 uninterpreted_option() const; 2272 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 2273 mutable_uninterpreted_option(); 2274 2275 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MethodOptions) 2276 // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions) 2277 private: 2278 2279 ::google::protobuf::internal::ExtensionSet _extensions_; 2280 2281 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2282 2283 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 2284 2285 mutable int _cached_size_; 2286 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2287 2288 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2289 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2290 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2291 2292 void InitAsDefaultInstance(); 2293 static MethodOptions* default_instance_; 2294}; 2295// ------------------------------------------------------------------- 2296 2297class LIBPROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf::Message { 2298 public: 2299 UninterpretedOption_NamePart(); 2300 virtual ~UninterpretedOption_NamePart(); 2301 2302 UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from); 2303 2304 inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) { 2305 CopyFrom(from); 2306 return *this; 2307 } 2308 2309 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2310 return _unknown_fields_; 2311 } 2312 2313 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2314 return &_unknown_fields_; 2315 } 2316 2317 static const ::google::protobuf::Descriptor* descriptor(); 2318 static const UninterpretedOption_NamePart& default_instance(); 2319 2320 void Swap(UninterpretedOption_NamePart* other); 2321 2322 // implements Message ---------------------------------------------- 2323 2324 UninterpretedOption_NamePart* New() const; 2325 void CopyFrom(const ::google::protobuf::Message& from); 2326 void MergeFrom(const ::google::protobuf::Message& from); 2327 void CopyFrom(const UninterpretedOption_NamePart& from); 2328 void MergeFrom(const UninterpretedOption_NamePart& from); 2329 void Clear(); 2330 bool IsInitialized() const; 2331 2332 int ByteSize() const; 2333 bool MergePartialFromCodedStream( 2334 ::google::protobuf::io::CodedInputStream* input); 2335 void SerializeWithCachedSizes( 2336 ::google::protobuf::io::CodedOutputStream* output) const; 2337 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2338 int GetCachedSize() const { return _cached_size_; } 2339 private: 2340 void SharedCtor(); 2341 void SharedDtor(); 2342 void SetCachedSize(int size) const; 2343 public: 2344 2345 ::google::protobuf::Metadata GetMetadata() const; 2346 2347 // nested types ---------------------------------------------------- 2348 2349 // accessors ------------------------------------------------------- 2350 2351 // required string name_part = 1; 2352 inline bool has_name_part() const; 2353 inline void clear_name_part(); 2354 static const int kNamePartFieldNumber = 1; 2355 inline const ::std::string& name_part() const; 2356 inline void set_name_part(const ::std::string& value); 2357 inline void set_name_part(const char* value); 2358 inline void set_name_part(const char* value, size_t size); 2359 inline ::std::string* mutable_name_part(); 2360 inline ::std::string* release_name_part(); 2361 inline void set_allocated_name_part(::std::string* name_part); 2362 2363 // required bool is_extension = 2; 2364 inline bool has_is_extension() const; 2365 inline void clear_is_extension(); 2366 static const int kIsExtensionFieldNumber = 2; 2367 inline bool is_extension() const; 2368 inline void set_is_extension(bool value); 2369 2370 // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart) 2371 private: 2372 inline void set_has_name_part(); 2373 inline void clear_has_name_part(); 2374 inline void set_has_is_extension(); 2375 inline void clear_has_is_extension(); 2376 2377 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2378 2379 ::std::string* name_part_; 2380 bool is_extension_; 2381 2382 mutable int _cached_size_; 2383 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 2384 2385 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2386 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2387 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2388 2389 void InitAsDefaultInstance(); 2390 static UninterpretedOption_NamePart* default_instance_; 2391}; 2392// ------------------------------------------------------------------- 2393 2394class LIBPROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message { 2395 public: 2396 UninterpretedOption(); 2397 virtual ~UninterpretedOption(); 2398 2399 UninterpretedOption(const UninterpretedOption& from); 2400 2401 inline UninterpretedOption& operator=(const UninterpretedOption& from) { 2402 CopyFrom(from); 2403 return *this; 2404 } 2405 2406 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2407 return _unknown_fields_; 2408 } 2409 2410 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2411 return &_unknown_fields_; 2412 } 2413 2414 static const ::google::protobuf::Descriptor* descriptor(); 2415 static const UninterpretedOption& default_instance(); 2416 2417 void Swap(UninterpretedOption* other); 2418 2419 // implements Message ---------------------------------------------- 2420 2421 UninterpretedOption* New() const; 2422 void CopyFrom(const ::google::protobuf::Message& from); 2423 void MergeFrom(const ::google::protobuf::Message& from); 2424 void CopyFrom(const UninterpretedOption& from); 2425 void MergeFrom(const UninterpretedOption& from); 2426 void Clear(); 2427 bool IsInitialized() const; 2428 2429 int ByteSize() const; 2430 bool MergePartialFromCodedStream( 2431 ::google::protobuf::io::CodedInputStream* input); 2432 void SerializeWithCachedSizes( 2433 ::google::protobuf::io::CodedOutputStream* output) const; 2434 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2435 int GetCachedSize() const { return _cached_size_; } 2436 private: 2437 void SharedCtor(); 2438 void SharedDtor(); 2439 void SetCachedSize(int size) const; 2440 public: 2441 2442 ::google::protobuf::Metadata GetMetadata() const; 2443 2444 // nested types ---------------------------------------------------- 2445 2446 typedef UninterpretedOption_NamePart NamePart; 2447 2448 // accessors ------------------------------------------------------- 2449 2450 // repeated .google.protobuf.UninterpretedOption.NamePart name = 2; 2451 inline int name_size() const; 2452 inline void clear_name(); 2453 static const int kNameFieldNumber = 2; 2454 inline const ::google::protobuf::UninterpretedOption_NamePart& name(int index) const; 2455 inline ::google::protobuf::UninterpretedOption_NamePart* mutable_name(int index); 2456 inline ::google::protobuf::UninterpretedOption_NamePart* add_name(); 2457 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 2458 name() const; 2459 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 2460 mutable_name(); 2461 2462 // optional string identifier_value = 3; 2463 inline bool has_identifier_value() const; 2464 inline void clear_identifier_value(); 2465 static const int kIdentifierValueFieldNumber = 3; 2466 inline const ::std::string& identifier_value() const; 2467 inline void set_identifier_value(const ::std::string& value); 2468 inline void set_identifier_value(const char* value); 2469 inline void set_identifier_value(const char* value, size_t size); 2470 inline ::std::string* mutable_identifier_value(); 2471 inline ::std::string* release_identifier_value(); 2472 inline void set_allocated_identifier_value(::std::string* identifier_value); 2473 2474 // optional uint64 positive_int_value = 4; 2475 inline bool has_positive_int_value() const; 2476 inline void clear_positive_int_value(); 2477 static const int kPositiveIntValueFieldNumber = 4; 2478 inline ::google::protobuf::uint64 positive_int_value() const; 2479 inline void set_positive_int_value(::google::protobuf::uint64 value); 2480 2481 // optional int64 negative_int_value = 5; 2482 inline bool has_negative_int_value() const; 2483 inline void clear_negative_int_value(); 2484 static const int kNegativeIntValueFieldNumber = 5; 2485 inline ::google::protobuf::int64 negative_int_value() const; 2486 inline void set_negative_int_value(::google::protobuf::int64 value); 2487 2488 // optional double double_value = 6; 2489 inline bool has_double_value() const; 2490 inline void clear_double_value(); 2491 static const int kDoubleValueFieldNumber = 6; 2492 inline double double_value() const; 2493 inline void set_double_value(double value); 2494 2495 // optional bytes string_value = 7; 2496 inline bool has_string_value() const; 2497 inline void clear_string_value(); 2498 static const int kStringValueFieldNumber = 7; 2499 inline const ::std::string& string_value() const; 2500 inline void set_string_value(const ::std::string& value); 2501 inline void set_string_value(const char* value); 2502 inline void set_string_value(const void* value, size_t size); 2503 inline ::std::string* mutable_string_value(); 2504 inline ::std::string* release_string_value(); 2505 inline void set_allocated_string_value(::std::string* string_value); 2506 2507 // optional string aggregate_value = 8; 2508 inline bool has_aggregate_value() const; 2509 inline void clear_aggregate_value(); 2510 static const int kAggregateValueFieldNumber = 8; 2511 inline const ::std::string& aggregate_value() const; 2512 inline void set_aggregate_value(const ::std::string& value); 2513 inline void set_aggregate_value(const char* value); 2514 inline void set_aggregate_value(const char* value, size_t size); 2515 inline ::std::string* mutable_aggregate_value(); 2516 inline ::std::string* release_aggregate_value(); 2517 inline void set_allocated_aggregate_value(::std::string* aggregate_value); 2518 2519 // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption) 2520 private: 2521 inline void set_has_identifier_value(); 2522 inline void clear_has_identifier_value(); 2523 inline void set_has_positive_int_value(); 2524 inline void clear_has_positive_int_value(); 2525 inline void set_has_negative_int_value(); 2526 inline void clear_has_negative_int_value(); 2527 inline void set_has_double_value(); 2528 inline void clear_has_double_value(); 2529 inline void set_has_string_value(); 2530 inline void clear_has_string_value(); 2531 inline void set_has_aggregate_value(); 2532 inline void clear_has_aggregate_value(); 2533 2534 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2535 2536 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart > name_; 2537 ::std::string* identifier_value_; 2538 ::google::protobuf::uint64 positive_int_value_; 2539 ::google::protobuf::int64 negative_int_value_; 2540 double double_value_; 2541 ::std::string* string_value_; 2542 ::std::string* aggregate_value_; 2543 2544 mutable int _cached_size_; 2545 ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; 2546 2547 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2548 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2549 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2550 2551 void InitAsDefaultInstance(); 2552 static UninterpretedOption* default_instance_; 2553}; 2554// ------------------------------------------------------------------- 2555 2556class LIBPROTOBUF_EXPORT SourceCodeInfo_Location : public ::google::protobuf::Message { 2557 public: 2558 SourceCodeInfo_Location(); 2559 virtual ~SourceCodeInfo_Location(); 2560 2561 SourceCodeInfo_Location(const SourceCodeInfo_Location& from); 2562 2563 inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) { 2564 CopyFrom(from); 2565 return *this; 2566 } 2567 2568 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2569 return _unknown_fields_; 2570 } 2571 2572 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2573 return &_unknown_fields_; 2574 } 2575 2576 static const ::google::protobuf::Descriptor* descriptor(); 2577 static const SourceCodeInfo_Location& default_instance(); 2578 2579 void Swap(SourceCodeInfo_Location* other); 2580 2581 // implements Message ---------------------------------------------- 2582 2583 SourceCodeInfo_Location* New() const; 2584 void CopyFrom(const ::google::protobuf::Message& from); 2585 void MergeFrom(const ::google::protobuf::Message& from); 2586 void CopyFrom(const SourceCodeInfo_Location& from); 2587 void MergeFrom(const SourceCodeInfo_Location& from); 2588 void Clear(); 2589 bool IsInitialized() const; 2590 2591 int ByteSize() const; 2592 bool MergePartialFromCodedStream( 2593 ::google::protobuf::io::CodedInputStream* input); 2594 void SerializeWithCachedSizes( 2595 ::google::protobuf::io::CodedOutputStream* output) const; 2596 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2597 int GetCachedSize() const { return _cached_size_; } 2598 private: 2599 void SharedCtor(); 2600 void SharedDtor(); 2601 void SetCachedSize(int size) const; 2602 public: 2603 2604 ::google::protobuf::Metadata GetMetadata() const; 2605 2606 // nested types ---------------------------------------------------- 2607 2608 // accessors ------------------------------------------------------- 2609 2610 // repeated int32 path = 1 [packed = true]; 2611 inline int path_size() const; 2612 inline void clear_path(); 2613 static const int kPathFieldNumber = 1; 2614 inline ::google::protobuf::int32 path(int index) const; 2615 inline void set_path(int index, ::google::protobuf::int32 value); 2616 inline void add_path(::google::protobuf::int32 value); 2617 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 2618 path() const; 2619 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 2620 mutable_path(); 2621 2622 // repeated int32 span = 2 [packed = true]; 2623 inline int span_size() const; 2624 inline void clear_span(); 2625 static const int kSpanFieldNumber = 2; 2626 inline ::google::protobuf::int32 span(int index) const; 2627 inline void set_span(int index, ::google::protobuf::int32 value); 2628 inline void add_span(::google::protobuf::int32 value); 2629 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 2630 span() const; 2631 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 2632 mutable_span(); 2633 2634 // optional string leading_comments = 3; 2635 inline bool has_leading_comments() const; 2636 inline void clear_leading_comments(); 2637 static const int kLeadingCommentsFieldNumber = 3; 2638 inline const ::std::string& leading_comments() const; 2639 inline void set_leading_comments(const ::std::string& value); 2640 inline void set_leading_comments(const char* value); 2641 inline void set_leading_comments(const char* value, size_t size); 2642 inline ::std::string* mutable_leading_comments(); 2643 inline ::std::string* release_leading_comments(); 2644 inline void set_allocated_leading_comments(::std::string* leading_comments); 2645 2646 // optional string trailing_comments = 4; 2647 inline bool has_trailing_comments() const; 2648 inline void clear_trailing_comments(); 2649 static const int kTrailingCommentsFieldNumber = 4; 2650 inline const ::std::string& trailing_comments() const; 2651 inline void set_trailing_comments(const ::std::string& value); 2652 inline void set_trailing_comments(const char* value); 2653 inline void set_trailing_comments(const char* value, size_t size); 2654 inline ::std::string* mutable_trailing_comments(); 2655 inline ::std::string* release_trailing_comments(); 2656 inline void set_allocated_trailing_comments(::std::string* trailing_comments); 2657 2658 // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location) 2659 private: 2660 inline void set_has_leading_comments(); 2661 inline void clear_has_leading_comments(); 2662 inline void set_has_trailing_comments(); 2663 inline void clear_has_trailing_comments(); 2664 2665 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2666 2667 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > path_; 2668 mutable int _path_cached_byte_size_; 2669 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > span_; 2670 mutable int _span_cached_byte_size_; 2671 ::std::string* leading_comments_; 2672 ::std::string* trailing_comments_; 2673 2674 mutable int _cached_size_; 2675 ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; 2676 2677 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2678 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2679 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2680 2681 void InitAsDefaultInstance(); 2682 static SourceCodeInfo_Location* default_instance_; 2683}; 2684// ------------------------------------------------------------------- 2685 2686class LIBPROTOBUF_EXPORT SourceCodeInfo : public ::google::protobuf::Message { 2687 public: 2688 SourceCodeInfo(); 2689 virtual ~SourceCodeInfo(); 2690 2691 SourceCodeInfo(const SourceCodeInfo& from); 2692 2693 inline SourceCodeInfo& operator=(const SourceCodeInfo& from) { 2694 CopyFrom(from); 2695 return *this; 2696 } 2697 2698 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2699 return _unknown_fields_; 2700 } 2701 2702 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2703 return &_unknown_fields_; 2704 } 2705 2706 static const ::google::protobuf::Descriptor* descriptor(); 2707 static const SourceCodeInfo& default_instance(); 2708 2709 void Swap(SourceCodeInfo* other); 2710 2711 // implements Message ---------------------------------------------- 2712 2713 SourceCodeInfo* New() const; 2714 void CopyFrom(const ::google::protobuf::Message& from); 2715 void MergeFrom(const ::google::protobuf::Message& from); 2716 void CopyFrom(const SourceCodeInfo& from); 2717 void MergeFrom(const SourceCodeInfo& from); 2718 void Clear(); 2719 bool IsInitialized() const; 2720 2721 int ByteSize() const; 2722 bool MergePartialFromCodedStream( 2723 ::google::protobuf::io::CodedInputStream* input); 2724 void SerializeWithCachedSizes( 2725 ::google::protobuf::io::CodedOutputStream* output) const; 2726 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2727 int GetCachedSize() const { return _cached_size_; } 2728 private: 2729 void SharedCtor(); 2730 void SharedDtor(); 2731 void SetCachedSize(int size) const; 2732 public: 2733 2734 ::google::protobuf::Metadata GetMetadata() const; 2735 2736 // nested types ---------------------------------------------------- 2737 2738 typedef SourceCodeInfo_Location Location; 2739 2740 // accessors ------------------------------------------------------- 2741 2742 // repeated .google.protobuf.SourceCodeInfo.Location location = 1; 2743 inline int location_size() const; 2744 inline void clear_location(); 2745 static const int kLocationFieldNumber = 1; 2746 inline const ::google::protobuf::SourceCodeInfo_Location& location(int index) const; 2747 inline ::google::protobuf::SourceCodeInfo_Location* mutable_location(int index); 2748 inline ::google::protobuf::SourceCodeInfo_Location* add_location(); 2749 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >& 2750 location() const; 2751 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >* 2752 mutable_location(); 2753 2754 // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo) 2755 private: 2756 2757 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2758 2759 ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location > location_; 2760 2761 mutable int _cached_size_; 2762 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2763 2764 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2765 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 2766 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 2767 2768 void InitAsDefaultInstance(); 2769 static SourceCodeInfo* default_instance_; 2770}; 2771// =================================================================== 2772 2773 2774// =================================================================== 2775 2776// FileDescriptorSet 2777 2778// repeated .google.protobuf.FileDescriptorProto file = 1; 2779inline int FileDescriptorSet::file_size() const { 2780 return file_.size(); 2781} 2782inline void FileDescriptorSet::clear_file() { 2783 file_.Clear(); 2784} 2785inline const ::google::protobuf::FileDescriptorProto& FileDescriptorSet::file(int index) const { 2786 return file_.Get(index); 2787} 2788inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) { 2789 return file_.Mutable(index); 2790} 2791inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::add_file() { 2792 return file_.Add(); 2793} 2794inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >& 2795FileDescriptorSet::file() const { 2796 return file_; 2797} 2798inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >* 2799FileDescriptorSet::mutable_file() { 2800 return &file_; 2801} 2802 2803// ------------------------------------------------------------------- 2804 2805// FileDescriptorProto 2806 2807// optional string name = 1; 2808inline bool FileDescriptorProto::has_name() const { 2809 return (_has_bits_[0] & 0x00000001u) != 0; 2810} 2811inline void FileDescriptorProto::set_has_name() { 2812 _has_bits_[0] |= 0x00000001u; 2813} 2814inline void FileDescriptorProto::clear_has_name() { 2815 _has_bits_[0] &= ~0x00000001u; 2816} 2817inline void FileDescriptorProto::clear_name() { 2818 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 2819 name_->clear(); 2820 } 2821 clear_has_name(); 2822} 2823inline const ::std::string& FileDescriptorProto::name() const { 2824 return *name_; 2825} 2826inline void FileDescriptorProto::set_name(const ::std::string& value) { 2827 set_has_name(); 2828 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 2829 name_ = new ::std::string; 2830 } 2831 name_->assign(value); 2832} 2833inline void FileDescriptorProto::set_name(const char* value) { 2834 set_has_name(); 2835 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 2836 name_ = new ::std::string; 2837 } 2838 name_->assign(value); 2839} 2840inline void FileDescriptorProto::set_name(const char* value, size_t size) { 2841 set_has_name(); 2842 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 2843 name_ = new ::std::string; 2844 } 2845 name_->assign(reinterpret_cast<const char*>(value), size); 2846} 2847inline ::std::string* FileDescriptorProto::mutable_name() { 2848 set_has_name(); 2849 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 2850 name_ = new ::std::string; 2851 } 2852 return name_; 2853} 2854inline ::std::string* FileDescriptorProto::release_name() { 2855 clear_has_name(); 2856 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 2857 return NULL; 2858 } else { 2859 ::std::string* temp = name_; 2860 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 2861 return temp; 2862 } 2863} 2864inline void FileDescriptorProto::set_allocated_name(::std::string* name) { 2865 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 2866 delete name_; 2867 } 2868 if (name) { 2869 set_has_name(); 2870 name_ = name; 2871 } else { 2872 clear_has_name(); 2873 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 2874 } 2875} 2876 2877// optional string package = 2; 2878inline bool FileDescriptorProto::has_package() const { 2879 return (_has_bits_[0] & 0x00000002u) != 0; 2880} 2881inline void FileDescriptorProto::set_has_package() { 2882 _has_bits_[0] |= 0x00000002u; 2883} 2884inline void FileDescriptorProto::clear_has_package() { 2885 _has_bits_[0] &= ~0x00000002u; 2886} 2887inline void FileDescriptorProto::clear_package() { 2888 if (package_ != &::google::protobuf::internal::GetEmptyString()) { 2889 package_->clear(); 2890 } 2891 clear_has_package(); 2892} 2893inline const ::std::string& FileDescriptorProto::package() const { 2894 return *package_; 2895} 2896inline void FileDescriptorProto::set_package(const ::std::string& value) { 2897 set_has_package(); 2898 if (package_ == &::google::protobuf::internal::GetEmptyString()) { 2899 package_ = new ::std::string; 2900 } 2901 package_->assign(value); 2902} 2903inline void FileDescriptorProto::set_package(const char* value) { 2904 set_has_package(); 2905 if (package_ == &::google::protobuf::internal::GetEmptyString()) { 2906 package_ = new ::std::string; 2907 } 2908 package_->assign(value); 2909} 2910inline void FileDescriptorProto::set_package(const char* value, size_t size) { 2911 set_has_package(); 2912 if (package_ == &::google::protobuf::internal::GetEmptyString()) { 2913 package_ = new ::std::string; 2914 } 2915 package_->assign(reinterpret_cast<const char*>(value), size); 2916} 2917inline ::std::string* FileDescriptorProto::mutable_package() { 2918 set_has_package(); 2919 if (package_ == &::google::protobuf::internal::GetEmptyString()) { 2920 package_ = new ::std::string; 2921 } 2922 return package_; 2923} 2924inline ::std::string* FileDescriptorProto::release_package() { 2925 clear_has_package(); 2926 if (package_ == &::google::protobuf::internal::GetEmptyString()) { 2927 return NULL; 2928 } else { 2929 ::std::string* temp = package_; 2930 package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 2931 return temp; 2932 } 2933} 2934inline void FileDescriptorProto::set_allocated_package(::std::string* package) { 2935 if (package_ != &::google::protobuf::internal::GetEmptyString()) { 2936 delete package_; 2937 } 2938 if (package) { 2939 set_has_package(); 2940 package_ = package; 2941 } else { 2942 clear_has_package(); 2943 package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 2944 } 2945} 2946 2947// repeated string dependency = 3; 2948inline int FileDescriptorProto::dependency_size() const { 2949 return dependency_.size(); 2950} 2951inline void FileDescriptorProto::clear_dependency() { 2952 dependency_.Clear(); 2953} 2954inline const ::std::string& FileDescriptorProto::dependency(int index) const { 2955 return dependency_.Get(index); 2956} 2957inline ::std::string* FileDescriptorProto::mutable_dependency(int index) { 2958 return dependency_.Mutable(index); 2959} 2960inline void FileDescriptorProto::set_dependency(int index, const ::std::string& value) { 2961 dependency_.Mutable(index)->assign(value); 2962} 2963inline void FileDescriptorProto::set_dependency(int index, const char* value) { 2964 dependency_.Mutable(index)->assign(value); 2965} 2966inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) { 2967 dependency_.Mutable(index)->assign( 2968 reinterpret_cast<const char*>(value), size); 2969} 2970inline ::std::string* FileDescriptorProto::add_dependency() { 2971 return dependency_.Add(); 2972} 2973inline void FileDescriptorProto::add_dependency(const ::std::string& value) { 2974 dependency_.Add()->assign(value); 2975} 2976inline void FileDescriptorProto::add_dependency(const char* value) { 2977 dependency_.Add()->assign(value); 2978} 2979inline void FileDescriptorProto::add_dependency(const char* value, size_t size) { 2980 dependency_.Add()->assign(reinterpret_cast<const char*>(value), size); 2981} 2982inline const ::google::protobuf::RepeatedPtrField< ::std::string>& 2983FileDescriptorProto::dependency() const { 2984 return dependency_; 2985} 2986inline ::google::protobuf::RepeatedPtrField< ::std::string>* 2987FileDescriptorProto::mutable_dependency() { 2988 return &dependency_; 2989} 2990 2991// repeated int32 public_dependency = 10; 2992inline int FileDescriptorProto::public_dependency_size() const { 2993 return public_dependency_.size(); 2994} 2995inline void FileDescriptorProto::clear_public_dependency() { 2996 public_dependency_.Clear(); 2997} 2998inline ::google::protobuf::int32 FileDescriptorProto::public_dependency(int index) const { 2999 return public_dependency_.Get(index); 3000} 3001inline void FileDescriptorProto::set_public_dependency(int index, ::google::protobuf::int32 value) { 3002 public_dependency_.Set(index, value); 3003} 3004inline void FileDescriptorProto::add_public_dependency(::google::protobuf::int32 value) { 3005 public_dependency_.Add(value); 3006} 3007inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 3008FileDescriptorProto::public_dependency() const { 3009 return public_dependency_; 3010} 3011inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 3012FileDescriptorProto::mutable_public_dependency() { 3013 return &public_dependency_; 3014} 3015 3016// repeated int32 weak_dependency = 11; 3017inline int FileDescriptorProto::weak_dependency_size() const { 3018 return weak_dependency_.size(); 3019} 3020inline void FileDescriptorProto::clear_weak_dependency() { 3021 weak_dependency_.Clear(); 3022} 3023inline ::google::protobuf::int32 FileDescriptorProto::weak_dependency(int index) const { 3024 return weak_dependency_.Get(index); 3025} 3026inline void FileDescriptorProto::set_weak_dependency(int index, ::google::protobuf::int32 value) { 3027 weak_dependency_.Set(index, value); 3028} 3029inline void FileDescriptorProto::add_weak_dependency(::google::protobuf::int32 value) { 3030 weak_dependency_.Add(value); 3031} 3032inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 3033FileDescriptorProto::weak_dependency() const { 3034 return weak_dependency_; 3035} 3036inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 3037FileDescriptorProto::mutable_weak_dependency() { 3038 return &weak_dependency_; 3039} 3040 3041// repeated .google.protobuf.DescriptorProto message_type = 4; 3042inline int FileDescriptorProto::message_type_size() const { 3043 return message_type_.size(); 3044} 3045inline void FileDescriptorProto::clear_message_type() { 3046 message_type_.Clear(); 3047} 3048inline const ::google::protobuf::DescriptorProto& FileDescriptorProto::message_type(int index) const { 3049 return message_type_.Get(index); 3050} 3051inline ::google::protobuf::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) { 3052 return message_type_.Mutable(index); 3053} 3054inline ::google::protobuf::DescriptorProto* FileDescriptorProto::add_message_type() { 3055 return message_type_.Add(); 3056} 3057inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 3058FileDescriptorProto::message_type() const { 3059 return message_type_; 3060} 3061inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 3062FileDescriptorProto::mutable_message_type() { 3063 return &message_type_; 3064} 3065 3066// repeated .google.protobuf.EnumDescriptorProto enum_type = 5; 3067inline int FileDescriptorProto::enum_type_size() const { 3068 return enum_type_.size(); 3069} 3070inline void FileDescriptorProto::clear_enum_type() { 3071 enum_type_.Clear(); 3072} 3073inline const ::google::protobuf::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const { 3074 return enum_type_.Get(index); 3075} 3076inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) { 3077 return enum_type_.Mutable(index); 3078} 3079inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::add_enum_type() { 3080 return enum_type_.Add(); 3081} 3082inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 3083FileDescriptorProto::enum_type() const { 3084 return enum_type_; 3085} 3086inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 3087FileDescriptorProto::mutable_enum_type() { 3088 return &enum_type_; 3089} 3090 3091// repeated .google.protobuf.ServiceDescriptorProto service = 6; 3092inline int FileDescriptorProto::service_size() const { 3093 return service_.size(); 3094} 3095inline void FileDescriptorProto::clear_service() { 3096 service_.Clear(); 3097} 3098inline const ::google::protobuf::ServiceDescriptorProto& FileDescriptorProto::service(int index) const { 3099 return service_.Get(index); 3100} 3101inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) { 3102 return service_.Mutable(index); 3103} 3104inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::add_service() { 3105 return service_.Add(); 3106} 3107inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >& 3108FileDescriptorProto::service() const { 3109 return service_; 3110} 3111inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >* 3112FileDescriptorProto::mutable_service() { 3113 return &service_; 3114} 3115 3116// repeated .google.protobuf.FieldDescriptorProto extension = 7; 3117inline int FileDescriptorProto::extension_size() const { 3118 return extension_.size(); 3119} 3120inline void FileDescriptorProto::clear_extension() { 3121 extension_.Clear(); 3122} 3123inline const ::google::protobuf::FieldDescriptorProto& FileDescriptorProto::extension(int index) const { 3124 return extension_.Get(index); 3125} 3126inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) { 3127 return extension_.Mutable(index); 3128} 3129inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::add_extension() { 3130 return extension_.Add(); 3131} 3132inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 3133FileDescriptorProto::extension() const { 3134 return extension_; 3135} 3136inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 3137FileDescriptorProto::mutable_extension() { 3138 return &extension_; 3139} 3140 3141// optional .google.protobuf.FileOptions options = 8; 3142inline bool FileDescriptorProto::has_options() const { 3143 return (_has_bits_[0] & 0x00000200u) != 0; 3144} 3145inline void FileDescriptorProto::set_has_options() { 3146 _has_bits_[0] |= 0x00000200u; 3147} 3148inline void FileDescriptorProto::clear_has_options() { 3149 _has_bits_[0] &= ~0x00000200u; 3150} 3151inline void FileDescriptorProto::clear_options() { 3152 if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear(); 3153 clear_has_options(); 3154} 3155inline const ::google::protobuf::FileOptions& FileDescriptorProto::options() const { 3156 return options_ != NULL ? *options_ : *default_instance_->options_; 3157} 3158inline ::google::protobuf::FileOptions* FileDescriptorProto::mutable_options() { 3159 set_has_options(); 3160 if (options_ == NULL) options_ = new ::google::protobuf::FileOptions; 3161 return options_; 3162} 3163inline ::google::protobuf::FileOptions* FileDescriptorProto::release_options() { 3164 clear_has_options(); 3165 ::google::protobuf::FileOptions* temp = options_; 3166 options_ = NULL; 3167 return temp; 3168} 3169inline void FileDescriptorProto::set_allocated_options(::google::protobuf::FileOptions* options) { 3170 delete options_; 3171 options_ = options; 3172 if (options) { 3173 set_has_options(); 3174 } else { 3175 clear_has_options(); 3176 } 3177} 3178 3179// optional .google.protobuf.SourceCodeInfo source_code_info = 9; 3180inline bool FileDescriptorProto::has_source_code_info() const { 3181 return (_has_bits_[0] & 0x00000400u) != 0; 3182} 3183inline void FileDescriptorProto::set_has_source_code_info() { 3184 _has_bits_[0] |= 0x00000400u; 3185} 3186inline void FileDescriptorProto::clear_has_source_code_info() { 3187 _has_bits_[0] &= ~0x00000400u; 3188} 3189inline void FileDescriptorProto::clear_source_code_info() { 3190 if (source_code_info_ != NULL) source_code_info_->::google::protobuf::SourceCodeInfo::Clear(); 3191 clear_has_source_code_info(); 3192} 3193inline const ::google::protobuf::SourceCodeInfo& FileDescriptorProto::source_code_info() const { 3194 return source_code_info_ != NULL ? *source_code_info_ : *default_instance_->source_code_info_; 3195} 3196inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info() { 3197 set_has_source_code_info(); 3198 if (source_code_info_ == NULL) source_code_info_ = new ::google::protobuf::SourceCodeInfo; 3199 return source_code_info_; 3200} 3201inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::release_source_code_info() { 3202 clear_has_source_code_info(); 3203 ::google::protobuf::SourceCodeInfo* temp = source_code_info_; 3204 source_code_info_ = NULL; 3205 return temp; 3206} 3207inline void FileDescriptorProto::set_allocated_source_code_info(::google::protobuf::SourceCodeInfo* source_code_info) { 3208 delete source_code_info_; 3209 source_code_info_ = source_code_info; 3210 if (source_code_info) { 3211 set_has_source_code_info(); 3212 } else { 3213 clear_has_source_code_info(); 3214 } 3215} 3216 3217// ------------------------------------------------------------------- 3218 3219// DescriptorProto_ExtensionRange 3220 3221// optional int32 start = 1; 3222inline bool DescriptorProto_ExtensionRange::has_start() const { 3223 return (_has_bits_[0] & 0x00000001u) != 0; 3224} 3225inline void DescriptorProto_ExtensionRange::set_has_start() { 3226 _has_bits_[0] |= 0x00000001u; 3227} 3228inline void DescriptorProto_ExtensionRange::clear_has_start() { 3229 _has_bits_[0] &= ~0x00000001u; 3230} 3231inline void DescriptorProto_ExtensionRange::clear_start() { 3232 start_ = 0; 3233 clear_has_start(); 3234} 3235inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::start() const { 3236 return start_; 3237} 3238inline void DescriptorProto_ExtensionRange::set_start(::google::protobuf::int32 value) { 3239 set_has_start(); 3240 start_ = value; 3241} 3242 3243// optional int32 end = 2; 3244inline bool DescriptorProto_ExtensionRange::has_end() const { 3245 return (_has_bits_[0] & 0x00000002u) != 0; 3246} 3247inline void DescriptorProto_ExtensionRange::set_has_end() { 3248 _has_bits_[0] |= 0x00000002u; 3249} 3250inline void DescriptorProto_ExtensionRange::clear_has_end() { 3251 _has_bits_[0] &= ~0x00000002u; 3252} 3253inline void DescriptorProto_ExtensionRange::clear_end() { 3254 end_ = 0; 3255 clear_has_end(); 3256} 3257inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::end() const { 3258 return end_; 3259} 3260inline void DescriptorProto_ExtensionRange::set_end(::google::protobuf::int32 value) { 3261 set_has_end(); 3262 end_ = value; 3263} 3264 3265// ------------------------------------------------------------------- 3266 3267// DescriptorProto 3268 3269// optional string name = 1; 3270inline bool DescriptorProto::has_name() const { 3271 return (_has_bits_[0] & 0x00000001u) != 0; 3272} 3273inline void DescriptorProto::set_has_name() { 3274 _has_bits_[0] |= 0x00000001u; 3275} 3276inline void DescriptorProto::clear_has_name() { 3277 _has_bits_[0] &= ~0x00000001u; 3278} 3279inline void DescriptorProto::clear_name() { 3280 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 3281 name_->clear(); 3282 } 3283 clear_has_name(); 3284} 3285inline const ::std::string& DescriptorProto::name() const { 3286 return *name_; 3287} 3288inline void DescriptorProto::set_name(const ::std::string& value) { 3289 set_has_name(); 3290 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3291 name_ = new ::std::string; 3292 } 3293 name_->assign(value); 3294} 3295inline void DescriptorProto::set_name(const char* value) { 3296 set_has_name(); 3297 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3298 name_ = new ::std::string; 3299 } 3300 name_->assign(value); 3301} 3302inline void DescriptorProto::set_name(const char* value, size_t size) { 3303 set_has_name(); 3304 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3305 name_ = new ::std::string; 3306 } 3307 name_->assign(reinterpret_cast<const char*>(value), size); 3308} 3309inline ::std::string* DescriptorProto::mutable_name() { 3310 set_has_name(); 3311 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3312 name_ = new ::std::string; 3313 } 3314 return name_; 3315} 3316inline ::std::string* DescriptorProto::release_name() { 3317 clear_has_name(); 3318 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3319 return NULL; 3320 } else { 3321 ::std::string* temp = name_; 3322 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3323 return temp; 3324 } 3325} 3326inline void DescriptorProto::set_allocated_name(::std::string* name) { 3327 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 3328 delete name_; 3329 } 3330 if (name) { 3331 set_has_name(); 3332 name_ = name; 3333 } else { 3334 clear_has_name(); 3335 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3336 } 3337} 3338 3339// repeated .google.protobuf.FieldDescriptorProto field = 2; 3340inline int DescriptorProto::field_size() const { 3341 return field_.size(); 3342} 3343inline void DescriptorProto::clear_field() { 3344 field_.Clear(); 3345} 3346inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::field(int index) const { 3347 return field_.Get(index); 3348} 3349inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_field(int index) { 3350 return field_.Mutable(index); 3351} 3352inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_field() { 3353 return field_.Add(); 3354} 3355inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 3356DescriptorProto::field() const { 3357 return field_; 3358} 3359inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 3360DescriptorProto::mutable_field() { 3361 return &field_; 3362} 3363 3364// repeated .google.protobuf.FieldDescriptorProto extension = 6; 3365inline int DescriptorProto::extension_size() const { 3366 return extension_.size(); 3367} 3368inline void DescriptorProto::clear_extension() { 3369 extension_.Clear(); 3370} 3371inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::extension(int index) const { 3372 return extension_.Get(index); 3373} 3374inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) { 3375 return extension_.Mutable(index); 3376} 3377inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_extension() { 3378 return extension_.Add(); 3379} 3380inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 3381DescriptorProto::extension() const { 3382 return extension_; 3383} 3384inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 3385DescriptorProto::mutable_extension() { 3386 return &extension_; 3387} 3388 3389// repeated .google.protobuf.DescriptorProto nested_type = 3; 3390inline int DescriptorProto::nested_type_size() const { 3391 return nested_type_.size(); 3392} 3393inline void DescriptorProto::clear_nested_type() { 3394 nested_type_.Clear(); 3395} 3396inline const ::google::protobuf::DescriptorProto& DescriptorProto::nested_type(int index) const { 3397 return nested_type_.Get(index); 3398} 3399inline ::google::protobuf::DescriptorProto* DescriptorProto::mutable_nested_type(int index) { 3400 return nested_type_.Mutable(index); 3401} 3402inline ::google::protobuf::DescriptorProto* DescriptorProto::add_nested_type() { 3403 return nested_type_.Add(); 3404} 3405inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 3406DescriptorProto::nested_type() const { 3407 return nested_type_; 3408} 3409inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 3410DescriptorProto::mutable_nested_type() { 3411 return &nested_type_; 3412} 3413 3414// repeated .google.protobuf.EnumDescriptorProto enum_type = 4; 3415inline int DescriptorProto::enum_type_size() const { 3416 return enum_type_.size(); 3417} 3418inline void DescriptorProto::clear_enum_type() { 3419 enum_type_.Clear(); 3420} 3421inline const ::google::protobuf::EnumDescriptorProto& DescriptorProto::enum_type(int index) const { 3422 return enum_type_.Get(index); 3423} 3424inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) { 3425 return enum_type_.Mutable(index); 3426} 3427inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::add_enum_type() { 3428 return enum_type_.Add(); 3429} 3430inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 3431DescriptorProto::enum_type() const { 3432 return enum_type_; 3433} 3434inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 3435DescriptorProto::mutable_enum_type() { 3436 return &enum_type_; 3437} 3438 3439// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; 3440inline int DescriptorProto::extension_range_size() const { 3441 return extension_range_.size(); 3442} 3443inline void DescriptorProto::clear_extension_range() { 3444 extension_range_.Clear(); 3445} 3446inline const ::google::protobuf::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const { 3447 return extension_range_.Get(index); 3448} 3449inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) { 3450 return extension_range_.Mutable(index); 3451} 3452inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() { 3453 return extension_range_.Add(); 3454} 3455inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >& 3456DescriptorProto::extension_range() const { 3457 return extension_range_; 3458} 3459inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >* 3460DescriptorProto::mutable_extension_range() { 3461 return &extension_range_; 3462} 3463 3464// optional .google.protobuf.MessageOptions options = 7; 3465inline bool DescriptorProto::has_options() const { 3466 return (_has_bits_[0] & 0x00000040u) != 0; 3467} 3468inline void DescriptorProto::set_has_options() { 3469 _has_bits_[0] |= 0x00000040u; 3470} 3471inline void DescriptorProto::clear_has_options() { 3472 _has_bits_[0] &= ~0x00000040u; 3473} 3474inline void DescriptorProto::clear_options() { 3475 if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear(); 3476 clear_has_options(); 3477} 3478inline const ::google::protobuf::MessageOptions& DescriptorProto::options() const { 3479 return options_ != NULL ? *options_ : *default_instance_->options_; 3480} 3481inline ::google::protobuf::MessageOptions* DescriptorProto::mutable_options() { 3482 set_has_options(); 3483 if (options_ == NULL) options_ = new ::google::protobuf::MessageOptions; 3484 return options_; 3485} 3486inline ::google::protobuf::MessageOptions* DescriptorProto::release_options() { 3487 clear_has_options(); 3488 ::google::protobuf::MessageOptions* temp = options_; 3489 options_ = NULL; 3490 return temp; 3491} 3492inline void DescriptorProto::set_allocated_options(::google::protobuf::MessageOptions* options) { 3493 delete options_; 3494 options_ = options; 3495 if (options) { 3496 set_has_options(); 3497 } else { 3498 clear_has_options(); 3499 } 3500} 3501 3502// ------------------------------------------------------------------- 3503 3504// FieldDescriptorProto 3505 3506// optional string name = 1; 3507inline bool FieldDescriptorProto::has_name() const { 3508 return (_has_bits_[0] & 0x00000001u) != 0; 3509} 3510inline void FieldDescriptorProto::set_has_name() { 3511 _has_bits_[0] |= 0x00000001u; 3512} 3513inline void FieldDescriptorProto::clear_has_name() { 3514 _has_bits_[0] &= ~0x00000001u; 3515} 3516inline void FieldDescriptorProto::clear_name() { 3517 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 3518 name_->clear(); 3519 } 3520 clear_has_name(); 3521} 3522inline const ::std::string& FieldDescriptorProto::name() const { 3523 return *name_; 3524} 3525inline void FieldDescriptorProto::set_name(const ::std::string& value) { 3526 set_has_name(); 3527 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3528 name_ = new ::std::string; 3529 } 3530 name_->assign(value); 3531} 3532inline void FieldDescriptorProto::set_name(const char* value) { 3533 set_has_name(); 3534 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3535 name_ = new ::std::string; 3536 } 3537 name_->assign(value); 3538} 3539inline void FieldDescriptorProto::set_name(const char* value, size_t size) { 3540 set_has_name(); 3541 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3542 name_ = new ::std::string; 3543 } 3544 name_->assign(reinterpret_cast<const char*>(value), size); 3545} 3546inline ::std::string* FieldDescriptorProto::mutable_name() { 3547 set_has_name(); 3548 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3549 name_ = new ::std::string; 3550 } 3551 return name_; 3552} 3553inline ::std::string* FieldDescriptorProto::release_name() { 3554 clear_has_name(); 3555 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3556 return NULL; 3557 } else { 3558 ::std::string* temp = name_; 3559 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3560 return temp; 3561 } 3562} 3563inline void FieldDescriptorProto::set_allocated_name(::std::string* name) { 3564 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 3565 delete name_; 3566 } 3567 if (name) { 3568 set_has_name(); 3569 name_ = name; 3570 } else { 3571 clear_has_name(); 3572 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3573 } 3574} 3575 3576// optional int32 number = 3; 3577inline bool FieldDescriptorProto::has_number() const { 3578 return (_has_bits_[0] & 0x00000002u) != 0; 3579} 3580inline void FieldDescriptorProto::set_has_number() { 3581 _has_bits_[0] |= 0x00000002u; 3582} 3583inline void FieldDescriptorProto::clear_has_number() { 3584 _has_bits_[0] &= ~0x00000002u; 3585} 3586inline void FieldDescriptorProto::clear_number() { 3587 number_ = 0; 3588 clear_has_number(); 3589} 3590inline ::google::protobuf::int32 FieldDescriptorProto::number() const { 3591 return number_; 3592} 3593inline void FieldDescriptorProto::set_number(::google::protobuf::int32 value) { 3594 set_has_number(); 3595 number_ = value; 3596} 3597 3598// optional .google.protobuf.FieldDescriptorProto.Label label = 4; 3599inline bool FieldDescriptorProto::has_label() const { 3600 return (_has_bits_[0] & 0x00000004u) != 0; 3601} 3602inline void FieldDescriptorProto::set_has_label() { 3603 _has_bits_[0] |= 0x00000004u; 3604} 3605inline void FieldDescriptorProto::clear_has_label() { 3606 _has_bits_[0] &= ~0x00000004u; 3607} 3608inline void FieldDescriptorProto::clear_label() { 3609 label_ = 1; 3610 clear_has_label(); 3611} 3612inline ::google::protobuf::FieldDescriptorProto_Label FieldDescriptorProto::label() const { 3613 return static_cast< ::google::protobuf::FieldDescriptorProto_Label >(label_); 3614} 3615inline void FieldDescriptorProto::set_label(::google::protobuf::FieldDescriptorProto_Label value) { 3616 assert(::google::protobuf::FieldDescriptorProto_Label_IsValid(value)); 3617 set_has_label(); 3618 label_ = value; 3619} 3620 3621// optional .google.protobuf.FieldDescriptorProto.Type type = 5; 3622inline bool FieldDescriptorProto::has_type() const { 3623 return (_has_bits_[0] & 0x00000008u) != 0; 3624} 3625inline void FieldDescriptorProto::set_has_type() { 3626 _has_bits_[0] |= 0x00000008u; 3627} 3628inline void FieldDescriptorProto::clear_has_type() { 3629 _has_bits_[0] &= ~0x00000008u; 3630} 3631inline void FieldDescriptorProto::clear_type() { 3632 type_ = 1; 3633 clear_has_type(); 3634} 3635inline ::google::protobuf::FieldDescriptorProto_Type FieldDescriptorProto::type() const { 3636 return static_cast< ::google::protobuf::FieldDescriptorProto_Type >(type_); 3637} 3638inline void FieldDescriptorProto::set_type(::google::protobuf::FieldDescriptorProto_Type value) { 3639 assert(::google::protobuf::FieldDescriptorProto_Type_IsValid(value)); 3640 set_has_type(); 3641 type_ = value; 3642} 3643 3644// optional string type_name = 6; 3645inline bool FieldDescriptorProto::has_type_name() const { 3646 return (_has_bits_[0] & 0x00000010u) != 0; 3647} 3648inline void FieldDescriptorProto::set_has_type_name() { 3649 _has_bits_[0] |= 0x00000010u; 3650} 3651inline void FieldDescriptorProto::clear_has_type_name() { 3652 _has_bits_[0] &= ~0x00000010u; 3653} 3654inline void FieldDescriptorProto::clear_type_name() { 3655 if (type_name_ != &::google::protobuf::internal::GetEmptyString()) { 3656 type_name_->clear(); 3657 } 3658 clear_has_type_name(); 3659} 3660inline const ::std::string& FieldDescriptorProto::type_name() const { 3661 return *type_name_; 3662} 3663inline void FieldDescriptorProto::set_type_name(const ::std::string& value) { 3664 set_has_type_name(); 3665 if (type_name_ == &::google::protobuf::internal::GetEmptyString()) { 3666 type_name_ = new ::std::string; 3667 } 3668 type_name_->assign(value); 3669} 3670inline void FieldDescriptorProto::set_type_name(const char* value) { 3671 set_has_type_name(); 3672 if (type_name_ == &::google::protobuf::internal::GetEmptyString()) { 3673 type_name_ = new ::std::string; 3674 } 3675 type_name_->assign(value); 3676} 3677inline void FieldDescriptorProto::set_type_name(const char* value, size_t size) { 3678 set_has_type_name(); 3679 if (type_name_ == &::google::protobuf::internal::GetEmptyString()) { 3680 type_name_ = new ::std::string; 3681 } 3682 type_name_->assign(reinterpret_cast<const char*>(value), size); 3683} 3684inline ::std::string* FieldDescriptorProto::mutable_type_name() { 3685 set_has_type_name(); 3686 if (type_name_ == &::google::protobuf::internal::GetEmptyString()) { 3687 type_name_ = new ::std::string; 3688 } 3689 return type_name_; 3690} 3691inline ::std::string* FieldDescriptorProto::release_type_name() { 3692 clear_has_type_name(); 3693 if (type_name_ == &::google::protobuf::internal::GetEmptyString()) { 3694 return NULL; 3695 } else { 3696 ::std::string* temp = type_name_; 3697 type_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3698 return temp; 3699 } 3700} 3701inline void FieldDescriptorProto::set_allocated_type_name(::std::string* type_name) { 3702 if (type_name_ != &::google::protobuf::internal::GetEmptyString()) { 3703 delete type_name_; 3704 } 3705 if (type_name) { 3706 set_has_type_name(); 3707 type_name_ = type_name; 3708 } else { 3709 clear_has_type_name(); 3710 type_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3711 } 3712} 3713 3714// optional string extendee = 2; 3715inline bool FieldDescriptorProto::has_extendee() const { 3716 return (_has_bits_[0] & 0x00000020u) != 0; 3717} 3718inline void FieldDescriptorProto::set_has_extendee() { 3719 _has_bits_[0] |= 0x00000020u; 3720} 3721inline void FieldDescriptorProto::clear_has_extendee() { 3722 _has_bits_[0] &= ~0x00000020u; 3723} 3724inline void FieldDescriptorProto::clear_extendee() { 3725 if (extendee_ != &::google::protobuf::internal::GetEmptyString()) { 3726 extendee_->clear(); 3727 } 3728 clear_has_extendee(); 3729} 3730inline const ::std::string& FieldDescriptorProto::extendee() const { 3731 return *extendee_; 3732} 3733inline void FieldDescriptorProto::set_extendee(const ::std::string& value) { 3734 set_has_extendee(); 3735 if (extendee_ == &::google::protobuf::internal::GetEmptyString()) { 3736 extendee_ = new ::std::string; 3737 } 3738 extendee_->assign(value); 3739} 3740inline void FieldDescriptorProto::set_extendee(const char* value) { 3741 set_has_extendee(); 3742 if (extendee_ == &::google::protobuf::internal::GetEmptyString()) { 3743 extendee_ = new ::std::string; 3744 } 3745 extendee_->assign(value); 3746} 3747inline void FieldDescriptorProto::set_extendee(const char* value, size_t size) { 3748 set_has_extendee(); 3749 if (extendee_ == &::google::protobuf::internal::GetEmptyString()) { 3750 extendee_ = new ::std::string; 3751 } 3752 extendee_->assign(reinterpret_cast<const char*>(value), size); 3753} 3754inline ::std::string* FieldDescriptorProto::mutable_extendee() { 3755 set_has_extendee(); 3756 if (extendee_ == &::google::protobuf::internal::GetEmptyString()) { 3757 extendee_ = new ::std::string; 3758 } 3759 return extendee_; 3760} 3761inline ::std::string* FieldDescriptorProto::release_extendee() { 3762 clear_has_extendee(); 3763 if (extendee_ == &::google::protobuf::internal::GetEmptyString()) { 3764 return NULL; 3765 } else { 3766 ::std::string* temp = extendee_; 3767 extendee_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3768 return temp; 3769 } 3770} 3771inline void FieldDescriptorProto::set_allocated_extendee(::std::string* extendee) { 3772 if (extendee_ != &::google::protobuf::internal::GetEmptyString()) { 3773 delete extendee_; 3774 } 3775 if (extendee) { 3776 set_has_extendee(); 3777 extendee_ = extendee; 3778 } else { 3779 clear_has_extendee(); 3780 extendee_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3781 } 3782} 3783 3784// optional string default_value = 7; 3785inline bool FieldDescriptorProto::has_default_value() const { 3786 return (_has_bits_[0] & 0x00000040u) != 0; 3787} 3788inline void FieldDescriptorProto::set_has_default_value() { 3789 _has_bits_[0] |= 0x00000040u; 3790} 3791inline void FieldDescriptorProto::clear_has_default_value() { 3792 _has_bits_[0] &= ~0x00000040u; 3793} 3794inline void FieldDescriptorProto::clear_default_value() { 3795 if (default_value_ != &::google::protobuf::internal::GetEmptyString()) { 3796 default_value_->clear(); 3797 } 3798 clear_has_default_value(); 3799} 3800inline const ::std::string& FieldDescriptorProto::default_value() const { 3801 return *default_value_; 3802} 3803inline void FieldDescriptorProto::set_default_value(const ::std::string& value) { 3804 set_has_default_value(); 3805 if (default_value_ == &::google::protobuf::internal::GetEmptyString()) { 3806 default_value_ = new ::std::string; 3807 } 3808 default_value_->assign(value); 3809} 3810inline void FieldDescriptorProto::set_default_value(const char* value) { 3811 set_has_default_value(); 3812 if (default_value_ == &::google::protobuf::internal::GetEmptyString()) { 3813 default_value_ = new ::std::string; 3814 } 3815 default_value_->assign(value); 3816} 3817inline void FieldDescriptorProto::set_default_value(const char* value, size_t size) { 3818 set_has_default_value(); 3819 if (default_value_ == &::google::protobuf::internal::GetEmptyString()) { 3820 default_value_ = new ::std::string; 3821 } 3822 default_value_->assign(reinterpret_cast<const char*>(value), size); 3823} 3824inline ::std::string* FieldDescriptorProto::mutable_default_value() { 3825 set_has_default_value(); 3826 if (default_value_ == &::google::protobuf::internal::GetEmptyString()) { 3827 default_value_ = new ::std::string; 3828 } 3829 return default_value_; 3830} 3831inline ::std::string* FieldDescriptorProto::release_default_value() { 3832 clear_has_default_value(); 3833 if (default_value_ == &::google::protobuf::internal::GetEmptyString()) { 3834 return NULL; 3835 } else { 3836 ::std::string* temp = default_value_; 3837 default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3838 return temp; 3839 } 3840} 3841inline void FieldDescriptorProto::set_allocated_default_value(::std::string* default_value) { 3842 if (default_value_ != &::google::protobuf::internal::GetEmptyString()) { 3843 delete default_value_; 3844 } 3845 if (default_value) { 3846 set_has_default_value(); 3847 default_value_ = default_value; 3848 } else { 3849 clear_has_default_value(); 3850 default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3851 } 3852} 3853 3854// optional .google.protobuf.FieldOptions options = 8; 3855inline bool FieldDescriptorProto::has_options() const { 3856 return (_has_bits_[0] & 0x00000080u) != 0; 3857} 3858inline void FieldDescriptorProto::set_has_options() { 3859 _has_bits_[0] |= 0x00000080u; 3860} 3861inline void FieldDescriptorProto::clear_has_options() { 3862 _has_bits_[0] &= ~0x00000080u; 3863} 3864inline void FieldDescriptorProto::clear_options() { 3865 if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear(); 3866 clear_has_options(); 3867} 3868inline const ::google::protobuf::FieldOptions& FieldDescriptorProto::options() const { 3869 return options_ != NULL ? *options_ : *default_instance_->options_; 3870} 3871inline ::google::protobuf::FieldOptions* FieldDescriptorProto::mutable_options() { 3872 set_has_options(); 3873 if (options_ == NULL) options_ = new ::google::protobuf::FieldOptions; 3874 return options_; 3875} 3876inline ::google::protobuf::FieldOptions* FieldDescriptorProto::release_options() { 3877 clear_has_options(); 3878 ::google::protobuf::FieldOptions* temp = options_; 3879 options_ = NULL; 3880 return temp; 3881} 3882inline void FieldDescriptorProto::set_allocated_options(::google::protobuf::FieldOptions* options) { 3883 delete options_; 3884 options_ = options; 3885 if (options) { 3886 set_has_options(); 3887 } else { 3888 clear_has_options(); 3889 } 3890} 3891 3892// ------------------------------------------------------------------- 3893 3894// EnumDescriptorProto 3895 3896// optional string name = 1; 3897inline bool EnumDescriptorProto::has_name() const { 3898 return (_has_bits_[0] & 0x00000001u) != 0; 3899} 3900inline void EnumDescriptorProto::set_has_name() { 3901 _has_bits_[0] |= 0x00000001u; 3902} 3903inline void EnumDescriptorProto::clear_has_name() { 3904 _has_bits_[0] &= ~0x00000001u; 3905} 3906inline void EnumDescriptorProto::clear_name() { 3907 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 3908 name_->clear(); 3909 } 3910 clear_has_name(); 3911} 3912inline const ::std::string& EnumDescriptorProto::name() const { 3913 return *name_; 3914} 3915inline void EnumDescriptorProto::set_name(const ::std::string& value) { 3916 set_has_name(); 3917 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3918 name_ = new ::std::string; 3919 } 3920 name_->assign(value); 3921} 3922inline void EnumDescriptorProto::set_name(const char* value) { 3923 set_has_name(); 3924 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3925 name_ = new ::std::string; 3926 } 3927 name_->assign(value); 3928} 3929inline void EnumDescriptorProto::set_name(const char* value, size_t size) { 3930 set_has_name(); 3931 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3932 name_ = new ::std::string; 3933 } 3934 name_->assign(reinterpret_cast<const char*>(value), size); 3935} 3936inline ::std::string* EnumDescriptorProto::mutable_name() { 3937 set_has_name(); 3938 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3939 name_ = new ::std::string; 3940 } 3941 return name_; 3942} 3943inline ::std::string* EnumDescriptorProto::release_name() { 3944 clear_has_name(); 3945 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 3946 return NULL; 3947 } else { 3948 ::std::string* temp = name_; 3949 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3950 return temp; 3951 } 3952} 3953inline void EnumDescriptorProto::set_allocated_name(::std::string* name) { 3954 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 3955 delete name_; 3956 } 3957 if (name) { 3958 set_has_name(); 3959 name_ = name; 3960 } else { 3961 clear_has_name(); 3962 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 3963 } 3964} 3965 3966// repeated .google.protobuf.EnumValueDescriptorProto value = 2; 3967inline int EnumDescriptorProto::value_size() const { 3968 return value_.size(); 3969} 3970inline void EnumDescriptorProto::clear_value() { 3971 value_.Clear(); 3972} 3973inline const ::google::protobuf::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const { 3974 return value_.Get(index); 3975} 3976inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) { 3977 return value_.Mutable(index); 3978} 3979inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::add_value() { 3980 return value_.Add(); 3981} 3982inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >& 3983EnumDescriptorProto::value() const { 3984 return value_; 3985} 3986inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >* 3987EnumDescriptorProto::mutable_value() { 3988 return &value_; 3989} 3990 3991// optional .google.protobuf.EnumOptions options = 3; 3992inline bool EnumDescriptorProto::has_options() const { 3993 return (_has_bits_[0] & 0x00000004u) != 0; 3994} 3995inline void EnumDescriptorProto::set_has_options() { 3996 _has_bits_[0] |= 0x00000004u; 3997} 3998inline void EnumDescriptorProto::clear_has_options() { 3999 _has_bits_[0] &= ~0x00000004u; 4000} 4001inline void EnumDescriptorProto::clear_options() { 4002 if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear(); 4003 clear_has_options(); 4004} 4005inline const ::google::protobuf::EnumOptions& EnumDescriptorProto::options() const { 4006 return options_ != NULL ? *options_ : *default_instance_->options_; 4007} 4008inline ::google::protobuf::EnumOptions* EnumDescriptorProto::mutable_options() { 4009 set_has_options(); 4010 if (options_ == NULL) options_ = new ::google::protobuf::EnumOptions; 4011 return options_; 4012} 4013inline ::google::protobuf::EnumOptions* EnumDescriptorProto::release_options() { 4014 clear_has_options(); 4015 ::google::protobuf::EnumOptions* temp = options_; 4016 options_ = NULL; 4017 return temp; 4018} 4019inline void EnumDescriptorProto::set_allocated_options(::google::protobuf::EnumOptions* options) { 4020 delete options_; 4021 options_ = options; 4022 if (options) { 4023 set_has_options(); 4024 } else { 4025 clear_has_options(); 4026 } 4027} 4028 4029// ------------------------------------------------------------------- 4030 4031// EnumValueDescriptorProto 4032 4033// optional string name = 1; 4034inline bool EnumValueDescriptorProto::has_name() const { 4035 return (_has_bits_[0] & 0x00000001u) != 0; 4036} 4037inline void EnumValueDescriptorProto::set_has_name() { 4038 _has_bits_[0] |= 0x00000001u; 4039} 4040inline void EnumValueDescriptorProto::clear_has_name() { 4041 _has_bits_[0] &= ~0x00000001u; 4042} 4043inline void EnumValueDescriptorProto::clear_name() { 4044 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 4045 name_->clear(); 4046 } 4047 clear_has_name(); 4048} 4049inline const ::std::string& EnumValueDescriptorProto::name() const { 4050 return *name_; 4051} 4052inline void EnumValueDescriptorProto::set_name(const ::std::string& value) { 4053 set_has_name(); 4054 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4055 name_ = new ::std::string; 4056 } 4057 name_->assign(value); 4058} 4059inline void EnumValueDescriptorProto::set_name(const char* value) { 4060 set_has_name(); 4061 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4062 name_ = new ::std::string; 4063 } 4064 name_->assign(value); 4065} 4066inline void EnumValueDescriptorProto::set_name(const char* value, size_t size) { 4067 set_has_name(); 4068 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4069 name_ = new ::std::string; 4070 } 4071 name_->assign(reinterpret_cast<const char*>(value), size); 4072} 4073inline ::std::string* EnumValueDescriptorProto::mutable_name() { 4074 set_has_name(); 4075 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4076 name_ = new ::std::string; 4077 } 4078 return name_; 4079} 4080inline ::std::string* EnumValueDescriptorProto::release_name() { 4081 clear_has_name(); 4082 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4083 return NULL; 4084 } else { 4085 ::std::string* temp = name_; 4086 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4087 return temp; 4088 } 4089} 4090inline void EnumValueDescriptorProto::set_allocated_name(::std::string* name) { 4091 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 4092 delete name_; 4093 } 4094 if (name) { 4095 set_has_name(); 4096 name_ = name; 4097 } else { 4098 clear_has_name(); 4099 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4100 } 4101} 4102 4103// optional int32 number = 2; 4104inline bool EnumValueDescriptorProto::has_number() const { 4105 return (_has_bits_[0] & 0x00000002u) != 0; 4106} 4107inline void EnumValueDescriptorProto::set_has_number() { 4108 _has_bits_[0] |= 0x00000002u; 4109} 4110inline void EnumValueDescriptorProto::clear_has_number() { 4111 _has_bits_[0] &= ~0x00000002u; 4112} 4113inline void EnumValueDescriptorProto::clear_number() { 4114 number_ = 0; 4115 clear_has_number(); 4116} 4117inline ::google::protobuf::int32 EnumValueDescriptorProto::number() const { 4118 return number_; 4119} 4120inline void EnumValueDescriptorProto::set_number(::google::protobuf::int32 value) { 4121 set_has_number(); 4122 number_ = value; 4123} 4124 4125// optional .google.protobuf.EnumValueOptions options = 3; 4126inline bool EnumValueDescriptorProto::has_options() const { 4127 return (_has_bits_[0] & 0x00000004u) != 0; 4128} 4129inline void EnumValueDescriptorProto::set_has_options() { 4130 _has_bits_[0] |= 0x00000004u; 4131} 4132inline void EnumValueDescriptorProto::clear_has_options() { 4133 _has_bits_[0] &= ~0x00000004u; 4134} 4135inline void EnumValueDescriptorProto::clear_options() { 4136 if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear(); 4137 clear_has_options(); 4138} 4139inline const ::google::protobuf::EnumValueOptions& EnumValueDescriptorProto::options() const { 4140 return options_ != NULL ? *options_ : *default_instance_->options_; 4141} 4142inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::mutable_options() { 4143 set_has_options(); 4144 if (options_ == NULL) options_ = new ::google::protobuf::EnumValueOptions; 4145 return options_; 4146} 4147inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::release_options() { 4148 clear_has_options(); 4149 ::google::protobuf::EnumValueOptions* temp = options_; 4150 options_ = NULL; 4151 return temp; 4152} 4153inline void EnumValueDescriptorProto::set_allocated_options(::google::protobuf::EnumValueOptions* options) { 4154 delete options_; 4155 options_ = options; 4156 if (options) { 4157 set_has_options(); 4158 } else { 4159 clear_has_options(); 4160 } 4161} 4162 4163// ------------------------------------------------------------------- 4164 4165// ServiceDescriptorProto 4166 4167// optional string name = 1; 4168inline bool ServiceDescriptorProto::has_name() const { 4169 return (_has_bits_[0] & 0x00000001u) != 0; 4170} 4171inline void ServiceDescriptorProto::set_has_name() { 4172 _has_bits_[0] |= 0x00000001u; 4173} 4174inline void ServiceDescriptorProto::clear_has_name() { 4175 _has_bits_[0] &= ~0x00000001u; 4176} 4177inline void ServiceDescriptorProto::clear_name() { 4178 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 4179 name_->clear(); 4180 } 4181 clear_has_name(); 4182} 4183inline const ::std::string& ServiceDescriptorProto::name() const { 4184 return *name_; 4185} 4186inline void ServiceDescriptorProto::set_name(const ::std::string& value) { 4187 set_has_name(); 4188 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4189 name_ = new ::std::string; 4190 } 4191 name_->assign(value); 4192} 4193inline void ServiceDescriptorProto::set_name(const char* value) { 4194 set_has_name(); 4195 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4196 name_ = new ::std::string; 4197 } 4198 name_->assign(value); 4199} 4200inline void ServiceDescriptorProto::set_name(const char* value, size_t size) { 4201 set_has_name(); 4202 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4203 name_ = new ::std::string; 4204 } 4205 name_->assign(reinterpret_cast<const char*>(value), size); 4206} 4207inline ::std::string* ServiceDescriptorProto::mutable_name() { 4208 set_has_name(); 4209 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4210 name_ = new ::std::string; 4211 } 4212 return name_; 4213} 4214inline ::std::string* ServiceDescriptorProto::release_name() { 4215 clear_has_name(); 4216 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4217 return NULL; 4218 } else { 4219 ::std::string* temp = name_; 4220 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4221 return temp; 4222 } 4223} 4224inline void ServiceDescriptorProto::set_allocated_name(::std::string* name) { 4225 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 4226 delete name_; 4227 } 4228 if (name) { 4229 set_has_name(); 4230 name_ = name; 4231 } else { 4232 clear_has_name(); 4233 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4234 } 4235} 4236 4237// repeated .google.protobuf.MethodDescriptorProto method = 2; 4238inline int ServiceDescriptorProto::method_size() const { 4239 return method_.size(); 4240} 4241inline void ServiceDescriptorProto::clear_method() { 4242 method_.Clear(); 4243} 4244inline const ::google::protobuf::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const { 4245 return method_.Get(index); 4246} 4247inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) { 4248 return method_.Mutable(index); 4249} 4250inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::add_method() { 4251 return method_.Add(); 4252} 4253inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >& 4254ServiceDescriptorProto::method() const { 4255 return method_; 4256} 4257inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >* 4258ServiceDescriptorProto::mutable_method() { 4259 return &method_; 4260} 4261 4262// optional .google.protobuf.ServiceOptions options = 3; 4263inline bool ServiceDescriptorProto::has_options() const { 4264 return (_has_bits_[0] & 0x00000004u) != 0; 4265} 4266inline void ServiceDescriptorProto::set_has_options() { 4267 _has_bits_[0] |= 0x00000004u; 4268} 4269inline void ServiceDescriptorProto::clear_has_options() { 4270 _has_bits_[0] &= ~0x00000004u; 4271} 4272inline void ServiceDescriptorProto::clear_options() { 4273 if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear(); 4274 clear_has_options(); 4275} 4276inline const ::google::protobuf::ServiceOptions& ServiceDescriptorProto::options() const { 4277 return options_ != NULL ? *options_ : *default_instance_->options_; 4278} 4279inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::mutable_options() { 4280 set_has_options(); 4281 if (options_ == NULL) options_ = new ::google::protobuf::ServiceOptions; 4282 return options_; 4283} 4284inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::release_options() { 4285 clear_has_options(); 4286 ::google::protobuf::ServiceOptions* temp = options_; 4287 options_ = NULL; 4288 return temp; 4289} 4290inline void ServiceDescriptorProto::set_allocated_options(::google::protobuf::ServiceOptions* options) { 4291 delete options_; 4292 options_ = options; 4293 if (options) { 4294 set_has_options(); 4295 } else { 4296 clear_has_options(); 4297 } 4298} 4299 4300// ------------------------------------------------------------------- 4301 4302// MethodDescriptorProto 4303 4304// optional string name = 1; 4305inline bool MethodDescriptorProto::has_name() const { 4306 return (_has_bits_[0] & 0x00000001u) != 0; 4307} 4308inline void MethodDescriptorProto::set_has_name() { 4309 _has_bits_[0] |= 0x00000001u; 4310} 4311inline void MethodDescriptorProto::clear_has_name() { 4312 _has_bits_[0] &= ~0x00000001u; 4313} 4314inline void MethodDescriptorProto::clear_name() { 4315 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 4316 name_->clear(); 4317 } 4318 clear_has_name(); 4319} 4320inline const ::std::string& MethodDescriptorProto::name() const { 4321 return *name_; 4322} 4323inline void MethodDescriptorProto::set_name(const ::std::string& value) { 4324 set_has_name(); 4325 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4326 name_ = new ::std::string; 4327 } 4328 name_->assign(value); 4329} 4330inline void MethodDescriptorProto::set_name(const char* value) { 4331 set_has_name(); 4332 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4333 name_ = new ::std::string; 4334 } 4335 name_->assign(value); 4336} 4337inline void MethodDescriptorProto::set_name(const char* value, size_t size) { 4338 set_has_name(); 4339 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4340 name_ = new ::std::string; 4341 } 4342 name_->assign(reinterpret_cast<const char*>(value), size); 4343} 4344inline ::std::string* MethodDescriptorProto::mutable_name() { 4345 set_has_name(); 4346 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4347 name_ = new ::std::string; 4348 } 4349 return name_; 4350} 4351inline ::std::string* MethodDescriptorProto::release_name() { 4352 clear_has_name(); 4353 if (name_ == &::google::protobuf::internal::GetEmptyString()) { 4354 return NULL; 4355 } else { 4356 ::std::string* temp = name_; 4357 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4358 return temp; 4359 } 4360} 4361inline void MethodDescriptorProto::set_allocated_name(::std::string* name) { 4362 if (name_ != &::google::protobuf::internal::GetEmptyString()) { 4363 delete name_; 4364 } 4365 if (name) { 4366 set_has_name(); 4367 name_ = name; 4368 } else { 4369 clear_has_name(); 4370 name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4371 } 4372} 4373 4374// optional string input_type = 2; 4375inline bool MethodDescriptorProto::has_input_type() const { 4376 return (_has_bits_[0] & 0x00000002u) != 0; 4377} 4378inline void MethodDescriptorProto::set_has_input_type() { 4379 _has_bits_[0] |= 0x00000002u; 4380} 4381inline void MethodDescriptorProto::clear_has_input_type() { 4382 _has_bits_[0] &= ~0x00000002u; 4383} 4384inline void MethodDescriptorProto::clear_input_type() { 4385 if (input_type_ != &::google::protobuf::internal::GetEmptyString()) { 4386 input_type_->clear(); 4387 } 4388 clear_has_input_type(); 4389} 4390inline const ::std::string& MethodDescriptorProto::input_type() const { 4391 return *input_type_; 4392} 4393inline void MethodDescriptorProto::set_input_type(const ::std::string& value) { 4394 set_has_input_type(); 4395 if (input_type_ == &::google::protobuf::internal::GetEmptyString()) { 4396 input_type_ = new ::std::string; 4397 } 4398 input_type_->assign(value); 4399} 4400inline void MethodDescriptorProto::set_input_type(const char* value) { 4401 set_has_input_type(); 4402 if (input_type_ == &::google::protobuf::internal::GetEmptyString()) { 4403 input_type_ = new ::std::string; 4404 } 4405 input_type_->assign(value); 4406} 4407inline void MethodDescriptorProto::set_input_type(const char* value, size_t size) { 4408 set_has_input_type(); 4409 if (input_type_ == &::google::protobuf::internal::GetEmptyString()) { 4410 input_type_ = new ::std::string; 4411 } 4412 input_type_->assign(reinterpret_cast<const char*>(value), size); 4413} 4414inline ::std::string* MethodDescriptorProto::mutable_input_type() { 4415 set_has_input_type(); 4416 if (input_type_ == &::google::protobuf::internal::GetEmptyString()) { 4417 input_type_ = new ::std::string; 4418 } 4419 return input_type_; 4420} 4421inline ::std::string* MethodDescriptorProto::release_input_type() { 4422 clear_has_input_type(); 4423 if (input_type_ == &::google::protobuf::internal::GetEmptyString()) { 4424 return NULL; 4425 } else { 4426 ::std::string* temp = input_type_; 4427 input_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4428 return temp; 4429 } 4430} 4431inline void MethodDescriptorProto::set_allocated_input_type(::std::string* input_type) { 4432 if (input_type_ != &::google::protobuf::internal::GetEmptyString()) { 4433 delete input_type_; 4434 } 4435 if (input_type) { 4436 set_has_input_type(); 4437 input_type_ = input_type; 4438 } else { 4439 clear_has_input_type(); 4440 input_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4441 } 4442} 4443 4444// optional string output_type = 3; 4445inline bool MethodDescriptorProto::has_output_type() const { 4446 return (_has_bits_[0] & 0x00000004u) != 0; 4447} 4448inline void MethodDescriptorProto::set_has_output_type() { 4449 _has_bits_[0] |= 0x00000004u; 4450} 4451inline void MethodDescriptorProto::clear_has_output_type() { 4452 _has_bits_[0] &= ~0x00000004u; 4453} 4454inline void MethodDescriptorProto::clear_output_type() { 4455 if (output_type_ != &::google::protobuf::internal::GetEmptyString()) { 4456 output_type_->clear(); 4457 } 4458 clear_has_output_type(); 4459} 4460inline const ::std::string& MethodDescriptorProto::output_type() const { 4461 return *output_type_; 4462} 4463inline void MethodDescriptorProto::set_output_type(const ::std::string& value) { 4464 set_has_output_type(); 4465 if (output_type_ == &::google::protobuf::internal::GetEmptyString()) { 4466 output_type_ = new ::std::string; 4467 } 4468 output_type_->assign(value); 4469} 4470inline void MethodDescriptorProto::set_output_type(const char* value) { 4471 set_has_output_type(); 4472 if (output_type_ == &::google::protobuf::internal::GetEmptyString()) { 4473 output_type_ = new ::std::string; 4474 } 4475 output_type_->assign(value); 4476} 4477inline void MethodDescriptorProto::set_output_type(const char* value, size_t size) { 4478 set_has_output_type(); 4479 if (output_type_ == &::google::protobuf::internal::GetEmptyString()) { 4480 output_type_ = new ::std::string; 4481 } 4482 output_type_->assign(reinterpret_cast<const char*>(value), size); 4483} 4484inline ::std::string* MethodDescriptorProto::mutable_output_type() { 4485 set_has_output_type(); 4486 if (output_type_ == &::google::protobuf::internal::GetEmptyString()) { 4487 output_type_ = new ::std::string; 4488 } 4489 return output_type_; 4490} 4491inline ::std::string* MethodDescriptorProto::release_output_type() { 4492 clear_has_output_type(); 4493 if (output_type_ == &::google::protobuf::internal::GetEmptyString()) { 4494 return NULL; 4495 } else { 4496 ::std::string* temp = output_type_; 4497 output_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4498 return temp; 4499 } 4500} 4501inline void MethodDescriptorProto::set_allocated_output_type(::std::string* output_type) { 4502 if (output_type_ != &::google::protobuf::internal::GetEmptyString()) { 4503 delete output_type_; 4504 } 4505 if (output_type) { 4506 set_has_output_type(); 4507 output_type_ = output_type; 4508 } else { 4509 clear_has_output_type(); 4510 output_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4511 } 4512} 4513 4514// optional .google.protobuf.MethodOptions options = 4; 4515inline bool MethodDescriptorProto::has_options() const { 4516 return (_has_bits_[0] & 0x00000008u) != 0; 4517} 4518inline void MethodDescriptorProto::set_has_options() { 4519 _has_bits_[0] |= 0x00000008u; 4520} 4521inline void MethodDescriptorProto::clear_has_options() { 4522 _has_bits_[0] &= ~0x00000008u; 4523} 4524inline void MethodDescriptorProto::clear_options() { 4525 if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear(); 4526 clear_has_options(); 4527} 4528inline const ::google::protobuf::MethodOptions& MethodDescriptorProto::options() const { 4529 return options_ != NULL ? *options_ : *default_instance_->options_; 4530} 4531inline ::google::protobuf::MethodOptions* MethodDescriptorProto::mutable_options() { 4532 set_has_options(); 4533 if (options_ == NULL) options_ = new ::google::protobuf::MethodOptions; 4534 return options_; 4535} 4536inline ::google::protobuf::MethodOptions* MethodDescriptorProto::release_options() { 4537 clear_has_options(); 4538 ::google::protobuf::MethodOptions* temp = options_; 4539 options_ = NULL; 4540 return temp; 4541} 4542inline void MethodDescriptorProto::set_allocated_options(::google::protobuf::MethodOptions* options) { 4543 delete options_; 4544 options_ = options; 4545 if (options) { 4546 set_has_options(); 4547 } else { 4548 clear_has_options(); 4549 } 4550} 4551 4552// ------------------------------------------------------------------- 4553 4554// FileOptions 4555 4556// optional string java_package = 1; 4557inline bool FileOptions::has_java_package() const { 4558 return (_has_bits_[0] & 0x00000001u) != 0; 4559} 4560inline void FileOptions::set_has_java_package() { 4561 _has_bits_[0] |= 0x00000001u; 4562} 4563inline void FileOptions::clear_has_java_package() { 4564 _has_bits_[0] &= ~0x00000001u; 4565} 4566inline void FileOptions::clear_java_package() { 4567 if (java_package_ != &::google::protobuf::internal::GetEmptyString()) { 4568 java_package_->clear(); 4569 } 4570 clear_has_java_package(); 4571} 4572inline const ::std::string& FileOptions::java_package() const { 4573 return *java_package_; 4574} 4575inline void FileOptions::set_java_package(const ::std::string& value) { 4576 set_has_java_package(); 4577 if (java_package_ == &::google::protobuf::internal::GetEmptyString()) { 4578 java_package_ = new ::std::string; 4579 } 4580 java_package_->assign(value); 4581} 4582inline void FileOptions::set_java_package(const char* value) { 4583 set_has_java_package(); 4584 if (java_package_ == &::google::protobuf::internal::GetEmptyString()) { 4585 java_package_ = new ::std::string; 4586 } 4587 java_package_->assign(value); 4588} 4589inline void FileOptions::set_java_package(const char* value, size_t size) { 4590 set_has_java_package(); 4591 if (java_package_ == &::google::protobuf::internal::GetEmptyString()) { 4592 java_package_ = new ::std::string; 4593 } 4594 java_package_->assign(reinterpret_cast<const char*>(value), size); 4595} 4596inline ::std::string* FileOptions::mutable_java_package() { 4597 set_has_java_package(); 4598 if (java_package_ == &::google::protobuf::internal::GetEmptyString()) { 4599 java_package_ = new ::std::string; 4600 } 4601 return java_package_; 4602} 4603inline ::std::string* FileOptions::release_java_package() { 4604 clear_has_java_package(); 4605 if (java_package_ == &::google::protobuf::internal::GetEmptyString()) { 4606 return NULL; 4607 } else { 4608 ::std::string* temp = java_package_; 4609 java_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4610 return temp; 4611 } 4612} 4613inline void FileOptions::set_allocated_java_package(::std::string* java_package) { 4614 if (java_package_ != &::google::protobuf::internal::GetEmptyString()) { 4615 delete java_package_; 4616 } 4617 if (java_package) { 4618 set_has_java_package(); 4619 java_package_ = java_package; 4620 } else { 4621 clear_has_java_package(); 4622 java_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4623 } 4624} 4625 4626// optional string java_outer_classname = 8; 4627inline bool FileOptions::has_java_outer_classname() const { 4628 return (_has_bits_[0] & 0x00000002u) != 0; 4629} 4630inline void FileOptions::set_has_java_outer_classname() { 4631 _has_bits_[0] |= 0x00000002u; 4632} 4633inline void FileOptions::clear_has_java_outer_classname() { 4634 _has_bits_[0] &= ~0x00000002u; 4635} 4636inline void FileOptions::clear_java_outer_classname() { 4637 if (java_outer_classname_ != &::google::protobuf::internal::GetEmptyString()) { 4638 java_outer_classname_->clear(); 4639 } 4640 clear_has_java_outer_classname(); 4641} 4642inline const ::std::string& FileOptions::java_outer_classname() const { 4643 return *java_outer_classname_; 4644} 4645inline void FileOptions::set_java_outer_classname(const ::std::string& value) { 4646 set_has_java_outer_classname(); 4647 if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) { 4648 java_outer_classname_ = new ::std::string; 4649 } 4650 java_outer_classname_->assign(value); 4651} 4652inline void FileOptions::set_java_outer_classname(const char* value) { 4653 set_has_java_outer_classname(); 4654 if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) { 4655 java_outer_classname_ = new ::std::string; 4656 } 4657 java_outer_classname_->assign(value); 4658} 4659inline void FileOptions::set_java_outer_classname(const char* value, size_t size) { 4660 set_has_java_outer_classname(); 4661 if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) { 4662 java_outer_classname_ = new ::std::string; 4663 } 4664 java_outer_classname_->assign(reinterpret_cast<const char*>(value), size); 4665} 4666inline ::std::string* FileOptions::mutable_java_outer_classname() { 4667 set_has_java_outer_classname(); 4668 if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) { 4669 java_outer_classname_ = new ::std::string; 4670 } 4671 return java_outer_classname_; 4672} 4673inline ::std::string* FileOptions::release_java_outer_classname() { 4674 clear_has_java_outer_classname(); 4675 if (java_outer_classname_ == &::google::protobuf::internal::GetEmptyString()) { 4676 return NULL; 4677 } else { 4678 ::std::string* temp = java_outer_classname_; 4679 java_outer_classname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4680 return temp; 4681 } 4682} 4683inline void FileOptions::set_allocated_java_outer_classname(::std::string* java_outer_classname) { 4684 if (java_outer_classname_ != &::google::protobuf::internal::GetEmptyString()) { 4685 delete java_outer_classname_; 4686 } 4687 if (java_outer_classname) { 4688 set_has_java_outer_classname(); 4689 java_outer_classname_ = java_outer_classname; 4690 } else { 4691 clear_has_java_outer_classname(); 4692 java_outer_classname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4693 } 4694} 4695 4696// optional bool java_multiple_files = 10 [default = false]; 4697inline bool FileOptions::has_java_multiple_files() const { 4698 return (_has_bits_[0] & 0x00000004u) != 0; 4699} 4700inline void FileOptions::set_has_java_multiple_files() { 4701 _has_bits_[0] |= 0x00000004u; 4702} 4703inline void FileOptions::clear_has_java_multiple_files() { 4704 _has_bits_[0] &= ~0x00000004u; 4705} 4706inline void FileOptions::clear_java_multiple_files() { 4707 java_multiple_files_ = false; 4708 clear_has_java_multiple_files(); 4709} 4710inline bool FileOptions::java_multiple_files() const { 4711 return java_multiple_files_; 4712} 4713inline void FileOptions::set_java_multiple_files(bool value) { 4714 set_has_java_multiple_files(); 4715 java_multiple_files_ = value; 4716} 4717 4718// optional bool retain_unknown_fields = 12 [default = false]; 4719inline bool FileOptions::has_retain_unknown_fields() const { 4720 return (_has_bits_[0] & 0x00000008u) != 0; 4721} 4722inline void FileOptions::set_has_retain_unknown_fields() { 4723 _has_bits_[0] |= 0x00000008u; 4724} 4725inline void FileOptions::clear_has_retain_unknown_fields() { 4726 _has_bits_[0] &= ~0x00000008u; 4727} 4728inline void FileOptions::clear_retain_unknown_fields() { 4729 retain_unknown_fields_ = false; 4730 clear_has_retain_unknown_fields(); 4731} 4732inline bool FileOptions::retain_unknown_fields() const { 4733 return retain_unknown_fields_; 4734} 4735inline void FileOptions::set_retain_unknown_fields(bool value) { 4736 set_has_retain_unknown_fields(); 4737 retain_unknown_fields_ = value; 4738} 4739 4740// optional bool java_generate_equals_and_hash = 20 [default = false]; 4741inline bool FileOptions::has_java_generate_equals_and_hash() const { 4742 return (_has_bits_[0] & 0x00000010u) != 0; 4743} 4744inline void FileOptions::set_has_java_generate_equals_and_hash() { 4745 _has_bits_[0] |= 0x00000010u; 4746} 4747inline void FileOptions::clear_has_java_generate_equals_and_hash() { 4748 _has_bits_[0] &= ~0x00000010u; 4749} 4750inline void FileOptions::clear_java_generate_equals_and_hash() { 4751 java_generate_equals_and_hash_ = false; 4752 clear_has_java_generate_equals_and_hash(); 4753} 4754inline bool FileOptions::java_generate_equals_and_hash() const { 4755 return java_generate_equals_and_hash_; 4756} 4757inline void FileOptions::set_java_generate_equals_and_hash(bool value) { 4758 set_has_java_generate_equals_and_hash(); 4759 java_generate_equals_and_hash_ = value; 4760} 4761 4762// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; 4763inline bool FileOptions::has_optimize_for() const { 4764 return (_has_bits_[0] & 0x00000020u) != 0; 4765} 4766inline void FileOptions::set_has_optimize_for() { 4767 _has_bits_[0] |= 0x00000020u; 4768} 4769inline void FileOptions::clear_has_optimize_for() { 4770 _has_bits_[0] &= ~0x00000020u; 4771} 4772inline void FileOptions::clear_optimize_for() { 4773 optimize_for_ = 1; 4774 clear_has_optimize_for(); 4775} 4776inline ::google::protobuf::FileOptions_OptimizeMode FileOptions::optimize_for() const { 4777 return static_cast< ::google::protobuf::FileOptions_OptimizeMode >(optimize_for_); 4778} 4779inline void FileOptions::set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value) { 4780 assert(::google::protobuf::FileOptions_OptimizeMode_IsValid(value)); 4781 set_has_optimize_for(); 4782 optimize_for_ = value; 4783} 4784 4785// optional string go_package = 11; 4786inline bool FileOptions::has_go_package() const { 4787 return (_has_bits_[0] & 0x00000040u) != 0; 4788} 4789inline void FileOptions::set_has_go_package() { 4790 _has_bits_[0] |= 0x00000040u; 4791} 4792inline void FileOptions::clear_has_go_package() { 4793 _has_bits_[0] &= ~0x00000040u; 4794} 4795inline void FileOptions::clear_go_package() { 4796 if (go_package_ != &::google::protobuf::internal::GetEmptyString()) { 4797 go_package_->clear(); 4798 } 4799 clear_has_go_package(); 4800} 4801inline const ::std::string& FileOptions::go_package() const { 4802 return *go_package_; 4803} 4804inline void FileOptions::set_go_package(const ::std::string& value) { 4805 set_has_go_package(); 4806 if (go_package_ == &::google::protobuf::internal::GetEmptyString()) { 4807 go_package_ = new ::std::string; 4808 } 4809 go_package_->assign(value); 4810} 4811inline void FileOptions::set_go_package(const char* value) { 4812 set_has_go_package(); 4813 if (go_package_ == &::google::protobuf::internal::GetEmptyString()) { 4814 go_package_ = new ::std::string; 4815 } 4816 go_package_->assign(value); 4817} 4818inline void FileOptions::set_go_package(const char* value, size_t size) { 4819 set_has_go_package(); 4820 if (go_package_ == &::google::protobuf::internal::GetEmptyString()) { 4821 go_package_ = new ::std::string; 4822 } 4823 go_package_->assign(reinterpret_cast<const char*>(value), size); 4824} 4825inline ::std::string* FileOptions::mutable_go_package() { 4826 set_has_go_package(); 4827 if (go_package_ == &::google::protobuf::internal::GetEmptyString()) { 4828 go_package_ = new ::std::string; 4829 } 4830 return go_package_; 4831} 4832inline ::std::string* FileOptions::release_go_package() { 4833 clear_has_go_package(); 4834 if (go_package_ == &::google::protobuf::internal::GetEmptyString()) { 4835 return NULL; 4836 } else { 4837 ::std::string* temp = go_package_; 4838 go_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4839 return temp; 4840 } 4841} 4842inline void FileOptions::set_allocated_go_package(::std::string* go_package) { 4843 if (go_package_ != &::google::protobuf::internal::GetEmptyString()) { 4844 delete go_package_; 4845 } 4846 if (go_package) { 4847 set_has_go_package(); 4848 go_package_ = go_package; 4849 } else { 4850 clear_has_go_package(); 4851 go_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 4852 } 4853} 4854 4855// optional bool cc_generic_services = 16 [default = false]; 4856inline bool FileOptions::has_cc_generic_services() const { 4857 return (_has_bits_[0] & 0x00000080u) != 0; 4858} 4859inline void FileOptions::set_has_cc_generic_services() { 4860 _has_bits_[0] |= 0x00000080u; 4861} 4862inline void FileOptions::clear_has_cc_generic_services() { 4863 _has_bits_[0] &= ~0x00000080u; 4864} 4865inline void FileOptions::clear_cc_generic_services() { 4866 cc_generic_services_ = false; 4867 clear_has_cc_generic_services(); 4868} 4869inline bool FileOptions::cc_generic_services() const { 4870 return cc_generic_services_; 4871} 4872inline void FileOptions::set_cc_generic_services(bool value) { 4873 set_has_cc_generic_services(); 4874 cc_generic_services_ = value; 4875} 4876 4877// optional bool java_generic_services = 17 [default = false]; 4878inline bool FileOptions::has_java_generic_services() const { 4879 return (_has_bits_[0] & 0x00000100u) != 0; 4880} 4881inline void FileOptions::set_has_java_generic_services() { 4882 _has_bits_[0] |= 0x00000100u; 4883} 4884inline void FileOptions::clear_has_java_generic_services() { 4885 _has_bits_[0] &= ~0x00000100u; 4886} 4887inline void FileOptions::clear_java_generic_services() { 4888 java_generic_services_ = false; 4889 clear_has_java_generic_services(); 4890} 4891inline bool FileOptions::java_generic_services() const { 4892 return java_generic_services_; 4893} 4894inline void FileOptions::set_java_generic_services(bool value) { 4895 set_has_java_generic_services(); 4896 java_generic_services_ = value; 4897} 4898 4899// optional bool py_generic_services = 18 [default = false]; 4900inline bool FileOptions::has_py_generic_services() const { 4901 return (_has_bits_[0] & 0x00000200u) != 0; 4902} 4903inline void FileOptions::set_has_py_generic_services() { 4904 _has_bits_[0] |= 0x00000200u; 4905} 4906inline void FileOptions::clear_has_py_generic_services() { 4907 _has_bits_[0] &= ~0x00000200u; 4908} 4909inline void FileOptions::clear_py_generic_services() { 4910 py_generic_services_ = false; 4911 clear_has_py_generic_services(); 4912} 4913inline bool FileOptions::py_generic_services() const { 4914 return py_generic_services_; 4915} 4916inline void FileOptions::set_py_generic_services(bool value) { 4917 set_has_py_generic_services(); 4918 py_generic_services_ = value; 4919} 4920 4921// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4922inline int FileOptions::uninterpreted_option_size() const { 4923 return uninterpreted_option_.size(); 4924} 4925inline void FileOptions::clear_uninterpreted_option() { 4926 uninterpreted_option_.Clear(); 4927} 4928inline const ::google::protobuf::UninterpretedOption& FileOptions::uninterpreted_option(int index) const { 4929 return uninterpreted_option_.Get(index); 4930} 4931inline ::google::protobuf::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) { 4932 return uninterpreted_option_.Mutable(index); 4933} 4934inline ::google::protobuf::UninterpretedOption* FileOptions::add_uninterpreted_option() { 4935 return uninterpreted_option_.Add(); 4936} 4937inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 4938FileOptions::uninterpreted_option() const { 4939 return uninterpreted_option_; 4940} 4941inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 4942FileOptions::mutable_uninterpreted_option() { 4943 return &uninterpreted_option_; 4944} 4945 4946// ------------------------------------------------------------------- 4947 4948// MessageOptions 4949 4950// optional bool message_set_wire_format = 1 [default = false]; 4951inline bool MessageOptions::has_message_set_wire_format() const { 4952 return (_has_bits_[0] & 0x00000001u) != 0; 4953} 4954inline void MessageOptions::set_has_message_set_wire_format() { 4955 _has_bits_[0] |= 0x00000001u; 4956} 4957inline void MessageOptions::clear_has_message_set_wire_format() { 4958 _has_bits_[0] &= ~0x00000001u; 4959} 4960inline void MessageOptions::clear_message_set_wire_format() { 4961 message_set_wire_format_ = false; 4962 clear_has_message_set_wire_format(); 4963} 4964inline bool MessageOptions::message_set_wire_format() const { 4965 return message_set_wire_format_; 4966} 4967inline void MessageOptions::set_message_set_wire_format(bool value) { 4968 set_has_message_set_wire_format(); 4969 message_set_wire_format_ = value; 4970} 4971 4972// optional bool no_standard_descriptor_accessor = 2 [default = false]; 4973inline bool MessageOptions::has_no_standard_descriptor_accessor() const { 4974 return (_has_bits_[0] & 0x00000002u) != 0; 4975} 4976inline void MessageOptions::set_has_no_standard_descriptor_accessor() { 4977 _has_bits_[0] |= 0x00000002u; 4978} 4979inline void MessageOptions::clear_has_no_standard_descriptor_accessor() { 4980 _has_bits_[0] &= ~0x00000002u; 4981} 4982inline void MessageOptions::clear_no_standard_descriptor_accessor() { 4983 no_standard_descriptor_accessor_ = false; 4984 clear_has_no_standard_descriptor_accessor(); 4985} 4986inline bool MessageOptions::no_standard_descriptor_accessor() const { 4987 return no_standard_descriptor_accessor_; 4988} 4989inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) { 4990 set_has_no_standard_descriptor_accessor(); 4991 no_standard_descriptor_accessor_ = value; 4992} 4993 4994// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 4995inline int MessageOptions::uninterpreted_option_size() const { 4996 return uninterpreted_option_.size(); 4997} 4998inline void MessageOptions::clear_uninterpreted_option() { 4999 uninterpreted_option_.Clear(); 5000} 5001inline const ::google::protobuf::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const { 5002 return uninterpreted_option_.Get(index); 5003} 5004inline ::google::protobuf::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) { 5005 return uninterpreted_option_.Mutable(index); 5006} 5007inline ::google::protobuf::UninterpretedOption* MessageOptions::add_uninterpreted_option() { 5008 return uninterpreted_option_.Add(); 5009} 5010inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 5011MessageOptions::uninterpreted_option() const { 5012 return uninterpreted_option_; 5013} 5014inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 5015MessageOptions::mutable_uninterpreted_option() { 5016 return &uninterpreted_option_; 5017} 5018 5019// ------------------------------------------------------------------- 5020 5021// FieldOptions 5022 5023// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 5024inline bool FieldOptions::has_ctype() const { 5025 return (_has_bits_[0] & 0x00000001u) != 0; 5026} 5027inline void FieldOptions::set_has_ctype() { 5028 _has_bits_[0] |= 0x00000001u; 5029} 5030inline void FieldOptions::clear_has_ctype() { 5031 _has_bits_[0] &= ~0x00000001u; 5032} 5033inline void FieldOptions::clear_ctype() { 5034 ctype_ = 0; 5035 clear_has_ctype(); 5036} 5037inline ::google::protobuf::FieldOptions_CType FieldOptions::ctype() const { 5038 return static_cast< ::google::protobuf::FieldOptions_CType >(ctype_); 5039} 5040inline void FieldOptions::set_ctype(::google::protobuf::FieldOptions_CType value) { 5041 assert(::google::protobuf::FieldOptions_CType_IsValid(value)); 5042 set_has_ctype(); 5043 ctype_ = value; 5044} 5045 5046// optional bool packed = 2; 5047inline bool FieldOptions::has_packed() const { 5048 return (_has_bits_[0] & 0x00000002u) != 0; 5049} 5050inline void FieldOptions::set_has_packed() { 5051 _has_bits_[0] |= 0x00000002u; 5052} 5053inline void FieldOptions::clear_has_packed() { 5054 _has_bits_[0] &= ~0x00000002u; 5055} 5056inline void FieldOptions::clear_packed() { 5057 packed_ = false; 5058 clear_has_packed(); 5059} 5060inline bool FieldOptions::packed() const { 5061 return packed_; 5062} 5063inline void FieldOptions::set_packed(bool value) { 5064 set_has_packed(); 5065 packed_ = value; 5066} 5067 5068// optional bool lazy = 5 [default = false]; 5069inline bool FieldOptions::has_lazy() const { 5070 return (_has_bits_[0] & 0x00000004u) != 0; 5071} 5072inline void FieldOptions::set_has_lazy() { 5073 _has_bits_[0] |= 0x00000004u; 5074} 5075inline void FieldOptions::clear_has_lazy() { 5076 _has_bits_[0] &= ~0x00000004u; 5077} 5078inline void FieldOptions::clear_lazy() { 5079 lazy_ = false; 5080 clear_has_lazy(); 5081} 5082inline bool FieldOptions::lazy() const { 5083 return lazy_; 5084} 5085inline void FieldOptions::set_lazy(bool value) { 5086 set_has_lazy(); 5087 lazy_ = value; 5088} 5089 5090// optional bool deprecated = 3 [default = false]; 5091inline bool FieldOptions::has_deprecated() const { 5092 return (_has_bits_[0] & 0x00000008u) != 0; 5093} 5094inline void FieldOptions::set_has_deprecated() { 5095 _has_bits_[0] |= 0x00000008u; 5096} 5097inline void FieldOptions::clear_has_deprecated() { 5098 _has_bits_[0] &= ~0x00000008u; 5099} 5100inline void FieldOptions::clear_deprecated() { 5101 deprecated_ = false; 5102 clear_has_deprecated(); 5103} 5104inline bool FieldOptions::deprecated() const { 5105 return deprecated_; 5106} 5107inline void FieldOptions::set_deprecated(bool value) { 5108 set_has_deprecated(); 5109 deprecated_ = value; 5110} 5111 5112// optional string experimental_map_key = 9; 5113inline bool FieldOptions::has_experimental_map_key() const { 5114 return (_has_bits_[0] & 0x00000010u) != 0; 5115} 5116inline void FieldOptions::set_has_experimental_map_key() { 5117 _has_bits_[0] |= 0x00000010u; 5118} 5119inline void FieldOptions::clear_has_experimental_map_key() { 5120 _has_bits_[0] &= ~0x00000010u; 5121} 5122inline void FieldOptions::clear_experimental_map_key() { 5123 if (experimental_map_key_ != &::google::protobuf::internal::GetEmptyString()) { 5124 experimental_map_key_->clear(); 5125 } 5126 clear_has_experimental_map_key(); 5127} 5128inline const ::std::string& FieldOptions::experimental_map_key() const { 5129 return *experimental_map_key_; 5130} 5131inline void FieldOptions::set_experimental_map_key(const ::std::string& value) { 5132 set_has_experimental_map_key(); 5133 if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) { 5134 experimental_map_key_ = new ::std::string; 5135 } 5136 experimental_map_key_->assign(value); 5137} 5138inline void FieldOptions::set_experimental_map_key(const char* value) { 5139 set_has_experimental_map_key(); 5140 if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) { 5141 experimental_map_key_ = new ::std::string; 5142 } 5143 experimental_map_key_->assign(value); 5144} 5145inline void FieldOptions::set_experimental_map_key(const char* value, size_t size) { 5146 set_has_experimental_map_key(); 5147 if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) { 5148 experimental_map_key_ = new ::std::string; 5149 } 5150 experimental_map_key_->assign(reinterpret_cast<const char*>(value), size); 5151} 5152inline ::std::string* FieldOptions::mutable_experimental_map_key() { 5153 set_has_experimental_map_key(); 5154 if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) { 5155 experimental_map_key_ = new ::std::string; 5156 } 5157 return experimental_map_key_; 5158} 5159inline ::std::string* FieldOptions::release_experimental_map_key() { 5160 clear_has_experimental_map_key(); 5161 if (experimental_map_key_ == &::google::protobuf::internal::GetEmptyString()) { 5162 return NULL; 5163 } else { 5164 ::std::string* temp = experimental_map_key_; 5165 experimental_map_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5166 return temp; 5167 } 5168} 5169inline void FieldOptions::set_allocated_experimental_map_key(::std::string* experimental_map_key) { 5170 if (experimental_map_key_ != &::google::protobuf::internal::GetEmptyString()) { 5171 delete experimental_map_key_; 5172 } 5173 if (experimental_map_key) { 5174 set_has_experimental_map_key(); 5175 experimental_map_key_ = experimental_map_key; 5176 } else { 5177 clear_has_experimental_map_key(); 5178 experimental_map_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5179 } 5180} 5181 5182// optional bool weak = 10 [default = false]; 5183inline bool FieldOptions::has_weak() const { 5184 return (_has_bits_[0] & 0x00000020u) != 0; 5185} 5186inline void FieldOptions::set_has_weak() { 5187 _has_bits_[0] |= 0x00000020u; 5188} 5189inline void FieldOptions::clear_has_weak() { 5190 _has_bits_[0] &= ~0x00000020u; 5191} 5192inline void FieldOptions::clear_weak() { 5193 weak_ = false; 5194 clear_has_weak(); 5195} 5196inline bool FieldOptions::weak() const { 5197 return weak_; 5198} 5199inline void FieldOptions::set_weak(bool value) { 5200 set_has_weak(); 5201 weak_ = value; 5202} 5203 5204// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 5205inline int FieldOptions::uninterpreted_option_size() const { 5206 return uninterpreted_option_.size(); 5207} 5208inline void FieldOptions::clear_uninterpreted_option() { 5209 uninterpreted_option_.Clear(); 5210} 5211inline const ::google::protobuf::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const { 5212 return uninterpreted_option_.Get(index); 5213} 5214inline ::google::protobuf::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) { 5215 return uninterpreted_option_.Mutable(index); 5216} 5217inline ::google::protobuf::UninterpretedOption* FieldOptions::add_uninterpreted_option() { 5218 return uninterpreted_option_.Add(); 5219} 5220inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 5221FieldOptions::uninterpreted_option() const { 5222 return uninterpreted_option_; 5223} 5224inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 5225FieldOptions::mutable_uninterpreted_option() { 5226 return &uninterpreted_option_; 5227} 5228 5229// ------------------------------------------------------------------- 5230 5231// EnumOptions 5232 5233// optional bool allow_alias = 2 [default = true]; 5234inline bool EnumOptions::has_allow_alias() const { 5235 return (_has_bits_[0] & 0x00000001u) != 0; 5236} 5237inline void EnumOptions::set_has_allow_alias() { 5238 _has_bits_[0] |= 0x00000001u; 5239} 5240inline void EnumOptions::clear_has_allow_alias() { 5241 _has_bits_[0] &= ~0x00000001u; 5242} 5243inline void EnumOptions::clear_allow_alias() { 5244 allow_alias_ = true; 5245 clear_has_allow_alias(); 5246} 5247inline bool EnumOptions::allow_alias() const { 5248 return allow_alias_; 5249} 5250inline void EnumOptions::set_allow_alias(bool value) { 5251 set_has_allow_alias(); 5252 allow_alias_ = value; 5253} 5254 5255// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 5256inline int EnumOptions::uninterpreted_option_size() const { 5257 return uninterpreted_option_.size(); 5258} 5259inline void EnumOptions::clear_uninterpreted_option() { 5260 uninterpreted_option_.Clear(); 5261} 5262inline const ::google::protobuf::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const { 5263 return uninterpreted_option_.Get(index); 5264} 5265inline ::google::protobuf::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) { 5266 return uninterpreted_option_.Mutable(index); 5267} 5268inline ::google::protobuf::UninterpretedOption* EnumOptions::add_uninterpreted_option() { 5269 return uninterpreted_option_.Add(); 5270} 5271inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 5272EnumOptions::uninterpreted_option() const { 5273 return uninterpreted_option_; 5274} 5275inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 5276EnumOptions::mutable_uninterpreted_option() { 5277 return &uninterpreted_option_; 5278} 5279 5280// ------------------------------------------------------------------- 5281 5282// EnumValueOptions 5283 5284// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 5285inline int EnumValueOptions::uninterpreted_option_size() const { 5286 return uninterpreted_option_.size(); 5287} 5288inline void EnumValueOptions::clear_uninterpreted_option() { 5289 uninterpreted_option_.Clear(); 5290} 5291inline const ::google::protobuf::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const { 5292 return uninterpreted_option_.Get(index); 5293} 5294inline ::google::protobuf::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) { 5295 return uninterpreted_option_.Mutable(index); 5296} 5297inline ::google::protobuf::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() { 5298 return uninterpreted_option_.Add(); 5299} 5300inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 5301EnumValueOptions::uninterpreted_option() const { 5302 return uninterpreted_option_; 5303} 5304inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 5305EnumValueOptions::mutable_uninterpreted_option() { 5306 return &uninterpreted_option_; 5307} 5308 5309// ------------------------------------------------------------------- 5310 5311// ServiceOptions 5312 5313// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 5314inline int ServiceOptions::uninterpreted_option_size() const { 5315 return uninterpreted_option_.size(); 5316} 5317inline void ServiceOptions::clear_uninterpreted_option() { 5318 uninterpreted_option_.Clear(); 5319} 5320inline const ::google::protobuf::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const { 5321 return uninterpreted_option_.Get(index); 5322} 5323inline ::google::protobuf::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) { 5324 return uninterpreted_option_.Mutable(index); 5325} 5326inline ::google::protobuf::UninterpretedOption* ServiceOptions::add_uninterpreted_option() { 5327 return uninterpreted_option_.Add(); 5328} 5329inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 5330ServiceOptions::uninterpreted_option() const { 5331 return uninterpreted_option_; 5332} 5333inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 5334ServiceOptions::mutable_uninterpreted_option() { 5335 return &uninterpreted_option_; 5336} 5337 5338// ------------------------------------------------------------------- 5339 5340// MethodOptions 5341 5342// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 5343inline int MethodOptions::uninterpreted_option_size() const { 5344 return uninterpreted_option_.size(); 5345} 5346inline void MethodOptions::clear_uninterpreted_option() { 5347 uninterpreted_option_.Clear(); 5348} 5349inline const ::google::protobuf::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const { 5350 return uninterpreted_option_.Get(index); 5351} 5352inline ::google::protobuf::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) { 5353 return uninterpreted_option_.Mutable(index); 5354} 5355inline ::google::protobuf::UninterpretedOption* MethodOptions::add_uninterpreted_option() { 5356 return uninterpreted_option_.Add(); 5357} 5358inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 5359MethodOptions::uninterpreted_option() const { 5360 return uninterpreted_option_; 5361} 5362inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 5363MethodOptions::mutable_uninterpreted_option() { 5364 return &uninterpreted_option_; 5365} 5366 5367// ------------------------------------------------------------------- 5368 5369// UninterpretedOption_NamePart 5370 5371// required string name_part = 1; 5372inline bool UninterpretedOption_NamePart::has_name_part() const { 5373 return (_has_bits_[0] & 0x00000001u) != 0; 5374} 5375inline void UninterpretedOption_NamePart::set_has_name_part() { 5376 _has_bits_[0] |= 0x00000001u; 5377} 5378inline void UninterpretedOption_NamePart::clear_has_name_part() { 5379 _has_bits_[0] &= ~0x00000001u; 5380} 5381inline void UninterpretedOption_NamePart::clear_name_part() { 5382 if (name_part_ != &::google::protobuf::internal::GetEmptyString()) { 5383 name_part_->clear(); 5384 } 5385 clear_has_name_part(); 5386} 5387inline const ::std::string& UninterpretedOption_NamePart::name_part() const { 5388 return *name_part_; 5389} 5390inline void UninterpretedOption_NamePart::set_name_part(const ::std::string& value) { 5391 set_has_name_part(); 5392 if (name_part_ == &::google::protobuf::internal::GetEmptyString()) { 5393 name_part_ = new ::std::string; 5394 } 5395 name_part_->assign(value); 5396} 5397inline void UninterpretedOption_NamePart::set_name_part(const char* value) { 5398 set_has_name_part(); 5399 if (name_part_ == &::google::protobuf::internal::GetEmptyString()) { 5400 name_part_ = new ::std::string; 5401 } 5402 name_part_->assign(value); 5403} 5404inline void UninterpretedOption_NamePart::set_name_part(const char* value, size_t size) { 5405 set_has_name_part(); 5406 if (name_part_ == &::google::protobuf::internal::GetEmptyString()) { 5407 name_part_ = new ::std::string; 5408 } 5409 name_part_->assign(reinterpret_cast<const char*>(value), size); 5410} 5411inline ::std::string* UninterpretedOption_NamePart::mutable_name_part() { 5412 set_has_name_part(); 5413 if (name_part_ == &::google::protobuf::internal::GetEmptyString()) { 5414 name_part_ = new ::std::string; 5415 } 5416 return name_part_; 5417} 5418inline ::std::string* UninterpretedOption_NamePart::release_name_part() { 5419 clear_has_name_part(); 5420 if (name_part_ == &::google::protobuf::internal::GetEmptyString()) { 5421 return NULL; 5422 } else { 5423 ::std::string* temp = name_part_; 5424 name_part_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5425 return temp; 5426 } 5427} 5428inline void UninterpretedOption_NamePart::set_allocated_name_part(::std::string* name_part) { 5429 if (name_part_ != &::google::protobuf::internal::GetEmptyString()) { 5430 delete name_part_; 5431 } 5432 if (name_part) { 5433 set_has_name_part(); 5434 name_part_ = name_part; 5435 } else { 5436 clear_has_name_part(); 5437 name_part_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5438 } 5439} 5440 5441// required bool is_extension = 2; 5442inline bool UninterpretedOption_NamePart::has_is_extension() const { 5443 return (_has_bits_[0] & 0x00000002u) != 0; 5444} 5445inline void UninterpretedOption_NamePart::set_has_is_extension() { 5446 _has_bits_[0] |= 0x00000002u; 5447} 5448inline void UninterpretedOption_NamePart::clear_has_is_extension() { 5449 _has_bits_[0] &= ~0x00000002u; 5450} 5451inline void UninterpretedOption_NamePart::clear_is_extension() { 5452 is_extension_ = false; 5453 clear_has_is_extension(); 5454} 5455inline bool UninterpretedOption_NamePart::is_extension() const { 5456 return is_extension_; 5457} 5458inline void UninterpretedOption_NamePart::set_is_extension(bool value) { 5459 set_has_is_extension(); 5460 is_extension_ = value; 5461} 5462 5463// ------------------------------------------------------------------- 5464 5465// UninterpretedOption 5466 5467// repeated .google.protobuf.UninterpretedOption.NamePart name = 2; 5468inline int UninterpretedOption::name_size() const { 5469 return name_.size(); 5470} 5471inline void UninterpretedOption::clear_name() { 5472 name_.Clear(); 5473} 5474inline const ::google::protobuf::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const { 5475 return name_.Get(index); 5476} 5477inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) { 5478 return name_.Mutable(index); 5479} 5480inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::add_name() { 5481 return name_.Add(); 5482} 5483inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 5484UninterpretedOption::name() const { 5485 return name_; 5486} 5487inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 5488UninterpretedOption::mutable_name() { 5489 return &name_; 5490} 5491 5492// optional string identifier_value = 3; 5493inline bool UninterpretedOption::has_identifier_value() const { 5494 return (_has_bits_[0] & 0x00000002u) != 0; 5495} 5496inline void UninterpretedOption::set_has_identifier_value() { 5497 _has_bits_[0] |= 0x00000002u; 5498} 5499inline void UninterpretedOption::clear_has_identifier_value() { 5500 _has_bits_[0] &= ~0x00000002u; 5501} 5502inline void UninterpretedOption::clear_identifier_value() { 5503 if (identifier_value_ != &::google::protobuf::internal::GetEmptyString()) { 5504 identifier_value_->clear(); 5505 } 5506 clear_has_identifier_value(); 5507} 5508inline const ::std::string& UninterpretedOption::identifier_value() const { 5509 return *identifier_value_; 5510} 5511inline void UninterpretedOption::set_identifier_value(const ::std::string& value) { 5512 set_has_identifier_value(); 5513 if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) { 5514 identifier_value_ = new ::std::string; 5515 } 5516 identifier_value_->assign(value); 5517} 5518inline void UninterpretedOption::set_identifier_value(const char* value) { 5519 set_has_identifier_value(); 5520 if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) { 5521 identifier_value_ = new ::std::string; 5522 } 5523 identifier_value_->assign(value); 5524} 5525inline void UninterpretedOption::set_identifier_value(const char* value, size_t size) { 5526 set_has_identifier_value(); 5527 if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) { 5528 identifier_value_ = new ::std::string; 5529 } 5530 identifier_value_->assign(reinterpret_cast<const char*>(value), size); 5531} 5532inline ::std::string* UninterpretedOption::mutable_identifier_value() { 5533 set_has_identifier_value(); 5534 if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) { 5535 identifier_value_ = new ::std::string; 5536 } 5537 return identifier_value_; 5538} 5539inline ::std::string* UninterpretedOption::release_identifier_value() { 5540 clear_has_identifier_value(); 5541 if (identifier_value_ == &::google::protobuf::internal::GetEmptyString()) { 5542 return NULL; 5543 } else { 5544 ::std::string* temp = identifier_value_; 5545 identifier_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5546 return temp; 5547 } 5548} 5549inline void UninterpretedOption::set_allocated_identifier_value(::std::string* identifier_value) { 5550 if (identifier_value_ != &::google::protobuf::internal::GetEmptyString()) { 5551 delete identifier_value_; 5552 } 5553 if (identifier_value) { 5554 set_has_identifier_value(); 5555 identifier_value_ = identifier_value; 5556 } else { 5557 clear_has_identifier_value(); 5558 identifier_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5559 } 5560} 5561 5562// optional uint64 positive_int_value = 4; 5563inline bool UninterpretedOption::has_positive_int_value() const { 5564 return (_has_bits_[0] & 0x00000004u) != 0; 5565} 5566inline void UninterpretedOption::set_has_positive_int_value() { 5567 _has_bits_[0] |= 0x00000004u; 5568} 5569inline void UninterpretedOption::clear_has_positive_int_value() { 5570 _has_bits_[0] &= ~0x00000004u; 5571} 5572inline void UninterpretedOption::clear_positive_int_value() { 5573 positive_int_value_ = GOOGLE_ULONGLONG(0); 5574 clear_has_positive_int_value(); 5575} 5576inline ::google::protobuf::uint64 UninterpretedOption::positive_int_value() const { 5577 return positive_int_value_; 5578} 5579inline void UninterpretedOption::set_positive_int_value(::google::protobuf::uint64 value) { 5580 set_has_positive_int_value(); 5581 positive_int_value_ = value; 5582} 5583 5584// optional int64 negative_int_value = 5; 5585inline bool UninterpretedOption::has_negative_int_value() const { 5586 return (_has_bits_[0] & 0x00000008u) != 0; 5587} 5588inline void UninterpretedOption::set_has_negative_int_value() { 5589 _has_bits_[0] |= 0x00000008u; 5590} 5591inline void UninterpretedOption::clear_has_negative_int_value() { 5592 _has_bits_[0] &= ~0x00000008u; 5593} 5594inline void UninterpretedOption::clear_negative_int_value() { 5595 negative_int_value_ = GOOGLE_LONGLONG(0); 5596 clear_has_negative_int_value(); 5597} 5598inline ::google::protobuf::int64 UninterpretedOption::negative_int_value() const { 5599 return negative_int_value_; 5600} 5601inline void UninterpretedOption::set_negative_int_value(::google::protobuf::int64 value) { 5602 set_has_negative_int_value(); 5603 negative_int_value_ = value; 5604} 5605 5606// optional double double_value = 6; 5607inline bool UninterpretedOption::has_double_value() const { 5608 return (_has_bits_[0] & 0x00000010u) != 0; 5609} 5610inline void UninterpretedOption::set_has_double_value() { 5611 _has_bits_[0] |= 0x00000010u; 5612} 5613inline void UninterpretedOption::clear_has_double_value() { 5614 _has_bits_[0] &= ~0x00000010u; 5615} 5616inline void UninterpretedOption::clear_double_value() { 5617 double_value_ = 0; 5618 clear_has_double_value(); 5619} 5620inline double UninterpretedOption::double_value() const { 5621 return double_value_; 5622} 5623inline void UninterpretedOption::set_double_value(double value) { 5624 set_has_double_value(); 5625 double_value_ = value; 5626} 5627 5628// optional bytes string_value = 7; 5629inline bool UninterpretedOption::has_string_value() const { 5630 return (_has_bits_[0] & 0x00000020u) != 0; 5631} 5632inline void UninterpretedOption::set_has_string_value() { 5633 _has_bits_[0] |= 0x00000020u; 5634} 5635inline void UninterpretedOption::clear_has_string_value() { 5636 _has_bits_[0] &= ~0x00000020u; 5637} 5638inline void UninterpretedOption::clear_string_value() { 5639 if (string_value_ != &::google::protobuf::internal::GetEmptyString()) { 5640 string_value_->clear(); 5641 } 5642 clear_has_string_value(); 5643} 5644inline const ::std::string& UninterpretedOption::string_value() const { 5645 return *string_value_; 5646} 5647inline void UninterpretedOption::set_string_value(const ::std::string& value) { 5648 set_has_string_value(); 5649 if (string_value_ == &::google::protobuf::internal::GetEmptyString()) { 5650 string_value_ = new ::std::string; 5651 } 5652 string_value_->assign(value); 5653} 5654inline void UninterpretedOption::set_string_value(const char* value) { 5655 set_has_string_value(); 5656 if (string_value_ == &::google::protobuf::internal::GetEmptyString()) { 5657 string_value_ = new ::std::string; 5658 } 5659 string_value_->assign(value); 5660} 5661inline void UninterpretedOption::set_string_value(const void* value, size_t size) { 5662 set_has_string_value(); 5663 if (string_value_ == &::google::protobuf::internal::GetEmptyString()) { 5664 string_value_ = new ::std::string; 5665 } 5666 string_value_->assign(reinterpret_cast<const char*>(value), size); 5667} 5668inline ::std::string* UninterpretedOption::mutable_string_value() { 5669 set_has_string_value(); 5670 if (string_value_ == &::google::protobuf::internal::GetEmptyString()) { 5671 string_value_ = new ::std::string; 5672 } 5673 return string_value_; 5674} 5675inline ::std::string* UninterpretedOption::release_string_value() { 5676 clear_has_string_value(); 5677 if (string_value_ == &::google::protobuf::internal::GetEmptyString()) { 5678 return NULL; 5679 } else { 5680 ::std::string* temp = string_value_; 5681 string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5682 return temp; 5683 } 5684} 5685inline void UninterpretedOption::set_allocated_string_value(::std::string* string_value) { 5686 if (string_value_ != &::google::protobuf::internal::GetEmptyString()) { 5687 delete string_value_; 5688 } 5689 if (string_value) { 5690 set_has_string_value(); 5691 string_value_ = string_value; 5692 } else { 5693 clear_has_string_value(); 5694 string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5695 } 5696} 5697 5698// optional string aggregate_value = 8; 5699inline bool UninterpretedOption::has_aggregate_value() const { 5700 return (_has_bits_[0] & 0x00000040u) != 0; 5701} 5702inline void UninterpretedOption::set_has_aggregate_value() { 5703 _has_bits_[0] |= 0x00000040u; 5704} 5705inline void UninterpretedOption::clear_has_aggregate_value() { 5706 _has_bits_[0] &= ~0x00000040u; 5707} 5708inline void UninterpretedOption::clear_aggregate_value() { 5709 if (aggregate_value_ != &::google::protobuf::internal::GetEmptyString()) { 5710 aggregate_value_->clear(); 5711 } 5712 clear_has_aggregate_value(); 5713} 5714inline const ::std::string& UninterpretedOption::aggregate_value() const { 5715 return *aggregate_value_; 5716} 5717inline void UninterpretedOption::set_aggregate_value(const ::std::string& value) { 5718 set_has_aggregate_value(); 5719 if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) { 5720 aggregate_value_ = new ::std::string; 5721 } 5722 aggregate_value_->assign(value); 5723} 5724inline void UninterpretedOption::set_aggregate_value(const char* value) { 5725 set_has_aggregate_value(); 5726 if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) { 5727 aggregate_value_ = new ::std::string; 5728 } 5729 aggregate_value_->assign(value); 5730} 5731inline void UninterpretedOption::set_aggregate_value(const char* value, size_t size) { 5732 set_has_aggregate_value(); 5733 if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) { 5734 aggregate_value_ = new ::std::string; 5735 } 5736 aggregate_value_->assign(reinterpret_cast<const char*>(value), size); 5737} 5738inline ::std::string* UninterpretedOption::mutable_aggregate_value() { 5739 set_has_aggregate_value(); 5740 if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) { 5741 aggregate_value_ = new ::std::string; 5742 } 5743 return aggregate_value_; 5744} 5745inline ::std::string* UninterpretedOption::release_aggregate_value() { 5746 clear_has_aggregate_value(); 5747 if (aggregate_value_ == &::google::protobuf::internal::GetEmptyString()) { 5748 return NULL; 5749 } else { 5750 ::std::string* temp = aggregate_value_; 5751 aggregate_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5752 return temp; 5753 } 5754} 5755inline void UninterpretedOption::set_allocated_aggregate_value(::std::string* aggregate_value) { 5756 if (aggregate_value_ != &::google::protobuf::internal::GetEmptyString()) { 5757 delete aggregate_value_; 5758 } 5759 if (aggregate_value) { 5760 set_has_aggregate_value(); 5761 aggregate_value_ = aggregate_value; 5762 } else { 5763 clear_has_aggregate_value(); 5764 aggregate_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5765 } 5766} 5767 5768// ------------------------------------------------------------------- 5769 5770// SourceCodeInfo_Location 5771 5772// repeated int32 path = 1 [packed = true]; 5773inline int SourceCodeInfo_Location::path_size() const { 5774 return path_.size(); 5775} 5776inline void SourceCodeInfo_Location::clear_path() { 5777 path_.Clear(); 5778} 5779inline ::google::protobuf::int32 SourceCodeInfo_Location::path(int index) const { 5780 return path_.Get(index); 5781} 5782inline void SourceCodeInfo_Location::set_path(int index, ::google::protobuf::int32 value) { 5783 path_.Set(index, value); 5784} 5785inline void SourceCodeInfo_Location::add_path(::google::protobuf::int32 value) { 5786 path_.Add(value); 5787} 5788inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 5789SourceCodeInfo_Location::path() const { 5790 return path_; 5791} 5792inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 5793SourceCodeInfo_Location::mutable_path() { 5794 return &path_; 5795} 5796 5797// repeated int32 span = 2 [packed = true]; 5798inline int SourceCodeInfo_Location::span_size() const { 5799 return span_.size(); 5800} 5801inline void SourceCodeInfo_Location::clear_span() { 5802 span_.Clear(); 5803} 5804inline ::google::protobuf::int32 SourceCodeInfo_Location::span(int index) const { 5805 return span_.Get(index); 5806} 5807inline void SourceCodeInfo_Location::set_span(int index, ::google::protobuf::int32 value) { 5808 span_.Set(index, value); 5809} 5810inline void SourceCodeInfo_Location::add_span(::google::protobuf::int32 value) { 5811 span_.Add(value); 5812} 5813inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 5814SourceCodeInfo_Location::span() const { 5815 return span_; 5816} 5817inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 5818SourceCodeInfo_Location::mutable_span() { 5819 return &span_; 5820} 5821 5822// optional string leading_comments = 3; 5823inline bool SourceCodeInfo_Location::has_leading_comments() const { 5824 return (_has_bits_[0] & 0x00000004u) != 0; 5825} 5826inline void SourceCodeInfo_Location::set_has_leading_comments() { 5827 _has_bits_[0] |= 0x00000004u; 5828} 5829inline void SourceCodeInfo_Location::clear_has_leading_comments() { 5830 _has_bits_[0] &= ~0x00000004u; 5831} 5832inline void SourceCodeInfo_Location::clear_leading_comments() { 5833 if (leading_comments_ != &::google::protobuf::internal::GetEmptyString()) { 5834 leading_comments_->clear(); 5835 } 5836 clear_has_leading_comments(); 5837} 5838inline const ::std::string& SourceCodeInfo_Location::leading_comments() const { 5839 return *leading_comments_; 5840} 5841inline void SourceCodeInfo_Location::set_leading_comments(const ::std::string& value) { 5842 set_has_leading_comments(); 5843 if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5844 leading_comments_ = new ::std::string; 5845 } 5846 leading_comments_->assign(value); 5847} 5848inline void SourceCodeInfo_Location::set_leading_comments(const char* value) { 5849 set_has_leading_comments(); 5850 if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5851 leading_comments_ = new ::std::string; 5852 } 5853 leading_comments_->assign(value); 5854} 5855inline void SourceCodeInfo_Location::set_leading_comments(const char* value, size_t size) { 5856 set_has_leading_comments(); 5857 if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5858 leading_comments_ = new ::std::string; 5859 } 5860 leading_comments_->assign(reinterpret_cast<const char*>(value), size); 5861} 5862inline ::std::string* SourceCodeInfo_Location::mutable_leading_comments() { 5863 set_has_leading_comments(); 5864 if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5865 leading_comments_ = new ::std::string; 5866 } 5867 return leading_comments_; 5868} 5869inline ::std::string* SourceCodeInfo_Location::release_leading_comments() { 5870 clear_has_leading_comments(); 5871 if (leading_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5872 return NULL; 5873 } else { 5874 ::std::string* temp = leading_comments_; 5875 leading_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5876 return temp; 5877 } 5878} 5879inline void SourceCodeInfo_Location::set_allocated_leading_comments(::std::string* leading_comments) { 5880 if (leading_comments_ != &::google::protobuf::internal::GetEmptyString()) { 5881 delete leading_comments_; 5882 } 5883 if (leading_comments) { 5884 set_has_leading_comments(); 5885 leading_comments_ = leading_comments; 5886 } else { 5887 clear_has_leading_comments(); 5888 leading_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5889 } 5890} 5891 5892// optional string trailing_comments = 4; 5893inline bool SourceCodeInfo_Location::has_trailing_comments() const { 5894 return (_has_bits_[0] & 0x00000008u) != 0; 5895} 5896inline void SourceCodeInfo_Location::set_has_trailing_comments() { 5897 _has_bits_[0] |= 0x00000008u; 5898} 5899inline void SourceCodeInfo_Location::clear_has_trailing_comments() { 5900 _has_bits_[0] &= ~0x00000008u; 5901} 5902inline void SourceCodeInfo_Location::clear_trailing_comments() { 5903 if (trailing_comments_ != &::google::protobuf::internal::GetEmptyString()) { 5904 trailing_comments_->clear(); 5905 } 5906 clear_has_trailing_comments(); 5907} 5908inline const ::std::string& SourceCodeInfo_Location::trailing_comments() const { 5909 return *trailing_comments_; 5910} 5911inline void SourceCodeInfo_Location::set_trailing_comments(const ::std::string& value) { 5912 set_has_trailing_comments(); 5913 if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5914 trailing_comments_ = new ::std::string; 5915 } 5916 trailing_comments_->assign(value); 5917} 5918inline void SourceCodeInfo_Location::set_trailing_comments(const char* value) { 5919 set_has_trailing_comments(); 5920 if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5921 trailing_comments_ = new ::std::string; 5922 } 5923 trailing_comments_->assign(value); 5924} 5925inline void SourceCodeInfo_Location::set_trailing_comments(const char* value, size_t size) { 5926 set_has_trailing_comments(); 5927 if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5928 trailing_comments_ = new ::std::string; 5929 } 5930 trailing_comments_->assign(reinterpret_cast<const char*>(value), size); 5931} 5932inline ::std::string* SourceCodeInfo_Location::mutable_trailing_comments() { 5933 set_has_trailing_comments(); 5934 if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5935 trailing_comments_ = new ::std::string; 5936 } 5937 return trailing_comments_; 5938} 5939inline ::std::string* SourceCodeInfo_Location::release_trailing_comments() { 5940 clear_has_trailing_comments(); 5941 if (trailing_comments_ == &::google::protobuf::internal::GetEmptyString()) { 5942 return NULL; 5943 } else { 5944 ::std::string* temp = trailing_comments_; 5945 trailing_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5946 return temp; 5947 } 5948} 5949inline void SourceCodeInfo_Location::set_allocated_trailing_comments(::std::string* trailing_comments) { 5950 if (trailing_comments_ != &::google::protobuf::internal::GetEmptyString()) { 5951 delete trailing_comments_; 5952 } 5953 if (trailing_comments) { 5954 set_has_trailing_comments(); 5955 trailing_comments_ = trailing_comments; 5956 } else { 5957 clear_has_trailing_comments(); 5958 trailing_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString()); 5959 } 5960} 5961 5962// ------------------------------------------------------------------- 5963 5964// SourceCodeInfo 5965 5966// repeated .google.protobuf.SourceCodeInfo.Location location = 1; 5967inline int SourceCodeInfo::location_size() const { 5968 return location_.size(); 5969} 5970inline void SourceCodeInfo::clear_location() { 5971 location_.Clear(); 5972} 5973inline const ::google::protobuf::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const { 5974 return location_.Get(index); 5975} 5976inline ::google::protobuf::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index) { 5977 return location_.Mutable(index); 5978} 5979inline ::google::protobuf::SourceCodeInfo_Location* SourceCodeInfo::add_location() { 5980 return location_.Add(); 5981} 5982inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >& 5983SourceCodeInfo::location() const { 5984 return location_; 5985} 5986inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >* 5987SourceCodeInfo::mutable_location() { 5988 return &location_; 5989} 5990 5991 5992// @@protoc_insertion_point(namespace_scope) 5993 5994} // namespace protobuf 5995} // namespace google 5996 5997#ifndef SWIG 5998namespace google { 5999namespace protobuf { 6000 6001template <> 6002inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type>() { 6003 return ::google::protobuf::FieldDescriptorProto_Type_descriptor(); 6004} 6005template <> 6006inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label>() { 6007 return ::google::protobuf::FieldDescriptorProto_Label_descriptor(); 6008} 6009template <> 6010inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode>() { 6011 return ::google::protobuf::FileOptions_OptimizeMode_descriptor(); 6012} 6013template <> 6014inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldOptions_CType>() { 6015 return ::google::protobuf::FieldOptions_CType_descriptor(); 6016} 6017 6018} // namespace google 6019} // namespace protobuf 6020#endif // SWIG 6021 6022// @@protoc_insertion_point(global_scope) 6023 6024#endif // PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED 6025