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