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