|
BWAPI
|
|
BWAPI
|
00001 // Generated by the protocol buffer compiler. DO NOT EDIT! 00002 // source: google/protobuf/descriptor.proto 00003 00004 #ifndef PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED 00005 #define PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED 00006 00007 #include <string> 00008 00009 #include <google/protobuf/stubs/common.h> 00010 00011 #if GOOGLE_PROTOBUF_VERSION < 2003000 00012 #error This file was generated by a newer version of protoc which is 00013 #error incompatible with your Protocol Buffer headers. Please update 00014 #error your headers. 00015 #endif 00016 #if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 00017 #error This file was generated by an older version of protoc which is 00018 #error incompatible with your Protocol Buffer headers. Please 00019 #error regenerate this file with a newer version of protoc. 00020 #endif 00021 00022 #include <google/protobuf/generated_message_util.h> 00023 #include <google/protobuf/repeated_field.h> 00024 #include <google/protobuf/extension_set.h> 00025 #include <google/protobuf/generated_message_reflection.h> 00026 // @@protoc_insertion_point(includes) 00027 00028 namespace google { 00029 namespace protobuf { 00030 00031 // Internal implementation detail -- do not call these. 00032 void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00033 void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00034 void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 00035 00036 class FileDescriptorSet; 00037 class FileDescriptorProto; 00038 class DescriptorProto; 00039 class DescriptorProto_ExtensionRange; 00040 class FieldDescriptorProto; 00041 class EnumDescriptorProto; 00042 class EnumValueDescriptorProto; 00043 class ServiceDescriptorProto; 00044 class MethodDescriptorProto; 00045 class FileOptions; 00046 class MessageOptions; 00047 class FieldOptions; 00048 class EnumOptions; 00049 class EnumValueOptions; 00050 class ServiceOptions; 00051 class MethodOptions; 00052 class UninterpretedOption; 00053 class UninterpretedOption_NamePart; 00054 00055 enum FieldDescriptorProto_Type { 00056 FieldDescriptorProto_Type_TYPE_DOUBLE = 1, 00057 FieldDescriptorProto_Type_TYPE_FLOAT = 2, 00058 FieldDescriptorProto_Type_TYPE_INT64 = 3, 00059 FieldDescriptorProto_Type_TYPE_UINT64 = 4, 00060 FieldDescriptorProto_Type_TYPE_INT32 = 5, 00061 FieldDescriptorProto_Type_TYPE_FIXED64 = 6, 00062 FieldDescriptorProto_Type_TYPE_FIXED32 = 7, 00063 FieldDescriptorProto_Type_TYPE_BOOL = 8, 00064 FieldDescriptorProto_Type_TYPE_STRING = 9, 00065 FieldDescriptorProto_Type_TYPE_GROUP = 10, 00066 FieldDescriptorProto_Type_TYPE_MESSAGE = 11, 00067 FieldDescriptorProto_Type_TYPE_BYTES = 12, 00068 FieldDescriptorProto_Type_TYPE_UINT32 = 13, 00069 FieldDescriptorProto_Type_TYPE_ENUM = 14, 00070 FieldDescriptorProto_Type_TYPE_SFIXED32 = 15, 00071 FieldDescriptorProto_Type_TYPE_SFIXED64 = 16, 00072 FieldDescriptorProto_Type_TYPE_SINT32 = 17, 00073 FieldDescriptorProto_Type_TYPE_SINT64 = 18 00074 }; 00075 LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value); 00076 const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE; 00077 const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64; 00078 const int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1; 00079 00080 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor(); 00081 inline const ::std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) { 00082 return ::google::protobuf::internal::NameOfEnum( 00083 FieldDescriptorProto_Type_descriptor(), value); 00084 } 00085 inline bool FieldDescriptorProto_Type_Parse( 00086 const ::std::string& name, FieldDescriptorProto_Type* value) { 00087 return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Type>( 00088 FieldDescriptorProto_Type_descriptor(), name, value); 00089 } 00090 enum FieldDescriptorProto_Label { 00091 FieldDescriptorProto_Label_LABEL_OPTIONAL = 1, 00092 FieldDescriptorProto_Label_LABEL_REQUIRED = 2, 00093 FieldDescriptorProto_Label_LABEL_REPEATED = 3 00094 }; 00095 LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value); 00096 const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL; 00097 const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED; 00098 const int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1; 00099 00100 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor(); 00101 inline const ::std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) { 00102 return ::google::protobuf::internal::NameOfEnum( 00103 FieldDescriptorProto_Label_descriptor(), value); 00104 } 00105 inline bool FieldDescriptorProto_Label_Parse( 00106 const ::std::string& name, FieldDescriptorProto_Label* value) { 00107 return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Label>( 00108 FieldDescriptorProto_Label_descriptor(), name, value); 00109 } 00110 enum FileOptions_OptimizeMode { 00111 FileOptions_OptimizeMode_SPEED = 1, 00112 FileOptions_OptimizeMode_CODE_SIZE = 2, 00113 FileOptions_OptimizeMode_LITE_RUNTIME = 3 00114 }; 00115 LIBPROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value); 00116 const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED; 00117 const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME; 00118 const int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1; 00119 00120 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor(); 00121 inline const ::std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) { 00122 return ::google::protobuf::internal::NameOfEnum( 00123 FileOptions_OptimizeMode_descriptor(), value); 00124 } 00125 inline bool FileOptions_OptimizeMode_Parse( 00126 const ::std::string& name, FileOptions_OptimizeMode* value) { 00127 return ::google::protobuf::internal::ParseNamedEnum<FileOptions_OptimizeMode>( 00128 FileOptions_OptimizeMode_descriptor(), name, value); 00129 } 00130 enum FieldOptions_CType { 00131 FieldOptions_CType_STRING = 0, 00132 FieldOptions_CType_CORD = 1, 00133 FieldOptions_CType_STRING_PIECE = 2 00134 }; 00135 LIBPROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value); 00136 const FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING; 00137 const FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE; 00138 const int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1; 00139 00140 LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor(); 00141 inline const ::std::string& FieldOptions_CType_Name(FieldOptions_CType value) { 00142 return ::google::protobuf::internal::NameOfEnum( 00143 FieldOptions_CType_descriptor(), value); 00144 } 00145 inline bool FieldOptions_CType_Parse( 00146 const ::std::string& name, FieldOptions_CType* value) { 00147 return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_CType>( 00148 FieldOptions_CType_descriptor(), name, value); 00149 } 00150 // =================================================================== 00151 00152 class LIBPROTOBUF_EXPORT FileDescriptorSet : public ::google::protobuf::Message { 00153 public: 00154 FileDescriptorSet(); 00155 virtual ~FileDescriptorSet(); 00156 00157 FileDescriptorSet(const FileDescriptorSet& from); 00158 00159 inline FileDescriptorSet& operator=(const FileDescriptorSet& from) { 00160 CopyFrom(from); 00161 return *this; 00162 } 00163 00164 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 00165 return _unknown_fields_; 00166 } 00167 00168 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 00169 return &_unknown_fields_; 00170 } 00171 00172 static const ::google::protobuf::Descriptor* descriptor(); 00173 static const FileDescriptorSet& default_instance(); 00174 00175 void Swap(FileDescriptorSet* other); 00176 00177 // implements Message ---------------------------------------------- 00178 00179 FileDescriptorSet* New() const; 00180 void CopyFrom(const ::google::protobuf::Message& from); 00181 void MergeFrom(const ::google::protobuf::Message& from); 00182 void CopyFrom(const FileDescriptorSet& from); 00183 void MergeFrom(const FileDescriptorSet& from); 00184 void Clear(); 00185 bool IsInitialized() const; 00186 00187 int ByteSize() const; 00188 bool MergePartialFromCodedStream( 00189 ::google::protobuf::io::CodedInputStream* input); 00190 void SerializeWithCachedSizes( 00191 ::google::protobuf::io::CodedOutputStream* output) const; 00192 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 00193 int GetCachedSize() const { return _cached_size_; } 00194 private: 00195 void SharedCtor(); 00196 void SharedDtor(); 00197 void SetCachedSize(int size) const; 00198 public: 00199 00200 ::google::protobuf::Metadata GetMetadata() const; 00201 00202 // nested types ---------------------------------------------------- 00203 00204 // accessors ------------------------------------------------------- 00205 00206 // repeated .google.protobuf.FileDescriptorProto file = 1; 00207 inline int file_size() const; 00208 inline void clear_file(); 00209 static const int kFileFieldNumber = 1; 00210 inline const ::google::protobuf::FileDescriptorProto& file(int index) const; 00211 inline ::google::protobuf::FileDescriptorProto* mutable_file(int index); 00212 inline ::google::protobuf::FileDescriptorProto* add_file(); 00213 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >& 00214 file() const; 00215 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >* 00216 mutable_file(); 00217 00218 // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet) 00219 private: 00220 ::google::protobuf::UnknownFieldSet _unknown_fields_; 00221 mutable int _cached_size_; 00222 00223 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > file_; 00224 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00225 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00226 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 00227 00228 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 00229 00230 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 00231 inline bool _has_bit(int index) const { 00232 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 00233 } 00234 inline void _set_bit(int index) { 00235 _has_bits_[index / 32] |= (1u << (index % 32)); 00236 } 00237 inline void _clear_bit(int index) { 00238 _has_bits_[index / 32] &= ~(1u << (index % 32)); 00239 } 00240 00241 void InitAsDefaultInstance(); 00242 static FileDescriptorSet* default_instance_; 00243 }; 00244 // ------------------------------------------------------------------- 00245 00246 class LIBPROTOBUF_EXPORT FileDescriptorProto : public ::google::protobuf::Message { 00247 public: 00248 FileDescriptorProto(); 00249 virtual ~FileDescriptorProto(); 00250 00251 FileDescriptorProto(const FileDescriptorProto& from); 00252 00253 inline FileDescriptorProto& operator=(const FileDescriptorProto& from) { 00254 CopyFrom(from); 00255 return *this; 00256 } 00257 00258 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 00259 return _unknown_fields_; 00260 } 00261 00262 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 00263 return &_unknown_fields_; 00264 } 00265 00266 static const ::google::protobuf::Descriptor* descriptor(); 00267 static const FileDescriptorProto& default_instance(); 00268 00269 void Swap(FileDescriptorProto* other); 00270 00271 // implements Message ---------------------------------------------- 00272 00273 FileDescriptorProto* New() const; 00274 void CopyFrom(const ::google::protobuf::Message& from); 00275 void MergeFrom(const ::google::protobuf::Message& from); 00276 void CopyFrom(const FileDescriptorProto& from); 00277 void MergeFrom(const FileDescriptorProto& from); 00278 void Clear(); 00279 bool IsInitialized() const; 00280 00281 int ByteSize() const; 00282 bool MergePartialFromCodedStream( 00283 ::google::protobuf::io::CodedInputStream* input); 00284 void SerializeWithCachedSizes( 00285 ::google::protobuf::io::CodedOutputStream* output) const; 00286 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 00287 int GetCachedSize() const { return _cached_size_; } 00288 private: 00289 void SharedCtor(); 00290 void SharedDtor(); 00291 void SetCachedSize(int size) const; 00292 public: 00293 00294 ::google::protobuf::Metadata GetMetadata() const; 00295 00296 // nested types ---------------------------------------------------- 00297 00298 // accessors ------------------------------------------------------- 00299 00300 // optional string name = 1; 00301 inline bool has_name() const; 00302 inline void clear_name(); 00303 static const int kNameFieldNumber = 1; 00304 inline const ::std::string& name() const; 00305 inline void set_name(const ::std::string& value); 00306 inline void set_name(const char* value); 00307 inline void set_name(const char* value, size_t size); 00308 inline ::std::string* mutable_name(); 00309 00310 // optional string package = 2; 00311 inline bool has_package() const; 00312 inline void clear_package(); 00313 static const int kPackageFieldNumber = 2; 00314 inline const ::std::string& package() const; 00315 inline void set_package(const ::std::string& value); 00316 inline void set_package(const char* value); 00317 inline void set_package(const char* value, size_t size); 00318 inline ::std::string* mutable_package(); 00319 00320 // repeated string dependency = 3; 00321 inline int dependency_size() const; 00322 inline void clear_dependency(); 00323 static const int kDependencyFieldNumber = 3; 00324 inline const ::std::string& dependency(int index) const; 00325 inline ::std::string* mutable_dependency(int index); 00326 inline void set_dependency(int index, const ::std::string& value); 00327 inline void set_dependency(int index, const char* value); 00328 inline void set_dependency(int index, const char* value, size_t size); 00329 inline ::std::string* add_dependency(); 00330 inline void add_dependency(const ::std::string& value); 00331 inline void add_dependency(const char* value); 00332 inline void add_dependency(const char* value, size_t size); 00333 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& dependency() const; 00334 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_dependency(); 00335 00336 // repeated .google.protobuf.DescriptorProto message_type = 4; 00337 inline int message_type_size() const; 00338 inline void clear_message_type(); 00339 static const int kMessageTypeFieldNumber = 4; 00340 inline const ::google::protobuf::DescriptorProto& message_type(int index) const; 00341 inline ::google::protobuf::DescriptorProto* mutable_message_type(int index); 00342 inline ::google::protobuf::DescriptorProto* add_message_type(); 00343 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 00344 message_type() const; 00345 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 00346 mutable_message_type(); 00347 00348 // repeated .google.protobuf.EnumDescriptorProto enum_type = 5; 00349 inline int enum_type_size() const; 00350 inline void clear_enum_type(); 00351 static const int kEnumTypeFieldNumber = 5; 00352 inline const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const; 00353 inline ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index); 00354 inline ::google::protobuf::EnumDescriptorProto* add_enum_type(); 00355 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 00356 enum_type() const; 00357 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 00358 mutable_enum_type(); 00359 00360 // repeated .google.protobuf.ServiceDescriptorProto service = 6; 00361 inline int service_size() const; 00362 inline void clear_service(); 00363 static const int kServiceFieldNumber = 6; 00364 inline const ::google::protobuf::ServiceDescriptorProto& service(int index) const; 00365 inline ::google::protobuf::ServiceDescriptorProto* mutable_service(int index); 00366 inline ::google::protobuf::ServiceDescriptorProto* add_service(); 00367 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >& 00368 service() const; 00369 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >* 00370 mutable_service(); 00371 00372 // repeated .google.protobuf.FieldDescriptorProto extension = 7; 00373 inline int extension_size() const; 00374 inline void clear_extension(); 00375 static const int kExtensionFieldNumber = 7; 00376 inline const ::google::protobuf::FieldDescriptorProto& extension(int index) const; 00377 inline ::google::protobuf::FieldDescriptorProto* mutable_extension(int index); 00378 inline ::google::protobuf::FieldDescriptorProto* add_extension(); 00379 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 00380 extension() const; 00381 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 00382 mutable_extension(); 00383 00384 // optional .google.protobuf.FileOptions options = 8; 00385 inline bool has_options() const; 00386 inline void clear_options(); 00387 static const int kOptionsFieldNumber = 8; 00388 inline const ::google::protobuf::FileOptions& options() const; 00389 inline ::google::protobuf::FileOptions* mutable_options(); 00390 00391 // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto) 00392 private: 00393 ::google::protobuf::UnknownFieldSet _unknown_fields_; 00394 mutable int _cached_size_; 00395 00396 ::std::string* name_; 00397 static const ::std::string _default_name_; 00398 ::std::string* package_; 00399 static const ::std::string _default_package_; 00400 ::google::protobuf::RepeatedPtrField< ::std::string> dependency_; 00401 ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > message_type_; 00402 ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_; 00403 ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto > service_; 00404 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_; 00405 ::google::protobuf::FileOptions* options_; 00406 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00407 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00408 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 00409 00410 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 00411 00412 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 00413 inline bool _has_bit(int index) const { 00414 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 00415 } 00416 inline void _set_bit(int index) { 00417 _has_bits_[index / 32] |= (1u << (index % 32)); 00418 } 00419 inline void _clear_bit(int index) { 00420 _has_bits_[index / 32] &= ~(1u << (index % 32)); 00421 } 00422 00423 void InitAsDefaultInstance(); 00424 static FileDescriptorProto* default_instance_; 00425 }; 00426 // ------------------------------------------------------------------- 00427 00428 class LIBPROTOBUF_EXPORT DescriptorProto_ExtensionRange : public ::google::protobuf::Message { 00429 public: 00430 DescriptorProto_ExtensionRange(); 00431 virtual ~DescriptorProto_ExtensionRange(); 00432 00433 DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from); 00434 00435 inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) { 00436 CopyFrom(from); 00437 return *this; 00438 } 00439 00440 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 00441 return _unknown_fields_; 00442 } 00443 00444 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 00445 return &_unknown_fields_; 00446 } 00447 00448 static const ::google::protobuf::Descriptor* descriptor(); 00449 static const DescriptorProto_ExtensionRange& default_instance(); 00450 00451 void Swap(DescriptorProto_ExtensionRange* other); 00452 00453 // implements Message ---------------------------------------------- 00454 00455 DescriptorProto_ExtensionRange* New() const; 00456 void CopyFrom(const ::google::protobuf::Message& from); 00457 void MergeFrom(const ::google::protobuf::Message& from); 00458 void CopyFrom(const DescriptorProto_ExtensionRange& from); 00459 void MergeFrom(const DescriptorProto_ExtensionRange& from); 00460 void Clear(); 00461 bool IsInitialized() const; 00462 00463 int ByteSize() const; 00464 bool MergePartialFromCodedStream( 00465 ::google::protobuf::io::CodedInputStream* input); 00466 void SerializeWithCachedSizes( 00467 ::google::protobuf::io::CodedOutputStream* output) const; 00468 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 00469 int GetCachedSize() const { return _cached_size_; } 00470 private: 00471 void SharedCtor(); 00472 void SharedDtor(); 00473 void SetCachedSize(int size) const; 00474 public: 00475 00476 ::google::protobuf::Metadata GetMetadata() const; 00477 00478 // nested types ---------------------------------------------------- 00479 00480 // accessors ------------------------------------------------------- 00481 00482 // optional int32 start = 1; 00483 inline bool has_start() const; 00484 inline void clear_start(); 00485 static const int kStartFieldNumber = 1; 00486 inline ::google::protobuf::int32 start() const; 00487 inline void set_start(::google::protobuf::int32 value); 00488 00489 // optional int32 end = 2; 00490 inline bool has_end() const; 00491 inline void clear_end(); 00492 static const int kEndFieldNumber = 2; 00493 inline ::google::protobuf::int32 end() const; 00494 inline void set_end(::google::protobuf::int32 value); 00495 00496 // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange) 00497 private: 00498 ::google::protobuf::UnknownFieldSet _unknown_fields_; 00499 mutable int _cached_size_; 00500 00501 ::google::protobuf::int32 start_; 00502 ::google::protobuf::int32 end_; 00503 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00504 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00505 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 00506 00507 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 00508 00509 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 00510 inline bool _has_bit(int index) const { 00511 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 00512 } 00513 inline void _set_bit(int index) { 00514 _has_bits_[index / 32] |= (1u << (index % 32)); 00515 } 00516 inline void _clear_bit(int index) { 00517 _has_bits_[index / 32] &= ~(1u << (index % 32)); 00518 } 00519 00520 void InitAsDefaultInstance(); 00521 static DescriptorProto_ExtensionRange* default_instance_; 00522 }; 00523 // ------------------------------------------------------------------- 00524 00525 class LIBPROTOBUF_EXPORT DescriptorProto : public ::google::protobuf::Message { 00526 public: 00527 DescriptorProto(); 00528 virtual ~DescriptorProto(); 00529 00530 DescriptorProto(const DescriptorProto& from); 00531 00532 inline DescriptorProto& operator=(const DescriptorProto& from) { 00533 CopyFrom(from); 00534 return *this; 00535 } 00536 00537 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 00538 return _unknown_fields_; 00539 } 00540 00541 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 00542 return &_unknown_fields_; 00543 } 00544 00545 static const ::google::protobuf::Descriptor* descriptor(); 00546 static const DescriptorProto& default_instance(); 00547 00548 void Swap(DescriptorProto* other); 00549 00550 // implements Message ---------------------------------------------- 00551 00552 DescriptorProto* New() const; 00553 void CopyFrom(const ::google::protobuf::Message& from); 00554 void MergeFrom(const ::google::protobuf::Message& from); 00555 void CopyFrom(const DescriptorProto& from); 00556 void MergeFrom(const DescriptorProto& from); 00557 void Clear(); 00558 bool IsInitialized() const; 00559 00560 int ByteSize() const; 00561 bool MergePartialFromCodedStream( 00562 ::google::protobuf::io::CodedInputStream* input); 00563 void SerializeWithCachedSizes( 00564 ::google::protobuf::io::CodedOutputStream* output) const; 00565 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 00566 int GetCachedSize() const { return _cached_size_; } 00567 private: 00568 void SharedCtor(); 00569 void SharedDtor(); 00570 void SetCachedSize(int size) const; 00571 public: 00572 00573 ::google::protobuf::Metadata GetMetadata() const; 00574 00575 // nested types ---------------------------------------------------- 00576 00577 typedef DescriptorProto_ExtensionRange ExtensionRange; 00578 00579 // accessors ------------------------------------------------------- 00580 00581 // optional string name = 1; 00582 inline bool has_name() const; 00583 inline void clear_name(); 00584 static const int kNameFieldNumber = 1; 00585 inline const ::std::string& name() const; 00586 inline void set_name(const ::std::string& value); 00587 inline void set_name(const char* value); 00588 inline void set_name(const char* value, size_t size); 00589 inline ::std::string* mutable_name(); 00590 00591 // repeated .google.protobuf.FieldDescriptorProto field = 2; 00592 inline int field_size() const; 00593 inline void clear_field(); 00594 static const int kFieldFieldNumber = 2; 00595 inline const ::google::protobuf::FieldDescriptorProto& field(int index) const; 00596 inline ::google::protobuf::FieldDescriptorProto* mutable_field(int index); 00597 inline ::google::protobuf::FieldDescriptorProto* add_field(); 00598 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 00599 field() const; 00600 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 00601 mutable_field(); 00602 00603 // repeated .google.protobuf.FieldDescriptorProto extension = 6; 00604 inline int extension_size() const; 00605 inline void clear_extension(); 00606 static const int kExtensionFieldNumber = 6; 00607 inline const ::google::protobuf::FieldDescriptorProto& extension(int index) const; 00608 inline ::google::protobuf::FieldDescriptorProto* mutable_extension(int index); 00609 inline ::google::protobuf::FieldDescriptorProto* add_extension(); 00610 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 00611 extension() const; 00612 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 00613 mutable_extension(); 00614 00615 // repeated .google.protobuf.DescriptorProto nested_type = 3; 00616 inline int nested_type_size() const; 00617 inline void clear_nested_type(); 00618 static const int kNestedTypeFieldNumber = 3; 00619 inline const ::google::protobuf::DescriptorProto& nested_type(int index) const; 00620 inline ::google::protobuf::DescriptorProto* mutable_nested_type(int index); 00621 inline ::google::protobuf::DescriptorProto* add_nested_type(); 00622 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 00623 nested_type() const; 00624 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 00625 mutable_nested_type(); 00626 00627 // repeated .google.protobuf.EnumDescriptorProto enum_type = 4; 00628 inline int enum_type_size() const; 00629 inline void clear_enum_type(); 00630 static const int kEnumTypeFieldNumber = 4; 00631 inline const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const; 00632 inline ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index); 00633 inline ::google::protobuf::EnumDescriptorProto* add_enum_type(); 00634 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 00635 enum_type() const; 00636 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 00637 mutable_enum_type(); 00638 00639 // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; 00640 inline int extension_range_size() const; 00641 inline void clear_extension_range(); 00642 static const int kExtensionRangeFieldNumber = 5; 00643 inline const ::google::protobuf::DescriptorProto_ExtensionRange& extension_range(int index) const; 00644 inline ::google::protobuf::DescriptorProto_ExtensionRange* mutable_extension_range(int index); 00645 inline ::google::protobuf::DescriptorProto_ExtensionRange* add_extension_range(); 00646 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >& 00647 extension_range() const; 00648 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >* 00649 mutable_extension_range(); 00650 00651 // optional .google.protobuf.MessageOptions options = 7; 00652 inline bool has_options() const; 00653 inline void clear_options(); 00654 static const int kOptionsFieldNumber = 7; 00655 inline const ::google::protobuf::MessageOptions& options() const; 00656 inline ::google::protobuf::MessageOptions* mutable_options(); 00657 00658 // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto) 00659 private: 00660 ::google::protobuf::UnknownFieldSet _unknown_fields_; 00661 mutable int _cached_size_; 00662 00663 ::std::string* name_; 00664 static const ::std::string _default_name_; 00665 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > field_; 00666 ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_; 00667 ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > nested_type_; 00668 ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_; 00669 ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange > extension_range_; 00670 ::google::protobuf::MessageOptions* options_; 00671 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00672 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00673 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 00674 00675 ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; 00676 00677 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 00678 inline bool _has_bit(int index) const { 00679 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 00680 } 00681 inline void _set_bit(int index) { 00682 _has_bits_[index / 32] |= (1u << (index % 32)); 00683 } 00684 inline void _clear_bit(int index) { 00685 _has_bits_[index / 32] &= ~(1u << (index % 32)); 00686 } 00687 00688 void InitAsDefaultInstance(); 00689 static DescriptorProto* default_instance_; 00690 }; 00691 // ------------------------------------------------------------------- 00692 00693 class LIBPROTOBUF_EXPORT FieldDescriptorProto : public ::google::protobuf::Message { 00694 public: 00695 FieldDescriptorProto(); 00696 virtual ~FieldDescriptorProto(); 00697 00698 FieldDescriptorProto(const FieldDescriptorProto& from); 00699 00700 inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) { 00701 CopyFrom(from); 00702 return *this; 00703 } 00704 00705 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 00706 return _unknown_fields_; 00707 } 00708 00709 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 00710 return &_unknown_fields_; 00711 } 00712 00713 static const ::google::protobuf::Descriptor* descriptor(); 00714 static const FieldDescriptorProto& default_instance(); 00715 00716 void Swap(FieldDescriptorProto* other); 00717 00718 // implements Message ---------------------------------------------- 00719 00720 FieldDescriptorProto* New() const; 00721 void CopyFrom(const ::google::protobuf::Message& from); 00722 void MergeFrom(const ::google::protobuf::Message& from); 00723 void CopyFrom(const FieldDescriptorProto& from); 00724 void MergeFrom(const FieldDescriptorProto& from); 00725 void Clear(); 00726 bool IsInitialized() const; 00727 00728 int ByteSize() const; 00729 bool MergePartialFromCodedStream( 00730 ::google::protobuf::io::CodedInputStream* input); 00731 void SerializeWithCachedSizes( 00732 ::google::protobuf::io::CodedOutputStream* output) const; 00733 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 00734 int GetCachedSize() const { return _cached_size_; } 00735 private: 00736 void SharedCtor(); 00737 void SharedDtor(); 00738 void SetCachedSize(int size) const; 00739 public: 00740 00741 ::google::protobuf::Metadata GetMetadata() const; 00742 00743 // nested types ---------------------------------------------------- 00744 00745 typedef FieldDescriptorProto_Type Type; 00746 static const Type TYPE_DOUBLE = FieldDescriptorProto_Type_TYPE_DOUBLE; 00747 static const Type TYPE_FLOAT = FieldDescriptorProto_Type_TYPE_FLOAT; 00748 static const Type TYPE_INT64 = FieldDescriptorProto_Type_TYPE_INT64; 00749 static const Type TYPE_UINT64 = FieldDescriptorProto_Type_TYPE_UINT64; 00750 static const Type TYPE_INT32 = FieldDescriptorProto_Type_TYPE_INT32; 00751 static const Type TYPE_FIXED64 = FieldDescriptorProto_Type_TYPE_FIXED64; 00752 static const Type TYPE_FIXED32 = FieldDescriptorProto_Type_TYPE_FIXED32; 00753 static const Type TYPE_BOOL = FieldDescriptorProto_Type_TYPE_BOOL; 00754 static const Type TYPE_STRING = FieldDescriptorProto_Type_TYPE_STRING; 00755 static const Type TYPE_GROUP = FieldDescriptorProto_Type_TYPE_GROUP; 00756 static const Type TYPE_MESSAGE = FieldDescriptorProto_Type_TYPE_MESSAGE; 00757 static const Type TYPE_BYTES = FieldDescriptorProto_Type_TYPE_BYTES; 00758 static const Type TYPE_UINT32 = FieldDescriptorProto_Type_TYPE_UINT32; 00759 static const Type TYPE_ENUM = FieldDescriptorProto_Type_TYPE_ENUM; 00760 static const Type TYPE_SFIXED32 = FieldDescriptorProto_Type_TYPE_SFIXED32; 00761 static const Type TYPE_SFIXED64 = FieldDescriptorProto_Type_TYPE_SFIXED64; 00762 static const Type TYPE_SINT32 = FieldDescriptorProto_Type_TYPE_SINT32; 00763 static const Type TYPE_SINT64 = FieldDescriptorProto_Type_TYPE_SINT64; 00764 static inline bool Type_IsValid(int value) { 00765 return FieldDescriptorProto_Type_IsValid(value); 00766 } 00767 static const Type Type_MIN = 00768 FieldDescriptorProto_Type_Type_MIN; 00769 static const Type Type_MAX = 00770 FieldDescriptorProto_Type_Type_MAX; 00771 static const int Type_ARRAYSIZE = 00772 FieldDescriptorProto_Type_Type_ARRAYSIZE; 00773 static inline const ::google::protobuf::EnumDescriptor* 00774 Type_descriptor() { 00775 return FieldDescriptorProto_Type_descriptor(); 00776 } 00777 static inline const ::std::string& Type_Name(Type value) { 00778 return FieldDescriptorProto_Type_Name(value); 00779 } 00780 static inline bool Type_Parse(const ::std::string& name, 00781 Type* value) { 00782 return FieldDescriptorProto_Type_Parse(name, value); 00783 } 00784 00785 typedef FieldDescriptorProto_Label Label; 00786 static const Label LABEL_OPTIONAL = FieldDescriptorProto_Label_LABEL_OPTIONAL; 00787 static const Label LABEL_REQUIRED = FieldDescriptorProto_Label_LABEL_REQUIRED; 00788 static const Label LABEL_REPEATED = FieldDescriptorProto_Label_LABEL_REPEATED; 00789 static inline bool Label_IsValid(int value) { 00790 return FieldDescriptorProto_Label_IsValid(value); 00791 } 00792 static const Label Label_MIN = 00793 FieldDescriptorProto_Label_Label_MIN; 00794 static const Label Label_MAX = 00795 FieldDescriptorProto_Label_Label_MAX; 00796 static const int Label_ARRAYSIZE = 00797 FieldDescriptorProto_Label_Label_ARRAYSIZE; 00798 static inline const ::google::protobuf::EnumDescriptor* 00799 Label_descriptor() { 00800 return FieldDescriptorProto_Label_descriptor(); 00801 } 00802 static inline const ::std::string& Label_Name(Label value) { 00803 return FieldDescriptorProto_Label_Name(value); 00804 } 00805 static inline bool Label_Parse(const ::std::string& name, 00806 Label* value) { 00807 return FieldDescriptorProto_Label_Parse(name, value); 00808 } 00809 00810 // accessors ------------------------------------------------------- 00811 00812 // optional string name = 1; 00813 inline bool has_name() const; 00814 inline void clear_name(); 00815 static const int kNameFieldNumber = 1; 00816 inline const ::std::string& name() const; 00817 inline void set_name(const ::std::string& value); 00818 inline void set_name(const char* value); 00819 inline void set_name(const char* value, size_t size); 00820 inline ::std::string* mutable_name(); 00821 00822 // optional int32 number = 3; 00823 inline bool has_number() const; 00824 inline void clear_number(); 00825 static const int kNumberFieldNumber = 3; 00826 inline ::google::protobuf::int32 number() const; 00827 inline void set_number(::google::protobuf::int32 value); 00828 00829 // optional .google.protobuf.FieldDescriptorProto.Label label = 4; 00830 inline bool has_label() const; 00831 inline void clear_label(); 00832 static const int kLabelFieldNumber = 4; 00833 inline ::google::protobuf::FieldDescriptorProto_Label label() const; 00834 inline void set_label(::google::protobuf::FieldDescriptorProto_Label value); 00835 00836 // optional .google.protobuf.FieldDescriptorProto.Type type = 5; 00837 inline bool has_type() const; 00838 inline void clear_type(); 00839 static const int kTypeFieldNumber = 5; 00840 inline ::google::protobuf::FieldDescriptorProto_Type type() const; 00841 inline void set_type(::google::protobuf::FieldDescriptorProto_Type value); 00842 00843 // optional string type_name = 6; 00844 inline bool has_type_name() const; 00845 inline void clear_type_name(); 00846 static const int kTypeNameFieldNumber = 6; 00847 inline const ::std::string& type_name() const; 00848 inline void set_type_name(const ::std::string& value); 00849 inline void set_type_name(const char* value); 00850 inline void set_type_name(const char* value, size_t size); 00851 inline ::std::string* mutable_type_name(); 00852 00853 // optional string extendee = 2; 00854 inline bool has_extendee() const; 00855 inline void clear_extendee(); 00856 static const int kExtendeeFieldNumber = 2; 00857 inline const ::std::string& extendee() const; 00858 inline void set_extendee(const ::std::string& value); 00859 inline void set_extendee(const char* value); 00860 inline void set_extendee(const char* value, size_t size); 00861 inline ::std::string* mutable_extendee(); 00862 00863 // optional string default_value = 7; 00864 inline bool has_default_value() const; 00865 inline void clear_default_value(); 00866 static const int kDefaultValueFieldNumber = 7; 00867 inline const ::std::string& default_value() const; 00868 inline void set_default_value(const ::std::string& value); 00869 inline void set_default_value(const char* value); 00870 inline void set_default_value(const char* value, size_t size); 00871 inline ::std::string* mutable_default_value(); 00872 00873 // optional .google.protobuf.FieldOptions options = 8; 00874 inline bool has_options() const; 00875 inline void clear_options(); 00876 static const int kOptionsFieldNumber = 8; 00877 inline const ::google::protobuf::FieldOptions& options() const; 00878 inline ::google::protobuf::FieldOptions* mutable_options(); 00879 00880 // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto) 00881 private: 00882 ::google::protobuf::UnknownFieldSet _unknown_fields_; 00883 mutable int _cached_size_; 00884 00885 ::std::string* name_; 00886 static const ::std::string _default_name_; 00887 ::google::protobuf::int32 number_; 00888 int label_; 00889 int type_; 00890 ::std::string* type_name_; 00891 static const ::std::string _default_type_name_; 00892 ::std::string* extendee_; 00893 static const ::std::string _default_extendee_; 00894 ::std::string* default_value_; 00895 static const ::std::string _default_default_value_; 00896 ::google::protobuf::FieldOptions* options_; 00897 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00898 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 00899 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 00900 00901 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 00902 00903 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 00904 inline bool _has_bit(int index) const { 00905 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 00906 } 00907 inline void _set_bit(int index) { 00908 _has_bits_[index / 32] |= (1u << (index % 32)); 00909 } 00910 inline void _clear_bit(int index) { 00911 _has_bits_[index / 32] &= ~(1u << (index % 32)); 00912 } 00913 00914 void InitAsDefaultInstance(); 00915 static FieldDescriptorProto* default_instance_; 00916 }; 00917 // ------------------------------------------------------------------- 00918 00919 class LIBPROTOBUF_EXPORT EnumDescriptorProto : public ::google::protobuf::Message { 00920 public: 00921 EnumDescriptorProto(); 00922 virtual ~EnumDescriptorProto(); 00923 00924 EnumDescriptorProto(const EnumDescriptorProto& from); 00925 00926 inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) { 00927 CopyFrom(from); 00928 return *this; 00929 } 00930 00931 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 00932 return _unknown_fields_; 00933 } 00934 00935 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 00936 return &_unknown_fields_; 00937 } 00938 00939 static const ::google::protobuf::Descriptor* descriptor(); 00940 static const EnumDescriptorProto& default_instance(); 00941 00942 void Swap(EnumDescriptorProto* other); 00943 00944 // implements Message ---------------------------------------------- 00945 00946 EnumDescriptorProto* New() const; 00947 void CopyFrom(const ::google::protobuf::Message& from); 00948 void MergeFrom(const ::google::protobuf::Message& from); 00949 void CopyFrom(const EnumDescriptorProto& from); 00950 void MergeFrom(const EnumDescriptorProto& from); 00951 void Clear(); 00952 bool IsInitialized() const; 00953 00954 int ByteSize() const; 00955 bool MergePartialFromCodedStream( 00956 ::google::protobuf::io::CodedInputStream* input); 00957 void SerializeWithCachedSizes( 00958 ::google::protobuf::io::CodedOutputStream* output) const; 00959 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 00960 int GetCachedSize() const { return _cached_size_; } 00961 private: 00962 void SharedCtor(); 00963 void SharedDtor(); 00964 void SetCachedSize(int size) const; 00965 public: 00966 00967 ::google::protobuf::Metadata GetMetadata() const; 00968 00969 // nested types ---------------------------------------------------- 00970 00971 // accessors ------------------------------------------------------- 00972 00973 // optional string name = 1; 00974 inline bool has_name() const; 00975 inline void clear_name(); 00976 static const int kNameFieldNumber = 1; 00977 inline const ::std::string& name() const; 00978 inline void set_name(const ::std::string& value); 00979 inline void set_name(const char* value); 00980 inline void set_name(const char* value, size_t size); 00981 inline ::std::string* mutable_name(); 00982 00983 // repeated .google.protobuf.EnumValueDescriptorProto value = 2; 00984 inline int value_size() const; 00985 inline void clear_value(); 00986 static const int kValueFieldNumber = 2; 00987 inline const ::google::protobuf::EnumValueDescriptorProto& value(int index) const; 00988 inline ::google::protobuf::EnumValueDescriptorProto* mutable_value(int index); 00989 inline ::google::protobuf::EnumValueDescriptorProto* add_value(); 00990 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >& 00991 value() const; 00992 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >* 00993 mutable_value(); 00994 00995 // optional .google.protobuf.EnumOptions options = 3; 00996 inline bool has_options() const; 00997 inline void clear_options(); 00998 static const int kOptionsFieldNumber = 3; 00999 inline const ::google::protobuf::EnumOptions& options() const; 01000 inline ::google::protobuf::EnumOptions* mutable_options(); 01001 01002 // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto) 01003 private: 01004 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01005 mutable int _cached_size_; 01006 01007 ::std::string* name_; 01008 static const ::std::string _default_name_; 01009 ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto > value_; 01010 ::google::protobuf::EnumOptions* options_; 01011 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01012 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01013 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01014 01015 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 01016 01017 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01018 inline bool _has_bit(int index) const { 01019 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01020 } 01021 inline void _set_bit(int index) { 01022 _has_bits_[index / 32] |= (1u << (index % 32)); 01023 } 01024 inline void _clear_bit(int index) { 01025 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01026 } 01027 01028 void InitAsDefaultInstance(); 01029 static EnumDescriptorProto* default_instance_; 01030 }; 01031 // ------------------------------------------------------------------- 01032 01033 class LIBPROTOBUF_EXPORT EnumValueDescriptorProto : public ::google::protobuf::Message { 01034 public: 01035 EnumValueDescriptorProto(); 01036 virtual ~EnumValueDescriptorProto(); 01037 01038 EnumValueDescriptorProto(const EnumValueDescriptorProto& from); 01039 01040 inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) { 01041 CopyFrom(from); 01042 return *this; 01043 } 01044 01045 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01046 return _unknown_fields_; 01047 } 01048 01049 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01050 return &_unknown_fields_; 01051 } 01052 01053 static const ::google::protobuf::Descriptor* descriptor(); 01054 static const EnumValueDescriptorProto& default_instance(); 01055 01056 void Swap(EnumValueDescriptorProto* other); 01057 01058 // implements Message ---------------------------------------------- 01059 01060 EnumValueDescriptorProto* New() const; 01061 void CopyFrom(const ::google::protobuf::Message& from); 01062 void MergeFrom(const ::google::protobuf::Message& from); 01063 void CopyFrom(const EnumValueDescriptorProto& from); 01064 void MergeFrom(const EnumValueDescriptorProto& from); 01065 void Clear(); 01066 bool IsInitialized() const; 01067 01068 int ByteSize() const; 01069 bool MergePartialFromCodedStream( 01070 ::google::protobuf::io::CodedInputStream* input); 01071 void SerializeWithCachedSizes( 01072 ::google::protobuf::io::CodedOutputStream* output) const; 01073 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01074 int GetCachedSize() const { return _cached_size_; } 01075 private: 01076 void SharedCtor(); 01077 void SharedDtor(); 01078 void SetCachedSize(int size) const; 01079 public: 01080 01081 ::google::protobuf::Metadata GetMetadata() const; 01082 01083 // nested types ---------------------------------------------------- 01084 01085 // accessors ------------------------------------------------------- 01086 01087 // optional string name = 1; 01088 inline bool has_name() const; 01089 inline void clear_name(); 01090 static const int kNameFieldNumber = 1; 01091 inline const ::std::string& name() const; 01092 inline void set_name(const ::std::string& value); 01093 inline void set_name(const char* value); 01094 inline void set_name(const char* value, size_t size); 01095 inline ::std::string* mutable_name(); 01096 01097 // optional int32 number = 2; 01098 inline bool has_number() const; 01099 inline void clear_number(); 01100 static const int kNumberFieldNumber = 2; 01101 inline ::google::protobuf::int32 number() const; 01102 inline void set_number(::google::protobuf::int32 value); 01103 01104 // optional .google.protobuf.EnumValueOptions options = 3; 01105 inline bool has_options() const; 01106 inline void clear_options(); 01107 static const int kOptionsFieldNumber = 3; 01108 inline const ::google::protobuf::EnumValueOptions& options() const; 01109 inline ::google::protobuf::EnumValueOptions* mutable_options(); 01110 01111 // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto) 01112 private: 01113 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01114 mutable int _cached_size_; 01115 01116 ::std::string* name_; 01117 static const ::std::string _default_name_; 01118 ::google::protobuf::int32 number_; 01119 ::google::protobuf::EnumValueOptions* options_; 01120 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01121 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01122 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01123 01124 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 01125 01126 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01127 inline bool _has_bit(int index) const { 01128 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01129 } 01130 inline void _set_bit(int index) { 01131 _has_bits_[index / 32] |= (1u << (index % 32)); 01132 } 01133 inline void _clear_bit(int index) { 01134 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01135 } 01136 01137 void InitAsDefaultInstance(); 01138 static EnumValueDescriptorProto* default_instance_; 01139 }; 01140 // ------------------------------------------------------------------- 01141 01142 class LIBPROTOBUF_EXPORT ServiceDescriptorProto : public ::google::protobuf::Message { 01143 public: 01144 ServiceDescriptorProto(); 01145 virtual ~ServiceDescriptorProto(); 01146 01147 ServiceDescriptorProto(const ServiceDescriptorProto& from); 01148 01149 inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) { 01150 CopyFrom(from); 01151 return *this; 01152 } 01153 01154 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01155 return _unknown_fields_; 01156 } 01157 01158 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01159 return &_unknown_fields_; 01160 } 01161 01162 static const ::google::protobuf::Descriptor* descriptor(); 01163 static const ServiceDescriptorProto& default_instance(); 01164 01165 void Swap(ServiceDescriptorProto* other); 01166 01167 // implements Message ---------------------------------------------- 01168 01169 ServiceDescriptorProto* New() const; 01170 void CopyFrom(const ::google::protobuf::Message& from); 01171 void MergeFrom(const ::google::protobuf::Message& from); 01172 void CopyFrom(const ServiceDescriptorProto& from); 01173 void MergeFrom(const ServiceDescriptorProto& from); 01174 void Clear(); 01175 bool IsInitialized() const; 01176 01177 int ByteSize() const; 01178 bool MergePartialFromCodedStream( 01179 ::google::protobuf::io::CodedInputStream* input); 01180 void SerializeWithCachedSizes( 01181 ::google::protobuf::io::CodedOutputStream* output) const; 01182 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01183 int GetCachedSize() const { return _cached_size_; } 01184 private: 01185 void SharedCtor(); 01186 void SharedDtor(); 01187 void SetCachedSize(int size) const; 01188 public: 01189 01190 ::google::protobuf::Metadata GetMetadata() const; 01191 01192 // nested types ---------------------------------------------------- 01193 01194 // accessors ------------------------------------------------------- 01195 01196 // optional string name = 1; 01197 inline bool has_name() const; 01198 inline void clear_name(); 01199 static const int kNameFieldNumber = 1; 01200 inline const ::std::string& name() const; 01201 inline void set_name(const ::std::string& value); 01202 inline void set_name(const char* value); 01203 inline void set_name(const char* value, size_t size); 01204 inline ::std::string* mutable_name(); 01205 01206 // repeated .google.protobuf.MethodDescriptorProto method = 2; 01207 inline int method_size() const; 01208 inline void clear_method(); 01209 static const int kMethodFieldNumber = 2; 01210 inline const ::google::protobuf::MethodDescriptorProto& method(int index) const; 01211 inline ::google::protobuf::MethodDescriptorProto* mutable_method(int index); 01212 inline ::google::protobuf::MethodDescriptorProto* add_method(); 01213 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >& 01214 method() const; 01215 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >* 01216 mutable_method(); 01217 01218 // optional .google.protobuf.ServiceOptions options = 3; 01219 inline bool has_options() const; 01220 inline void clear_options(); 01221 static const int kOptionsFieldNumber = 3; 01222 inline const ::google::protobuf::ServiceOptions& options() const; 01223 inline ::google::protobuf::ServiceOptions* mutable_options(); 01224 01225 // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto) 01226 private: 01227 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01228 mutable int _cached_size_; 01229 01230 ::std::string* name_; 01231 static const ::std::string _default_name_; 01232 ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto > method_; 01233 ::google::protobuf::ServiceOptions* options_; 01234 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01235 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01236 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01237 01238 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 01239 01240 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01241 inline bool _has_bit(int index) const { 01242 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01243 } 01244 inline void _set_bit(int index) { 01245 _has_bits_[index / 32] |= (1u << (index % 32)); 01246 } 01247 inline void _clear_bit(int index) { 01248 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01249 } 01250 01251 void InitAsDefaultInstance(); 01252 static ServiceDescriptorProto* default_instance_; 01253 }; 01254 // ------------------------------------------------------------------- 01255 01256 class LIBPROTOBUF_EXPORT MethodDescriptorProto : public ::google::protobuf::Message { 01257 public: 01258 MethodDescriptorProto(); 01259 virtual ~MethodDescriptorProto(); 01260 01261 MethodDescriptorProto(const MethodDescriptorProto& from); 01262 01263 inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) { 01264 CopyFrom(from); 01265 return *this; 01266 } 01267 01268 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01269 return _unknown_fields_; 01270 } 01271 01272 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01273 return &_unknown_fields_; 01274 } 01275 01276 static const ::google::protobuf::Descriptor* descriptor(); 01277 static const MethodDescriptorProto& default_instance(); 01278 01279 void Swap(MethodDescriptorProto* other); 01280 01281 // implements Message ---------------------------------------------- 01282 01283 MethodDescriptorProto* New() const; 01284 void CopyFrom(const ::google::protobuf::Message& from); 01285 void MergeFrom(const ::google::protobuf::Message& from); 01286 void CopyFrom(const MethodDescriptorProto& from); 01287 void MergeFrom(const MethodDescriptorProto& from); 01288 void Clear(); 01289 bool IsInitialized() const; 01290 01291 int ByteSize() const; 01292 bool MergePartialFromCodedStream( 01293 ::google::protobuf::io::CodedInputStream* input); 01294 void SerializeWithCachedSizes( 01295 ::google::protobuf::io::CodedOutputStream* output) const; 01296 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01297 int GetCachedSize() const { return _cached_size_; } 01298 private: 01299 void SharedCtor(); 01300 void SharedDtor(); 01301 void SetCachedSize(int size) const; 01302 public: 01303 01304 ::google::protobuf::Metadata GetMetadata() const; 01305 01306 // nested types ---------------------------------------------------- 01307 01308 // accessors ------------------------------------------------------- 01309 01310 // optional string name = 1; 01311 inline bool has_name() const; 01312 inline void clear_name(); 01313 static const int kNameFieldNumber = 1; 01314 inline const ::std::string& name() const; 01315 inline void set_name(const ::std::string& value); 01316 inline void set_name(const char* value); 01317 inline void set_name(const char* value, size_t size); 01318 inline ::std::string* mutable_name(); 01319 01320 // optional string input_type = 2; 01321 inline bool has_input_type() const; 01322 inline void clear_input_type(); 01323 static const int kInputTypeFieldNumber = 2; 01324 inline const ::std::string& input_type() const; 01325 inline void set_input_type(const ::std::string& value); 01326 inline void set_input_type(const char* value); 01327 inline void set_input_type(const char* value, size_t size); 01328 inline ::std::string* mutable_input_type(); 01329 01330 // optional string output_type = 3; 01331 inline bool has_output_type() const; 01332 inline void clear_output_type(); 01333 static const int kOutputTypeFieldNumber = 3; 01334 inline const ::std::string& output_type() const; 01335 inline void set_output_type(const ::std::string& value); 01336 inline void set_output_type(const char* value); 01337 inline void set_output_type(const char* value, size_t size); 01338 inline ::std::string* mutable_output_type(); 01339 01340 // optional .google.protobuf.MethodOptions options = 4; 01341 inline bool has_options() const; 01342 inline void clear_options(); 01343 static const int kOptionsFieldNumber = 4; 01344 inline const ::google::protobuf::MethodOptions& options() const; 01345 inline ::google::protobuf::MethodOptions* mutable_options(); 01346 01347 // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto) 01348 private: 01349 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01350 mutable int _cached_size_; 01351 01352 ::std::string* name_; 01353 static const ::std::string _default_name_; 01354 ::std::string* input_type_; 01355 static const ::std::string _default_input_type_; 01356 ::std::string* output_type_; 01357 static const ::std::string _default_output_type_; 01358 ::google::protobuf::MethodOptions* options_; 01359 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01360 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01361 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01362 01363 ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; 01364 01365 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01366 inline bool _has_bit(int index) const { 01367 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01368 } 01369 inline void _set_bit(int index) { 01370 _has_bits_[index / 32] |= (1u << (index % 32)); 01371 } 01372 inline void _clear_bit(int index) { 01373 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01374 } 01375 01376 void InitAsDefaultInstance(); 01377 static MethodDescriptorProto* default_instance_; 01378 }; 01379 // ------------------------------------------------------------------- 01380 01381 class LIBPROTOBUF_EXPORT FileOptions : public ::google::protobuf::Message { 01382 public: 01383 FileOptions(); 01384 virtual ~FileOptions(); 01385 01386 FileOptions(const FileOptions& from); 01387 01388 inline FileOptions& operator=(const FileOptions& from) { 01389 CopyFrom(from); 01390 return *this; 01391 } 01392 01393 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01394 return _unknown_fields_; 01395 } 01396 01397 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01398 return &_unknown_fields_; 01399 } 01400 01401 static const ::google::protobuf::Descriptor* descriptor(); 01402 static const FileOptions& default_instance(); 01403 01404 void Swap(FileOptions* other); 01405 01406 // implements Message ---------------------------------------------- 01407 01408 FileOptions* New() const; 01409 void CopyFrom(const ::google::protobuf::Message& from); 01410 void MergeFrom(const ::google::protobuf::Message& from); 01411 void CopyFrom(const FileOptions& from); 01412 void MergeFrom(const FileOptions& from); 01413 void Clear(); 01414 bool IsInitialized() const; 01415 01416 int ByteSize() const; 01417 bool MergePartialFromCodedStream( 01418 ::google::protobuf::io::CodedInputStream* input); 01419 void SerializeWithCachedSizes( 01420 ::google::protobuf::io::CodedOutputStream* output) const; 01421 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01422 int GetCachedSize() const { return _cached_size_; } 01423 private: 01424 void SharedCtor(); 01425 void SharedDtor(); 01426 void SetCachedSize(int size) const; 01427 public: 01428 01429 ::google::protobuf::Metadata GetMetadata() const; 01430 01431 // nested types ---------------------------------------------------- 01432 01433 typedef FileOptions_OptimizeMode OptimizeMode; 01434 static const OptimizeMode SPEED = FileOptions_OptimizeMode_SPEED; 01435 static const OptimizeMode CODE_SIZE = FileOptions_OptimizeMode_CODE_SIZE; 01436 static const OptimizeMode LITE_RUNTIME = FileOptions_OptimizeMode_LITE_RUNTIME; 01437 static inline bool OptimizeMode_IsValid(int value) { 01438 return FileOptions_OptimizeMode_IsValid(value); 01439 } 01440 static const OptimizeMode OptimizeMode_MIN = 01441 FileOptions_OptimizeMode_OptimizeMode_MIN; 01442 static const OptimizeMode OptimizeMode_MAX = 01443 FileOptions_OptimizeMode_OptimizeMode_MAX; 01444 static const int OptimizeMode_ARRAYSIZE = 01445 FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE; 01446 static inline const ::google::protobuf::EnumDescriptor* 01447 OptimizeMode_descriptor() { 01448 return FileOptions_OptimizeMode_descriptor(); 01449 } 01450 static inline const ::std::string& OptimizeMode_Name(OptimizeMode value) { 01451 return FileOptions_OptimizeMode_Name(value); 01452 } 01453 static inline bool OptimizeMode_Parse(const ::std::string& name, 01454 OptimizeMode* value) { 01455 return FileOptions_OptimizeMode_Parse(name, value); 01456 } 01457 01458 // accessors ------------------------------------------------------- 01459 01460 // optional string java_package = 1; 01461 inline bool has_java_package() const; 01462 inline void clear_java_package(); 01463 static const int kJavaPackageFieldNumber = 1; 01464 inline const ::std::string& java_package() const; 01465 inline void set_java_package(const ::std::string& value); 01466 inline void set_java_package(const char* value); 01467 inline void set_java_package(const char* value, size_t size); 01468 inline ::std::string* mutable_java_package(); 01469 01470 // optional string java_outer_classname = 8; 01471 inline bool has_java_outer_classname() const; 01472 inline void clear_java_outer_classname(); 01473 static const int kJavaOuterClassnameFieldNumber = 8; 01474 inline const ::std::string& java_outer_classname() const; 01475 inline void set_java_outer_classname(const ::std::string& value); 01476 inline void set_java_outer_classname(const char* value); 01477 inline void set_java_outer_classname(const char* value, size_t size); 01478 inline ::std::string* mutable_java_outer_classname(); 01479 01480 // optional bool java_multiple_files = 10 [default = false]; 01481 inline bool has_java_multiple_files() const; 01482 inline void clear_java_multiple_files(); 01483 static const int kJavaMultipleFilesFieldNumber = 10; 01484 inline bool java_multiple_files() const; 01485 inline void set_java_multiple_files(bool value); 01486 01487 // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; 01488 inline bool has_optimize_for() const; 01489 inline void clear_optimize_for(); 01490 static const int kOptimizeForFieldNumber = 9; 01491 inline ::google::protobuf::FileOptions_OptimizeMode optimize_for() const; 01492 inline void set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value); 01493 01494 // optional bool cc_generic_services = 16 [default = true]; 01495 inline bool has_cc_generic_services() const; 01496 inline void clear_cc_generic_services(); 01497 static const int kCcGenericServicesFieldNumber = 16; 01498 inline bool cc_generic_services() const; 01499 inline void set_cc_generic_services(bool value); 01500 01501 // optional bool java_generic_services = 17 [default = true]; 01502 inline bool has_java_generic_services() const; 01503 inline void clear_java_generic_services(); 01504 static const int kJavaGenericServicesFieldNumber = 17; 01505 inline bool java_generic_services() const; 01506 inline void set_java_generic_services(bool value); 01507 01508 // optional bool py_generic_services = 18 [default = true]; 01509 inline bool has_py_generic_services() const; 01510 inline void clear_py_generic_services(); 01511 static const int kPyGenericServicesFieldNumber = 18; 01512 inline bool py_generic_services() const; 01513 inline void set_py_generic_services(bool value); 01514 01515 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 01516 inline int uninterpreted_option_size() const; 01517 inline void clear_uninterpreted_option(); 01518 static const int kUninterpretedOptionFieldNumber = 999; 01519 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 01520 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 01521 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 01522 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 01523 uninterpreted_option() const; 01524 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 01525 mutable_uninterpreted_option(); 01526 01527 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FileOptions) 01528 // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions) 01529 private: 01530 ::google::protobuf::internal::ExtensionSet _extensions_; 01531 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01532 mutable int _cached_size_; 01533 01534 ::std::string* java_package_; 01535 static const ::std::string _default_java_package_; 01536 ::std::string* java_outer_classname_; 01537 static const ::std::string _default_java_outer_classname_; 01538 bool java_multiple_files_; 01539 int optimize_for_; 01540 bool cc_generic_services_; 01541 bool java_generic_services_; 01542 bool py_generic_services_; 01543 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 01544 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01545 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01546 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01547 01548 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 01549 01550 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01551 inline bool _has_bit(int index) const { 01552 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01553 } 01554 inline void _set_bit(int index) { 01555 _has_bits_[index / 32] |= (1u << (index % 32)); 01556 } 01557 inline void _clear_bit(int index) { 01558 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01559 } 01560 01561 void InitAsDefaultInstance(); 01562 static FileOptions* default_instance_; 01563 }; 01564 // ------------------------------------------------------------------- 01565 01566 class LIBPROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message { 01567 public: 01568 MessageOptions(); 01569 virtual ~MessageOptions(); 01570 01571 MessageOptions(const MessageOptions& from); 01572 01573 inline MessageOptions& operator=(const MessageOptions& from) { 01574 CopyFrom(from); 01575 return *this; 01576 } 01577 01578 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01579 return _unknown_fields_; 01580 } 01581 01582 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01583 return &_unknown_fields_; 01584 } 01585 01586 static const ::google::protobuf::Descriptor* descriptor(); 01587 static const MessageOptions& default_instance(); 01588 01589 void Swap(MessageOptions* other); 01590 01591 // implements Message ---------------------------------------------- 01592 01593 MessageOptions* New() const; 01594 void CopyFrom(const ::google::protobuf::Message& from); 01595 void MergeFrom(const ::google::protobuf::Message& from); 01596 void CopyFrom(const MessageOptions& from); 01597 void MergeFrom(const MessageOptions& from); 01598 void Clear(); 01599 bool IsInitialized() const; 01600 01601 int ByteSize() const; 01602 bool MergePartialFromCodedStream( 01603 ::google::protobuf::io::CodedInputStream* input); 01604 void SerializeWithCachedSizes( 01605 ::google::protobuf::io::CodedOutputStream* output) const; 01606 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01607 int GetCachedSize() const { return _cached_size_; } 01608 private: 01609 void SharedCtor(); 01610 void SharedDtor(); 01611 void SetCachedSize(int size) const; 01612 public: 01613 01614 ::google::protobuf::Metadata GetMetadata() const; 01615 01616 // nested types ---------------------------------------------------- 01617 01618 // accessors ------------------------------------------------------- 01619 01620 // optional bool message_set_wire_format = 1 [default = false]; 01621 inline bool has_message_set_wire_format() const; 01622 inline void clear_message_set_wire_format(); 01623 static const int kMessageSetWireFormatFieldNumber = 1; 01624 inline bool message_set_wire_format() const; 01625 inline void set_message_set_wire_format(bool value); 01626 01627 // optional bool no_standard_descriptor_accessor = 2 [default = false]; 01628 inline bool has_no_standard_descriptor_accessor() const; 01629 inline void clear_no_standard_descriptor_accessor(); 01630 static const int kNoStandardDescriptorAccessorFieldNumber = 2; 01631 inline bool no_standard_descriptor_accessor() const; 01632 inline void set_no_standard_descriptor_accessor(bool value); 01633 01634 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 01635 inline int uninterpreted_option_size() const; 01636 inline void clear_uninterpreted_option(); 01637 static const int kUninterpretedOptionFieldNumber = 999; 01638 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 01639 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 01640 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 01641 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 01642 uninterpreted_option() const; 01643 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 01644 mutable_uninterpreted_option(); 01645 01646 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MessageOptions) 01647 // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions) 01648 private: 01649 ::google::protobuf::internal::ExtensionSet _extensions_; 01650 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01651 mutable int _cached_size_; 01652 01653 bool message_set_wire_format_; 01654 bool no_standard_descriptor_accessor_; 01655 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 01656 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01657 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01658 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01659 01660 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 01661 01662 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01663 inline bool _has_bit(int index) const { 01664 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01665 } 01666 inline void _set_bit(int index) { 01667 _has_bits_[index / 32] |= (1u << (index % 32)); 01668 } 01669 inline void _clear_bit(int index) { 01670 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01671 } 01672 01673 void InitAsDefaultInstance(); 01674 static MessageOptions* default_instance_; 01675 }; 01676 // ------------------------------------------------------------------- 01677 01678 class LIBPROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message { 01679 public: 01680 FieldOptions(); 01681 virtual ~FieldOptions(); 01682 01683 FieldOptions(const FieldOptions& from); 01684 01685 inline FieldOptions& operator=(const FieldOptions& from) { 01686 CopyFrom(from); 01687 return *this; 01688 } 01689 01690 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01691 return _unknown_fields_; 01692 } 01693 01694 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01695 return &_unknown_fields_; 01696 } 01697 01698 static const ::google::protobuf::Descriptor* descriptor(); 01699 static const FieldOptions& default_instance(); 01700 01701 void Swap(FieldOptions* other); 01702 01703 // implements Message ---------------------------------------------- 01704 01705 FieldOptions* New() const; 01706 void CopyFrom(const ::google::protobuf::Message& from); 01707 void MergeFrom(const ::google::protobuf::Message& from); 01708 void CopyFrom(const FieldOptions& from); 01709 void MergeFrom(const FieldOptions& from); 01710 void Clear(); 01711 bool IsInitialized() const; 01712 01713 int ByteSize() const; 01714 bool MergePartialFromCodedStream( 01715 ::google::protobuf::io::CodedInputStream* input); 01716 void SerializeWithCachedSizes( 01717 ::google::protobuf::io::CodedOutputStream* output) const; 01718 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01719 int GetCachedSize() const { return _cached_size_; } 01720 private: 01721 void SharedCtor(); 01722 void SharedDtor(); 01723 void SetCachedSize(int size) const; 01724 public: 01725 01726 ::google::protobuf::Metadata GetMetadata() const; 01727 01728 // nested types ---------------------------------------------------- 01729 01730 typedef FieldOptions_CType CType; 01731 static const CType STRING = FieldOptions_CType_STRING; 01732 static const CType CORD = FieldOptions_CType_CORD; 01733 static const CType STRING_PIECE = FieldOptions_CType_STRING_PIECE; 01734 static inline bool CType_IsValid(int value) { 01735 return FieldOptions_CType_IsValid(value); 01736 } 01737 static const CType CType_MIN = 01738 FieldOptions_CType_CType_MIN; 01739 static const CType CType_MAX = 01740 FieldOptions_CType_CType_MAX; 01741 static const int CType_ARRAYSIZE = 01742 FieldOptions_CType_CType_ARRAYSIZE; 01743 static inline const ::google::protobuf::EnumDescriptor* 01744 CType_descriptor() { 01745 return FieldOptions_CType_descriptor(); 01746 } 01747 static inline const ::std::string& CType_Name(CType value) { 01748 return FieldOptions_CType_Name(value); 01749 } 01750 static inline bool CType_Parse(const ::std::string& name, 01751 CType* value) { 01752 return FieldOptions_CType_Parse(name, value); 01753 } 01754 01755 // accessors ------------------------------------------------------- 01756 01757 // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 01758 inline bool has_ctype() const; 01759 inline void clear_ctype(); 01760 static const int kCtypeFieldNumber = 1; 01761 inline ::google::protobuf::FieldOptions_CType ctype() const; 01762 inline void set_ctype(::google::protobuf::FieldOptions_CType value); 01763 01764 // optional bool packed = 2; 01765 inline bool has_packed() const; 01766 inline void clear_packed(); 01767 static const int kPackedFieldNumber = 2; 01768 inline bool packed() const; 01769 inline void set_packed(bool value); 01770 01771 // optional bool deprecated = 3 [default = false]; 01772 inline bool has_deprecated() const; 01773 inline void clear_deprecated(); 01774 static const int kDeprecatedFieldNumber = 3; 01775 inline bool deprecated() const; 01776 inline void set_deprecated(bool value); 01777 01778 // optional string experimental_map_key = 9; 01779 inline bool has_experimental_map_key() const; 01780 inline void clear_experimental_map_key(); 01781 static const int kExperimentalMapKeyFieldNumber = 9; 01782 inline const ::std::string& experimental_map_key() const; 01783 inline void set_experimental_map_key(const ::std::string& value); 01784 inline void set_experimental_map_key(const char* value); 01785 inline void set_experimental_map_key(const char* value, size_t size); 01786 inline ::std::string* mutable_experimental_map_key(); 01787 01788 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 01789 inline int uninterpreted_option_size() const; 01790 inline void clear_uninterpreted_option(); 01791 static const int kUninterpretedOptionFieldNumber = 999; 01792 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 01793 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 01794 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 01795 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 01796 uninterpreted_option() const; 01797 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 01798 mutable_uninterpreted_option(); 01799 01800 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FieldOptions) 01801 // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions) 01802 private: 01803 ::google::protobuf::internal::ExtensionSet _extensions_; 01804 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01805 mutable int _cached_size_; 01806 01807 int ctype_; 01808 bool packed_; 01809 bool deprecated_; 01810 ::std::string* experimental_map_key_; 01811 static const ::std::string _default_experimental_map_key_; 01812 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 01813 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01814 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01815 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01816 01817 ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32]; 01818 01819 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01820 inline bool _has_bit(int index) const { 01821 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01822 } 01823 inline void _set_bit(int index) { 01824 _has_bits_[index / 32] |= (1u << (index % 32)); 01825 } 01826 inline void _clear_bit(int index) { 01827 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01828 } 01829 01830 void InitAsDefaultInstance(); 01831 static FieldOptions* default_instance_; 01832 }; 01833 // ------------------------------------------------------------------- 01834 01835 class LIBPROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message { 01836 public: 01837 EnumOptions(); 01838 virtual ~EnumOptions(); 01839 01840 EnumOptions(const EnumOptions& from); 01841 01842 inline EnumOptions& operator=(const EnumOptions& from) { 01843 CopyFrom(from); 01844 return *this; 01845 } 01846 01847 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01848 return _unknown_fields_; 01849 } 01850 01851 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01852 return &_unknown_fields_; 01853 } 01854 01855 static const ::google::protobuf::Descriptor* descriptor(); 01856 static const EnumOptions& default_instance(); 01857 01858 void Swap(EnumOptions* other); 01859 01860 // implements Message ---------------------------------------------- 01861 01862 EnumOptions* New() const; 01863 void CopyFrom(const ::google::protobuf::Message& from); 01864 void MergeFrom(const ::google::protobuf::Message& from); 01865 void CopyFrom(const EnumOptions& from); 01866 void MergeFrom(const EnumOptions& from); 01867 void Clear(); 01868 bool IsInitialized() const; 01869 01870 int ByteSize() const; 01871 bool MergePartialFromCodedStream( 01872 ::google::protobuf::io::CodedInputStream* input); 01873 void SerializeWithCachedSizes( 01874 ::google::protobuf::io::CodedOutputStream* output) const; 01875 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01876 int GetCachedSize() const { return _cached_size_; } 01877 private: 01878 void SharedCtor(); 01879 void SharedDtor(); 01880 void SetCachedSize(int size) const; 01881 public: 01882 01883 ::google::protobuf::Metadata GetMetadata() const; 01884 01885 // nested types ---------------------------------------------------- 01886 01887 // accessors ------------------------------------------------------- 01888 01889 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 01890 inline int uninterpreted_option_size() const; 01891 inline void clear_uninterpreted_option(); 01892 static const int kUninterpretedOptionFieldNumber = 999; 01893 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 01894 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 01895 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 01896 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 01897 uninterpreted_option() const; 01898 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 01899 mutable_uninterpreted_option(); 01900 01901 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumOptions) 01902 // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions) 01903 private: 01904 ::google::protobuf::internal::ExtensionSet _extensions_; 01905 ::google::protobuf::UnknownFieldSet _unknown_fields_; 01906 mutable int _cached_size_; 01907 01908 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 01909 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01910 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 01911 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 01912 01913 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 01914 01915 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 01916 inline bool _has_bit(int index) const { 01917 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 01918 } 01919 inline void _set_bit(int index) { 01920 _has_bits_[index / 32] |= (1u << (index % 32)); 01921 } 01922 inline void _clear_bit(int index) { 01923 _has_bits_[index / 32] &= ~(1u << (index % 32)); 01924 } 01925 01926 void InitAsDefaultInstance(); 01927 static EnumOptions* default_instance_; 01928 }; 01929 // ------------------------------------------------------------------- 01930 01931 class LIBPROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message { 01932 public: 01933 EnumValueOptions(); 01934 virtual ~EnumValueOptions(); 01935 01936 EnumValueOptions(const EnumValueOptions& from); 01937 01938 inline EnumValueOptions& operator=(const EnumValueOptions& from) { 01939 CopyFrom(from); 01940 return *this; 01941 } 01942 01943 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 01944 return _unknown_fields_; 01945 } 01946 01947 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 01948 return &_unknown_fields_; 01949 } 01950 01951 static const ::google::protobuf::Descriptor* descriptor(); 01952 static const EnumValueOptions& default_instance(); 01953 01954 void Swap(EnumValueOptions* other); 01955 01956 // implements Message ---------------------------------------------- 01957 01958 EnumValueOptions* New() const; 01959 void CopyFrom(const ::google::protobuf::Message& from); 01960 void MergeFrom(const ::google::protobuf::Message& from); 01961 void CopyFrom(const EnumValueOptions& from); 01962 void MergeFrom(const EnumValueOptions& from); 01963 void Clear(); 01964 bool IsInitialized() const; 01965 01966 int ByteSize() const; 01967 bool MergePartialFromCodedStream( 01968 ::google::protobuf::io::CodedInputStream* input); 01969 void SerializeWithCachedSizes( 01970 ::google::protobuf::io::CodedOutputStream* output) const; 01971 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 01972 int GetCachedSize() const { return _cached_size_; } 01973 private: 01974 void SharedCtor(); 01975 void SharedDtor(); 01976 void SetCachedSize(int size) const; 01977 public: 01978 01979 ::google::protobuf::Metadata GetMetadata() const; 01980 01981 // nested types ---------------------------------------------------- 01982 01983 // accessors ------------------------------------------------------- 01984 01985 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 01986 inline int uninterpreted_option_size() const; 01987 inline void clear_uninterpreted_option(); 01988 static const int kUninterpretedOptionFieldNumber = 999; 01989 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 01990 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 01991 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 01992 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 01993 uninterpreted_option() const; 01994 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 01995 mutable_uninterpreted_option(); 01996 01997 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumValueOptions) 01998 // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions) 01999 private: 02000 ::google::protobuf::internal::ExtensionSet _extensions_; 02001 ::google::protobuf::UnknownFieldSet _unknown_fields_; 02002 mutable int _cached_size_; 02003 02004 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 02005 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02006 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02007 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 02008 02009 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 02010 02011 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 02012 inline bool _has_bit(int index) const { 02013 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 02014 } 02015 inline void _set_bit(int index) { 02016 _has_bits_[index / 32] |= (1u << (index % 32)); 02017 } 02018 inline void _clear_bit(int index) { 02019 _has_bits_[index / 32] &= ~(1u << (index % 32)); 02020 } 02021 02022 void InitAsDefaultInstance(); 02023 static EnumValueOptions* default_instance_; 02024 }; 02025 // ------------------------------------------------------------------- 02026 02027 class LIBPROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message { 02028 public: 02029 ServiceOptions(); 02030 virtual ~ServiceOptions(); 02031 02032 ServiceOptions(const ServiceOptions& from); 02033 02034 inline ServiceOptions& operator=(const ServiceOptions& from) { 02035 CopyFrom(from); 02036 return *this; 02037 } 02038 02039 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 02040 return _unknown_fields_; 02041 } 02042 02043 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 02044 return &_unknown_fields_; 02045 } 02046 02047 static const ::google::protobuf::Descriptor* descriptor(); 02048 static const ServiceOptions& default_instance(); 02049 02050 void Swap(ServiceOptions* other); 02051 02052 // implements Message ---------------------------------------------- 02053 02054 ServiceOptions* New() const; 02055 void CopyFrom(const ::google::protobuf::Message& from); 02056 void MergeFrom(const ::google::protobuf::Message& from); 02057 void CopyFrom(const ServiceOptions& from); 02058 void MergeFrom(const ServiceOptions& from); 02059 void Clear(); 02060 bool IsInitialized() const; 02061 02062 int ByteSize() const; 02063 bool MergePartialFromCodedStream( 02064 ::google::protobuf::io::CodedInputStream* input); 02065 void SerializeWithCachedSizes( 02066 ::google::protobuf::io::CodedOutputStream* output) const; 02067 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 02068 int GetCachedSize() const { return _cached_size_; } 02069 private: 02070 void SharedCtor(); 02071 void SharedDtor(); 02072 void SetCachedSize(int size) const; 02073 public: 02074 02075 ::google::protobuf::Metadata GetMetadata() const; 02076 02077 // nested types ---------------------------------------------------- 02078 02079 // accessors ------------------------------------------------------- 02080 02081 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 02082 inline int uninterpreted_option_size() const; 02083 inline void clear_uninterpreted_option(); 02084 static const int kUninterpretedOptionFieldNumber = 999; 02085 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 02086 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 02087 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 02088 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 02089 uninterpreted_option() const; 02090 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 02091 mutable_uninterpreted_option(); 02092 02093 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ServiceOptions) 02094 // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions) 02095 private: 02096 ::google::protobuf::internal::ExtensionSet _extensions_; 02097 ::google::protobuf::UnknownFieldSet _unknown_fields_; 02098 mutable int _cached_size_; 02099 02100 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 02101 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02102 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02103 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 02104 02105 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 02106 02107 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 02108 inline bool _has_bit(int index) const { 02109 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 02110 } 02111 inline void _set_bit(int index) { 02112 _has_bits_[index / 32] |= (1u << (index % 32)); 02113 } 02114 inline void _clear_bit(int index) { 02115 _has_bits_[index / 32] &= ~(1u << (index % 32)); 02116 } 02117 02118 void InitAsDefaultInstance(); 02119 static ServiceOptions* default_instance_; 02120 }; 02121 // ------------------------------------------------------------------- 02122 02123 class LIBPROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message { 02124 public: 02125 MethodOptions(); 02126 virtual ~MethodOptions(); 02127 02128 MethodOptions(const MethodOptions& from); 02129 02130 inline MethodOptions& operator=(const MethodOptions& from) { 02131 CopyFrom(from); 02132 return *this; 02133 } 02134 02135 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 02136 return _unknown_fields_; 02137 } 02138 02139 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 02140 return &_unknown_fields_; 02141 } 02142 02143 static const ::google::protobuf::Descriptor* descriptor(); 02144 static const MethodOptions& default_instance(); 02145 02146 void Swap(MethodOptions* other); 02147 02148 // implements Message ---------------------------------------------- 02149 02150 MethodOptions* New() const; 02151 void CopyFrom(const ::google::protobuf::Message& from); 02152 void MergeFrom(const ::google::protobuf::Message& from); 02153 void CopyFrom(const MethodOptions& from); 02154 void MergeFrom(const MethodOptions& from); 02155 void Clear(); 02156 bool IsInitialized() const; 02157 02158 int ByteSize() const; 02159 bool MergePartialFromCodedStream( 02160 ::google::protobuf::io::CodedInputStream* input); 02161 void SerializeWithCachedSizes( 02162 ::google::protobuf::io::CodedOutputStream* output) const; 02163 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 02164 int GetCachedSize() const { return _cached_size_; } 02165 private: 02166 void SharedCtor(); 02167 void SharedDtor(); 02168 void SetCachedSize(int size) const; 02169 public: 02170 02171 ::google::protobuf::Metadata GetMetadata() const; 02172 02173 // nested types ---------------------------------------------------- 02174 02175 // accessors ------------------------------------------------------- 02176 02177 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 02178 inline int uninterpreted_option_size() const; 02179 inline void clear_uninterpreted_option(); 02180 static const int kUninterpretedOptionFieldNumber = 999; 02181 inline const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const; 02182 inline ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index); 02183 inline ::google::protobuf::UninterpretedOption* add_uninterpreted_option(); 02184 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 02185 uninterpreted_option() const; 02186 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 02187 mutable_uninterpreted_option(); 02188 02189 GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MethodOptions) 02190 // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions) 02191 private: 02192 ::google::protobuf::internal::ExtensionSet _extensions_; 02193 ::google::protobuf::UnknownFieldSet _unknown_fields_; 02194 mutable int _cached_size_; 02195 02196 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_; 02197 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02198 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02199 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 02200 02201 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 02202 02203 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 02204 inline bool _has_bit(int index) const { 02205 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 02206 } 02207 inline void _set_bit(int index) { 02208 _has_bits_[index / 32] |= (1u << (index % 32)); 02209 } 02210 inline void _clear_bit(int index) { 02211 _has_bits_[index / 32] &= ~(1u << (index % 32)); 02212 } 02213 02214 void InitAsDefaultInstance(); 02215 static MethodOptions* default_instance_; 02216 }; 02217 // ------------------------------------------------------------------- 02218 02219 class LIBPROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf::Message { 02220 public: 02221 UninterpretedOption_NamePart(); 02222 virtual ~UninterpretedOption_NamePart(); 02223 02224 UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from); 02225 02226 inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) { 02227 CopyFrom(from); 02228 return *this; 02229 } 02230 02231 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 02232 return _unknown_fields_; 02233 } 02234 02235 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 02236 return &_unknown_fields_; 02237 } 02238 02239 static const ::google::protobuf::Descriptor* descriptor(); 02240 static const UninterpretedOption_NamePart& default_instance(); 02241 02242 void Swap(UninterpretedOption_NamePart* other); 02243 02244 // implements Message ---------------------------------------------- 02245 02246 UninterpretedOption_NamePart* New() const; 02247 void CopyFrom(const ::google::protobuf::Message& from); 02248 void MergeFrom(const ::google::protobuf::Message& from); 02249 void CopyFrom(const UninterpretedOption_NamePart& from); 02250 void MergeFrom(const UninterpretedOption_NamePart& from); 02251 void Clear(); 02252 bool IsInitialized() const; 02253 02254 int ByteSize() const; 02255 bool MergePartialFromCodedStream( 02256 ::google::protobuf::io::CodedInputStream* input); 02257 void SerializeWithCachedSizes( 02258 ::google::protobuf::io::CodedOutputStream* output) const; 02259 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 02260 int GetCachedSize() const { return _cached_size_; } 02261 private: 02262 void SharedCtor(); 02263 void SharedDtor(); 02264 void SetCachedSize(int size) const; 02265 public: 02266 02267 ::google::protobuf::Metadata GetMetadata() const; 02268 02269 // nested types ---------------------------------------------------- 02270 02271 // accessors ------------------------------------------------------- 02272 02273 // required string name_part = 1; 02274 inline bool has_name_part() const; 02275 inline void clear_name_part(); 02276 static const int kNamePartFieldNumber = 1; 02277 inline const ::std::string& name_part() const; 02278 inline void set_name_part(const ::std::string& value); 02279 inline void set_name_part(const char* value); 02280 inline void set_name_part(const char* value, size_t size); 02281 inline ::std::string* mutable_name_part(); 02282 02283 // required bool is_extension = 2; 02284 inline bool has_is_extension() const; 02285 inline void clear_is_extension(); 02286 static const int kIsExtensionFieldNumber = 2; 02287 inline bool is_extension() const; 02288 inline void set_is_extension(bool value); 02289 02290 // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart) 02291 private: 02292 ::google::protobuf::UnknownFieldSet _unknown_fields_; 02293 mutable int _cached_size_; 02294 02295 ::std::string* name_part_; 02296 static const ::std::string _default_name_part_; 02297 bool is_extension_; 02298 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02299 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02300 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 02301 02302 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 02303 02304 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 02305 inline bool _has_bit(int index) const { 02306 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 02307 } 02308 inline void _set_bit(int index) { 02309 _has_bits_[index / 32] |= (1u << (index % 32)); 02310 } 02311 inline void _clear_bit(int index) { 02312 _has_bits_[index / 32] &= ~(1u << (index % 32)); 02313 } 02314 02315 void InitAsDefaultInstance(); 02316 static UninterpretedOption_NamePart* default_instance_; 02317 }; 02318 // ------------------------------------------------------------------- 02319 02320 class LIBPROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message { 02321 public: 02322 UninterpretedOption(); 02323 virtual ~UninterpretedOption(); 02324 02325 UninterpretedOption(const UninterpretedOption& from); 02326 02327 inline UninterpretedOption& operator=(const UninterpretedOption& from) { 02328 CopyFrom(from); 02329 return *this; 02330 } 02331 02332 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 02333 return _unknown_fields_; 02334 } 02335 02336 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 02337 return &_unknown_fields_; 02338 } 02339 02340 static const ::google::protobuf::Descriptor* descriptor(); 02341 static const UninterpretedOption& default_instance(); 02342 02343 void Swap(UninterpretedOption* other); 02344 02345 // implements Message ---------------------------------------------- 02346 02347 UninterpretedOption* New() const; 02348 void CopyFrom(const ::google::protobuf::Message& from); 02349 void MergeFrom(const ::google::protobuf::Message& from); 02350 void CopyFrom(const UninterpretedOption& from); 02351 void MergeFrom(const UninterpretedOption& from); 02352 void Clear(); 02353 bool IsInitialized() const; 02354 02355 int ByteSize() const; 02356 bool MergePartialFromCodedStream( 02357 ::google::protobuf::io::CodedInputStream* input); 02358 void SerializeWithCachedSizes( 02359 ::google::protobuf::io::CodedOutputStream* output) const; 02360 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 02361 int GetCachedSize() const { return _cached_size_; } 02362 private: 02363 void SharedCtor(); 02364 void SharedDtor(); 02365 void SetCachedSize(int size) const; 02366 public: 02367 02368 ::google::protobuf::Metadata GetMetadata() const; 02369 02370 // nested types ---------------------------------------------------- 02371 02372 typedef UninterpretedOption_NamePart NamePart; 02373 02374 // accessors ------------------------------------------------------- 02375 02376 // repeated .google.protobuf.UninterpretedOption.NamePart name = 2; 02377 inline int name_size() const; 02378 inline void clear_name(); 02379 static const int kNameFieldNumber = 2; 02380 inline const ::google::protobuf::UninterpretedOption_NamePart& name(int index) const; 02381 inline ::google::protobuf::UninterpretedOption_NamePart* mutable_name(int index); 02382 inline ::google::protobuf::UninterpretedOption_NamePart* add_name(); 02383 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 02384 name() const; 02385 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 02386 mutable_name(); 02387 02388 // optional string identifier_value = 3; 02389 inline bool has_identifier_value() const; 02390 inline void clear_identifier_value(); 02391 static const int kIdentifierValueFieldNumber = 3; 02392 inline const ::std::string& identifier_value() const; 02393 inline void set_identifier_value(const ::std::string& value); 02394 inline void set_identifier_value(const char* value); 02395 inline void set_identifier_value(const char* value, size_t size); 02396 inline ::std::string* mutable_identifier_value(); 02397 02398 // optional uint64 positive_int_value = 4; 02399 inline bool has_positive_int_value() const; 02400 inline void clear_positive_int_value(); 02401 static const int kPositiveIntValueFieldNumber = 4; 02402 inline ::google::protobuf::uint64 positive_int_value() const; 02403 inline void set_positive_int_value(::google::protobuf::uint64 value); 02404 02405 // optional int64 negative_int_value = 5; 02406 inline bool has_negative_int_value() const; 02407 inline void clear_negative_int_value(); 02408 static const int kNegativeIntValueFieldNumber = 5; 02409 inline ::google::protobuf::int64 negative_int_value() const; 02410 inline void set_negative_int_value(::google::protobuf::int64 value); 02411 02412 // optional double double_value = 6; 02413 inline bool has_double_value() const; 02414 inline void clear_double_value(); 02415 static const int kDoubleValueFieldNumber = 6; 02416 inline double double_value() const; 02417 inline void set_double_value(double value); 02418 02419 // optional bytes string_value = 7; 02420 inline bool has_string_value() const; 02421 inline void clear_string_value(); 02422 static const int kStringValueFieldNumber = 7; 02423 inline const ::std::string& string_value() const; 02424 inline void set_string_value(const ::std::string& value); 02425 inline void set_string_value(const char* value); 02426 inline void set_string_value(const void* value, size_t size); 02427 inline ::std::string* mutable_string_value(); 02428 02429 // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption) 02430 private: 02431 ::google::protobuf::UnknownFieldSet _unknown_fields_; 02432 mutable int _cached_size_; 02433 02434 ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart > name_; 02435 ::std::string* identifier_value_; 02436 static const ::std::string _default_identifier_value_; 02437 ::google::protobuf::uint64 positive_int_value_; 02438 ::google::protobuf::int64 negative_int_value_; 02439 double double_value_; 02440 ::std::string* string_value_; 02441 static const ::std::string _default_string_value_; 02442 friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02443 friend void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto(); 02444 friend void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto(); 02445 02446 ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; 02447 02448 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 02449 inline bool _has_bit(int index) const { 02450 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 02451 } 02452 inline void _set_bit(int index) { 02453 _has_bits_[index / 32] |= (1u << (index % 32)); 02454 } 02455 inline void _clear_bit(int index) { 02456 _has_bits_[index / 32] &= ~(1u << (index % 32)); 02457 } 02458 02459 void InitAsDefaultInstance(); 02460 static UninterpretedOption* default_instance_; 02461 }; 02462 // =================================================================== 02463 02464 02465 // =================================================================== 02466 02467 // FileDescriptorSet 02468 02469 // repeated .google.protobuf.FileDescriptorProto file = 1; 02470 inline int FileDescriptorSet::file_size() const { 02471 return file_.size(); 02472 } 02473 inline void FileDescriptorSet::clear_file() { 02474 file_.Clear(); 02475 } 02476 inline const ::google::protobuf::FileDescriptorProto& FileDescriptorSet::file(int index) const { 02477 return file_.Get(index); 02478 } 02479 inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) { 02480 return file_.Mutable(index); 02481 } 02482 inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::add_file() { 02483 return file_.Add(); 02484 } 02485 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >& 02486 FileDescriptorSet::file() const { 02487 return file_; 02488 } 02489 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >* 02490 FileDescriptorSet::mutable_file() { 02491 return &file_; 02492 } 02493 02494 // ------------------------------------------------------------------- 02495 02496 // FileDescriptorProto 02497 02498 // optional string name = 1; 02499 inline bool FileDescriptorProto::has_name() const { 02500 return _has_bit(0); 02501 } 02502 inline void FileDescriptorProto::clear_name() { 02503 if (name_ != &_default_name_) { 02504 name_->clear(); 02505 } 02506 _clear_bit(0); 02507 } 02508 inline const ::std::string& FileDescriptorProto::name() const { 02509 return *name_; 02510 } 02511 inline void FileDescriptorProto::set_name(const ::std::string& value) { 02512 _set_bit(0); 02513 if (name_ == &_default_name_) { 02514 name_ = new ::std::string; 02515 } 02516 name_->assign(value); 02517 } 02518 inline void FileDescriptorProto::set_name(const char* value) { 02519 _set_bit(0); 02520 if (name_ == &_default_name_) { 02521 name_ = new ::std::string; 02522 } 02523 name_->assign(value); 02524 } 02525 inline void FileDescriptorProto::set_name(const char* value, size_t size) { 02526 _set_bit(0); 02527 if (name_ == &_default_name_) { 02528 name_ = new ::std::string; 02529 } 02530 name_->assign(reinterpret_cast<const char*>(value), size); 02531 } 02532 inline ::std::string* FileDescriptorProto::mutable_name() { 02533 _set_bit(0); 02534 if (name_ == &_default_name_) { 02535 name_ = new ::std::string; 02536 } 02537 return name_; 02538 } 02539 02540 // optional string package = 2; 02541 inline bool FileDescriptorProto::has_package() const { 02542 return _has_bit(1); 02543 } 02544 inline void FileDescriptorProto::clear_package() { 02545 if (package_ != &_default_package_) { 02546 package_->clear(); 02547 } 02548 _clear_bit(1); 02549 } 02550 inline const ::std::string& FileDescriptorProto::package() const { 02551 return *package_; 02552 } 02553 inline void FileDescriptorProto::set_package(const ::std::string& value) { 02554 _set_bit(1); 02555 if (package_ == &_default_package_) { 02556 package_ = new ::std::string; 02557 } 02558 package_->assign(value); 02559 } 02560 inline void FileDescriptorProto::set_package(const char* value) { 02561 _set_bit(1); 02562 if (package_ == &_default_package_) { 02563 package_ = new ::std::string; 02564 } 02565 package_->assign(value); 02566 } 02567 inline void FileDescriptorProto::set_package(const char* value, size_t size) { 02568 _set_bit(1); 02569 if (package_ == &_default_package_) { 02570 package_ = new ::std::string; 02571 } 02572 package_->assign(reinterpret_cast<const char*>(value), size); 02573 } 02574 inline ::std::string* FileDescriptorProto::mutable_package() { 02575 _set_bit(1); 02576 if (package_ == &_default_package_) { 02577 package_ = new ::std::string; 02578 } 02579 return package_; 02580 } 02581 02582 // repeated string dependency = 3; 02583 inline int FileDescriptorProto::dependency_size() const { 02584 return dependency_.size(); 02585 } 02586 inline void FileDescriptorProto::clear_dependency() { 02587 dependency_.Clear(); 02588 } 02589 inline const ::std::string& FileDescriptorProto::dependency(int index) const { 02590 return dependency_.Get(index); 02591 } 02592 inline ::std::string* FileDescriptorProto::mutable_dependency(int index) { 02593 return dependency_.Mutable(index); 02594 } 02595 inline void FileDescriptorProto::set_dependency(int index, const ::std::string& value) { 02596 dependency_.Mutable(index)->assign(value); 02597 } 02598 inline void FileDescriptorProto::set_dependency(int index, const char* value) { 02599 dependency_.Mutable(index)->assign(value); 02600 } 02601 inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) { 02602 dependency_.Mutable(index)->assign( 02603 reinterpret_cast<const char*>(value), size); 02604 } 02605 inline ::std::string* FileDescriptorProto::add_dependency() { 02606 return dependency_.Add(); 02607 } 02608 inline void FileDescriptorProto::add_dependency(const ::std::string& value) { 02609 dependency_.Add()->assign(value); 02610 } 02611 inline void FileDescriptorProto::add_dependency(const char* value) { 02612 dependency_.Add()->assign(value); 02613 } 02614 inline void FileDescriptorProto::add_dependency(const char* value, size_t size) { 02615 dependency_.Add()->assign(reinterpret_cast<const char*>(value), size); 02616 } 02617 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& 02618 FileDescriptorProto::dependency() const { 02619 return dependency_; 02620 } 02621 inline ::google::protobuf::RepeatedPtrField< ::std::string>* 02622 FileDescriptorProto::mutable_dependency() { 02623 return &dependency_; 02624 } 02625 02626 // repeated .google.protobuf.DescriptorProto message_type = 4; 02627 inline int FileDescriptorProto::message_type_size() const { 02628 return message_type_.size(); 02629 } 02630 inline void FileDescriptorProto::clear_message_type() { 02631 message_type_.Clear(); 02632 } 02633 inline const ::google::protobuf::DescriptorProto& FileDescriptorProto::message_type(int index) const { 02634 return message_type_.Get(index); 02635 } 02636 inline ::google::protobuf::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) { 02637 return message_type_.Mutable(index); 02638 } 02639 inline ::google::protobuf::DescriptorProto* FileDescriptorProto::add_message_type() { 02640 return message_type_.Add(); 02641 } 02642 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 02643 FileDescriptorProto::message_type() const { 02644 return message_type_; 02645 } 02646 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 02647 FileDescriptorProto::mutable_message_type() { 02648 return &message_type_; 02649 } 02650 02651 // repeated .google.protobuf.EnumDescriptorProto enum_type = 5; 02652 inline int FileDescriptorProto::enum_type_size() const { 02653 return enum_type_.size(); 02654 } 02655 inline void FileDescriptorProto::clear_enum_type() { 02656 enum_type_.Clear(); 02657 } 02658 inline const ::google::protobuf::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const { 02659 return enum_type_.Get(index); 02660 } 02661 inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) { 02662 return enum_type_.Mutable(index); 02663 } 02664 inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::add_enum_type() { 02665 return enum_type_.Add(); 02666 } 02667 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 02668 FileDescriptorProto::enum_type() const { 02669 return enum_type_; 02670 } 02671 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 02672 FileDescriptorProto::mutable_enum_type() { 02673 return &enum_type_; 02674 } 02675 02676 // repeated .google.protobuf.ServiceDescriptorProto service = 6; 02677 inline int FileDescriptorProto::service_size() const { 02678 return service_.size(); 02679 } 02680 inline void FileDescriptorProto::clear_service() { 02681 service_.Clear(); 02682 } 02683 inline const ::google::protobuf::ServiceDescriptorProto& FileDescriptorProto::service(int index) const { 02684 return service_.Get(index); 02685 } 02686 inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) { 02687 return service_.Mutable(index); 02688 } 02689 inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::add_service() { 02690 return service_.Add(); 02691 } 02692 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >& 02693 FileDescriptorProto::service() const { 02694 return service_; 02695 } 02696 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >* 02697 FileDescriptorProto::mutable_service() { 02698 return &service_; 02699 } 02700 02701 // repeated .google.protobuf.FieldDescriptorProto extension = 7; 02702 inline int FileDescriptorProto::extension_size() const { 02703 return extension_.size(); 02704 } 02705 inline void FileDescriptorProto::clear_extension() { 02706 extension_.Clear(); 02707 } 02708 inline const ::google::protobuf::FieldDescriptorProto& FileDescriptorProto::extension(int index) const { 02709 return extension_.Get(index); 02710 } 02711 inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) { 02712 return extension_.Mutable(index); 02713 } 02714 inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::add_extension() { 02715 return extension_.Add(); 02716 } 02717 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 02718 FileDescriptorProto::extension() const { 02719 return extension_; 02720 } 02721 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 02722 FileDescriptorProto::mutable_extension() { 02723 return &extension_; 02724 } 02725 02726 // optional .google.protobuf.FileOptions options = 8; 02727 inline bool FileDescriptorProto::has_options() const { 02728 return _has_bit(7); 02729 } 02730 inline void FileDescriptorProto::clear_options() { 02731 if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear(); 02732 _clear_bit(7); 02733 } 02734 inline const ::google::protobuf::FileOptions& FileDescriptorProto::options() const { 02735 return options_ != NULL ? *options_ : *default_instance_->options_; 02736 } 02737 inline ::google::protobuf::FileOptions* FileDescriptorProto::mutable_options() { 02738 _set_bit(7); 02739 if (options_ == NULL) options_ = new ::google::protobuf::FileOptions; 02740 return options_; 02741 } 02742 02743 // ------------------------------------------------------------------- 02744 02745 // DescriptorProto_ExtensionRange 02746 02747 // optional int32 start = 1; 02748 inline bool DescriptorProto_ExtensionRange::has_start() const { 02749 return _has_bit(0); 02750 } 02751 inline void DescriptorProto_ExtensionRange::clear_start() { 02752 start_ = 0; 02753 _clear_bit(0); 02754 } 02755 inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::start() const { 02756 return start_; 02757 } 02758 inline void DescriptorProto_ExtensionRange::set_start(::google::protobuf::int32 value) { 02759 _set_bit(0); 02760 start_ = value; 02761 } 02762 02763 // optional int32 end = 2; 02764 inline bool DescriptorProto_ExtensionRange::has_end() const { 02765 return _has_bit(1); 02766 } 02767 inline void DescriptorProto_ExtensionRange::clear_end() { 02768 end_ = 0; 02769 _clear_bit(1); 02770 } 02771 inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::end() const { 02772 return end_; 02773 } 02774 inline void DescriptorProto_ExtensionRange::set_end(::google::protobuf::int32 value) { 02775 _set_bit(1); 02776 end_ = value; 02777 } 02778 02779 // ------------------------------------------------------------------- 02780 02781 // DescriptorProto 02782 02783 // optional string name = 1; 02784 inline bool DescriptorProto::has_name() const { 02785 return _has_bit(0); 02786 } 02787 inline void DescriptorProto::clear_name() { 02788 if (name_ != &_default_name_) { 02789 name_->clear(); 02790 } 02791 _clear_bit(0); 02792 } 02793 inline const ::std::string& DescriptorProto::name() const { 02794 return *name_; 02795 } 02796 inline void DescriptorProto::set_name(const ::std::string& value) { 02797 _set_bit(0); 02798 if (name_ == &_default_name_) { 02799 name_ = new ::std::string; 02800 } 02801 name_->assign(value); 02802 } 02803 inline void DescriptorProto::set_name(const char* value) { 02804 _set_bit(0); 02805 if (name_ == &_default_name_) { 02806 name_ = new ::std::string; 02807 } 02808 name_->assign(value); 02809 } 02810 inline void DescriptorProto::set_name(const char* value, size_t size) { 02811 _set_bit(0); 02812 if (name_ == &_default_name_) { 02813 name_ = new ::std::string; 02814 } 02815 name_->assign(reinterpret_cast<const char*>(value), size); 02816 } 02817 inline ::std::string* DescriptorProto::mutable_name() { 02818 _set_bit(0); 02819 if (name_ == &_default_name_) { 02820 name_ = new ::std::string; 02821 } 02822 return name_; 02823 } 02824 02825 // repeated .google.protobuf.FieldDescriptorProto field = 2; 02826 inline int DescriptorProto::field_size() const { 02827 return field_.size(); 02828 } 02829 inline void DescriptorProto::clear_field() { 02830 field_.Clear(); 02831 } 02832 inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::field(int index) const { 02833 return field_.Get(index); 02834 } 02835 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_field(int index) { 02836 return field_.Mutable(index); 02837 } 02838 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_field() { 02839 return field_.Add(); 02840 } 02841 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 02842 DescriptorProto::field() const { 02843 return field_; 02844 } 02845 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 02846 DescriptorProto::mutable_field() { 02847 return &field_; 02848 } 02849 02850 // repeated .google.protobuf.FieldDescriptorProto extension = 6; 02851 inline int DescriptorProto::extension_size() const { 02852 return extension_.size(); 02853 } 02854 inline void DescriptorProto::clear_extension() { 02855 extension_.Clear(); 02856 } 02857 inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::extension(int index) const { 02858 return extension_.Get(index); 02859 } 02860 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) { 02861 return extension_.Mutable(index); 02862 } 02863 inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_extension() { 02864 return extension_.Add(); 02865 } 02866 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >& 02867 DescriptorProto::extension() const { 02868 return extension_; 02869 } 02870 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >* 02871 DescriptorProto::mutable_extension() { 02872 return &extension_; 02873 } 02874 02875 // repeated .google.protobuf.DescriptorProto nested_type = 3; 02876 inline int DescriptorProto::nested_type_size() const { 02877 return nested_type_.size(); 02878 } 02879 inline void DescriptorProto::clear_nested_type() { 02880 nested_type_.Clear(); 02881 } 02882 inline const ::google::protobuf::DescriptorProto& DescriptorProto::nested_type(int index) const { 02883 return nested_type_.Get(index); 02884 } 02885 inline ::google::protobuf::DescriptorProto* DescriptorProto::mutable_nested_type(int index) { 02886 return nested_type_.Mutable(index); 02887 } 02888 inline ::google::protobuf::DescriptorProto* DescriptorProto::add_nested_type() { 02889 return nested_type_.Add(); 02890 } 02891 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >& 02892 DescriptorProto::nested_type() const { 02893 return nested_type_; 02894 } 02895 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >* 02896 DescriptorProto::mutable_nested_type() { 02897 return &nested_type_; 02898 } 02899 02900 // repeated .google.protobuf.EnumDescriptorProto enum_type = 4; 02901 inline int DescriptorProto::enum_type_size() const { 02902 return enum_type_.size(); 02903 } 02904 inline void DescriptorProto::clear_enum_type() { 02905 enum_type_.Clear(); 02906 } 02907 inline const ::google::protobuf::EnumDescriptorProto& DescriptorProto::enum_type(int index) const { 02908 return enum_type_.Get(index); 02909 } 02910 inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) { 02911 return enum_type_.Mutable(index); 02912 } 02913 inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::add_enum_type() { 02914 return enum_type_.Add(); 02915 } 02916 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >& 02917 DescriptorProto::enum_type() const { 02918 return enum_type_; 02919 } 02920 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >* 02921 DescriptorProto::mutable_enum_type() { 02922 return &enum_type_; 02923 } 02924 02925 // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5; 02926 inline int DescriptorProto::extension_range_size() const { 02927 return extension_range_.size(); 02928 } 02929 inline void DescriptorProto::clear_extension_range() { 02930 extension_range_.Clear(); 02931 } 02932 inline const ::google::protobuf::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const { 02933 return extension_range_.Get(index); 02934 } 02935 inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) { 02936 return extension_range_.Mutable(index); 02937 } 02938 inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() { 02939 return extension_range_.Add(); 02940 } 02941 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >& 02942 DescriptorProto::extension_range() const { 02943 return extension_range_; 02944 } 02945 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >* 02946 DescriptorProto::mutable_extension_range() { 02947 return &extension_range_; 02948 } 02949 02950 // optional .google.protobuf.MessageOptions options = 7; 02951 inline bool DescriptorProto::has_options() const { 02952 return _has_bit(6); 02953 } 02954 inline void DescriptorProto::clear_options() { 02955 if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear(); 02956 _clear_bit(6); 02957 } 02958 inline const ::google::protobuf::MessageOptions& DescriptorProto::options() const { 02959 return options_ != NULL ? *options_ : *default_instance_->options_; 02960 } 02961 inline ::google::protobuf::MessageOptions* DescriptorProto::mutable_options() { 02962 _set_bit(6); 02963 if (options_ == NULL) options_ = new ::google::protobuf::MessageOptions; 02964 return options_; 02965 } 02966 02967 // ------------------------------------------------------------------- 02968 02969 // FieldDescriptorProto 02970 02971 // optional string name = 1; 02972 inline bool FieldDescriptorProto::has_name() const { 02973 return _has_bit(0); 02974 } 02975 inline void FieldDescriptorProto::clear_name() { 02976 if (name_ != &_default_name_) { 02977 name_->clear(); 02978 } 02979 _clear_bit(0); 02980 } 02981 inline const ::std::string& FieldDescriptorProto::name() const { 02982 return *name_; 02983 } 02984 inline void FieldDescriptorProto::set_name(const ::std::string& value) { 02985 _set_bit(0); 02986 if (name_ == &_default_name_) { 02987 name_ = new ::std::string; 02988 } 02989 name_->assign(value); 02990 } 02991 inline void FieldDescriptorProto::set_name(const char* value) { 02992 _set_bit(0); 02993 if (name_ == &_default_name_) { 02994 name_ = new ::std::string; 02995 } 02996 name_->assign(value); 02997 } 02998 inline void FieldDescriptorProto::set_name(const char* value, size_t size) { 02999 _set_bit(0); 03000 if (name_ == &_default_name_) { 03001 name_ = new ::std::string; 03002 } 03003 name_->assign(reinterpret_cast<const char*>(value), size); 03004 } 03005 inline ::std::string* FieldDescriptorProto::mutable_name() { 03006 _set_bit(0); 03007 if (name_ == &_default_name_) { 03008 name_ = new ::std::string; 03009 } 03010 return name_; 03011 } 03012 03013 // optional int32 number = 3; 03014 inline bool FieldDescriptorProto::has_number() const { 03015 return _has_bit(1); 03016 } 03017 inline void FieldDescriptorProto::clear_number() { 03018 number_ = 0; 03019 _clear_bit(1); 03020 } 03021 inline ::google::protobuf::int32 FieldDescriptorProto::number() const { 03022 return number_; 03023 } 03024 inline void FieldDescriptorProto::set_number(::google::protobuf::int32 value) { 03025 _set_bit(1); 03026 number_ = value; 03027 } 03028 03029 // optional .google.protobuf.FieldDescriptorProto.Label label = 4; 03030 inline bool FieldDescriptorProto::has_label() const { 03031 return _has_bit(2); 03032 } 03033 inline void FieldDescriptorProto::clear_label() { 03034 label_ = 1; 03035 _clear_bit(2); 03036 } 03037 inline ::google::protobuf::FieldDescriptorProto_Label FieldDescriptorProto::label() const { 03038 return static_cast< ::google::protobuf::FieldDescriptorProto_Label >(label_); 03039 } 03040 inline void FieldDescriptorProto::set_label(::google::protobuf::FieldDescriptorProto_Label value) { 03041 GOOGLE_DCHECK(::google::protobuf::FieldDescriptorProto_Label_IsValid(value)); 03042 _set_bit(2); 03043 label_ = value; 03044 } 03045 03046 // optional .google.protobuf.FieldDescriptorProto.Type type = 5; 03047 inline bool FieldDescriptorProto::has_type() const { 03048 return _has_bit(3); 03049 } 03050 inline void FieldDescriptorProto::clear_type() { 03051 type_ = 1; 03052 _clear_bit(3); 03053 } 03054 inline ::google::protobuf::FieldDescriptorProto_Type FieldDescriptorProto::type() const { 03055 return static_cast< ::google::protobuf::FieldDescriptorProto_Type >(type_); 03056 } 03057 inline void FieldDescriptorProto::set_type(::google::protobuf::FieldDescriptorProto_Type value) { 03058 GOOGLE_DCHECK(::google::protobuf::FieldDescriptorProto_Type_IsValid(value)); 03059 _set_bit(3); 03060 type_ = value; 03061 } 03062 03063 // optional string type_name = 6; 03064 inline bool FieldDescriptorProto::has_type_name() const { 03065 return _has_bit(4); 03066 } 03067 inline void FieldDescriptorProto::clear_type_name() { 03068 if (type_name_ != &_default_type_name_) { 03069 type_name_->clear(); 03070 } 03071 _clear_bit(4); 03072 } 03073 inline const ::std::string& FieldDescriptorProto::type_name() const { 03074 return *type_name_; 03075 } 03076 inline void FieldDescriptorProto::set_type_name(const ::std::string& value) { 03077 _set_bit(4); 03078 if (type_name_ == &_default_type_name_) { 03079 type_name_ = new ::std::string; 03080 } 03081 type_name_->assign(value); 03082 } 03083 inline void FieldDescriptorProto::set_type_name(const char* value) { 03084 _set_bit(4); 03085 if (type_name_ == &_default_type_name_) { 03086 type_name_ = new ::std::string; 03087 } 03088 type_name_->assign(value); 03089 } 03090 inline void FieldDescriptorProto::set_type_name(const char* value, size_t size) { 03091 _set_bit(4); 03092 if (type_name_ == &_default_type_name_) { 03093 type_name_ = new ::std::string; 03094 } 03095 type_name_->assign(reinterpret_cast<const char*>(value), size); 03096 } 03097 inline ::std::string* FieldDescriptorProto::mutable_type_name() { 03098 _set_bit(4); 03099 if (type_name_ == &_default_type_name_) { 03100 type_name_ = new ::std::string; 03101 } 03102 return type_name_; 03103 } 03104 03105 // optional string extendee = 2; 03106 inline bool FieldDescriptorProto::has_extendee() const { 03107 return _has_bit(5); 03108 } 03109 inline void FieldDescriptorProto::clear_extendee() { 03110 if (extendee_ != &_default_extendee_) { 03111 extendee_->clear(); 03112 } 03113 _clear_bit(5); 03114 } 03115 inline const ::std::string& FieldDescriptorProto::extendee() const { 03116 return *extendee_; 03117 } 03118 inline void FieldDescriptorProto::set_extendee(const ::std::string& value) { 03119 _set_bit(5); 03120 if (extendee_ == &_default_extendee_) { 03121 extendee_ = new ::std::string; 03122 } 03123 extendee_->assign(value); 03124 } 03125 inline void FieldDescriptorProto::set_extendee(const char* value) { 03126 _set_bit(5); 03127 if (extendee_ == &_default_extendee_) { 03128 extendee_ = new ::std::string; 03129 } 03130 extendee_->assign(value); 03131 } 03132 inline void FieldDescriptorProto::set_extendee(const char* value, size_t size) { 03133 _set_bit(5); 03134 if (extendee_ == &_default_extendee_) { 03135 extendee_ = new ::std::string; 03136 } 03137 extendee_->assign(reinterpret_cast<const char*>(value), size); 03138 } 03139 inline ::std::string* FieldDescriptorProto::mutable_extendee() { 03140 _set_bit(5); 03141 if (extendee_ == &_default_extendee_) { 03142 extendee_ = new ::std::string; 03143 } 03144 return extendee_; 03145 } 03146 03147 // optional string default_value = 7; 03148 inline bool FieldDescriptorProto::has_default_value() const { 03149 return _has_bit(6); 03150 } 03151 inline void FieldDescriptorProto::clear_default_value() { 03152 if (default_value_ != &_default_default_value_) { 03153 default_value_->clear(); 03154 } 03155 _clear_bit(6); 03156 } 03157 inline const ::std::string& FieldDescriptorProto::default_value() const { 03158 return *default_value_; 03159 } 03160 inline void FieldDescriptorProto::set_default_value(const ::std::string& value) { 03161 _set_bit(6); 03162 if (default_value_ == &_default_default_value_) { 03163 default_value_ = new ::std::string; 03164 } 03165 default_value_->assign(value); 03166 } 03167 inline void FieldDescriptorProto::set_default_value(const char* value) { 03168 _set_bit(6); 03169 if (default_value_ == &_default_default_value_) { 03170 default_value_ = new ::std::string; 03171 } 03172 default_value_->assign(value); 03173 } 03174 inline void FieldDescriptorProto::set_default_value(const char* value, size_t size) { 03175 _set_bit(6); 03176 if (default_value_ == &_default_default_value_) { 03177 default_value_ = new ::std::string; 03178 } 03179 default_value_->assign(reinterpret_cast<const char*>(value), size); 03180 } 03181 inline ::std::string* FieldDescriptorProto::mutable_default_value() { 03182 _set_bit(6); 03183 if (default_value_ == &_default_default_value_) { 03184 default_value_ = new ::std::string; 03185 } 03186 return default_value_; 03187 } 03188 03189 // optional .google.protobuf.FieldOptions options = 8; 03190 inline bool FieldDescriptorProto::has_options() const { 03191 return _has_bit(7); 03192 } 03193 inline void FieldDescriptorProto::clear_options() { 03194 if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear(); 03195 _clear_bit(7); 03196 } 03197 inline const ::google::protobuf::FieldOptions& FieldDescriptorProto::options() const { 03198 return options_ != NULL ? *options_ : *default_instance_->options_; 03199 } 03200 inline ::google::protobuf::FieldOptions* FieldDescriptorProto::mutable_options() { 03201 _set_bit(7); 03202 if (options_ == NULL) options_ = new ::google::protobuf::FieldOptions; 03203 return options_; 03204 } 03205 03206 // ------------------------------------------------------------------- 03207 03208 // EnumDescriptorProto 03209 03210 // optional string name = 1; 03211 inline bool EnumDescriptorProto::has_name() const { 03212 return _has_bit(0); 03213 } 03214 inline void EnumDescriptorProto::clear_name() { 03215 if (name_ != &_default_name_) { 03216 name_->clear(); 03217 } 03218 _clear_bit(0); 03219 } 03220 inline const ::std::string& EnumDescriptorProto::name() const { 03221 return *name_; 03222 } 03223 inline void EnumDescriptorProto::set_name(const ::std::string& value) { 03224 _set_bit(0); 03225 if (name_ == &_default_name_) { 03226 name_ = new ::std::string; 03227 } 03228 name_->assign(value); 03229 } 03230 inline void EnumDescriptorProto::set_name(const char* value) { 03231 _set_bit(0); 03232 if (name_ == &_default_name_) { 03233 name_ = new ::std::string; 03234 } 03235 name_->assign(value); 03236 } 03237 inline void EnumDescriptorProto::set_name(const char* value, size_t size) { 03238 _set_bit(0); 03239 if (name_ == &_default_name_) { 03240 name_ = new ::std::string; 03241 } 03242 name_->assign(reinterpret_cast<const char*>(value), size); 03243 } 03244 inline ::std::string* EnumDescriptorProto::mutable_name() { 03245 _set_bit(0); 03246 if (name_ == &_default_name_) { 03247 name_ = new ::std::string; 03248 } 03249 return name_; 03250 } 03251 03252 // repeated .google.protobuf.EnumValueDescriptorProto value = 2; 03253 inline int EnumDescriptorProto::value_size() const { 03254 return value_.size(); 03255 } 03256 inline void EnumDescriptorProto::clear_value() { 03257 value_.Clear(); 03258 } 03259 inline const ::google::protobuf::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const { 03260 return value_.Get(index); 03261 } 03262 inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) { 03263 return value_.Mutable(index); 03264 } 03265 inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::add_value() { 03266 return value_.Add(); 03267 } 03268 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >& 03269 EnumDescriptorProto::value() const { 03270 return value_; 03271 } 03272 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >* 03273 EnumDescriptorProto::mutable_value() { 03274 return &value_; 03275 } 03276 03277 // optional .google.protobuf.EnumOptions options = 3; 03278 inline bool EnumDescriptorProto::has_options() const { 03279 return _has_bit(2); 03280 } 03281 inline void EnumDescriptorProto::clear_options() { 03282 if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear(); 03283 _clear_bit(2); 03284 } 03285 inline const ::google::protobuf::EnumOptions& EnumDescriptorProto::options() const { 03286 return options_ != NULL ? *options_ : *default_instance_->options_; 03287 } 03288 inline ::google::protobuf::EnumOptions* EnumDescriptorProto::mutable_options() { 03289 _set_bit(2); 03290 if (options_ == NULL) options_ = new ::google::protobuf::EnumOptions; 03291 return options_; 03292 } 03293 03294 // ------------------------------------------------------------------- 03295 03296 // EnumValueDescriptorProto 03297 03298 // optional string name = 1; 03299 inline bool EnumValueDescriptorProto::has_name() const { 03300 return _has_bit(0); 03301 } 03302 inline void EnumValueDescriptorProto::clear_name() { 03303 if (name_ != &_default_name_) { 03304 name_->clear(); 03305 } 03306 _clear_bit(0); 03307 } 03308 inline const ::std::string& EnumValueDescriptorProto::name() const { 03309 return *name_; 03310 } 03311 inline void EnumValueDescriptorProto::set_name(const ::std::string& value) { 03312 _set_bit(0); 03313 if (name_ == &_default_name_) { 03314 name_ = new ::std::string; 03315 } 03316 name_->assign(value); 03317 } 03318 inline void EnumValueDescriptorProto::set_name(const char* value) { 03319 _set_bit(0); 03320 if (name_ == &_default_name_) { 03321 name_ = new ::std::string; 03322 } 03323 name_->assign(value); 03324 } 03325 inline void EnumValueDescriptorProto::set_name(const char* value, size_t size) { 03326 _set_bit(0); 03327 if (name_ == &_default_name_) { 03328 name_ = new ::std::string; 03329 } 03330 name_->assign(reinterpret_cast<const char*>(value), size); 03331 } 03332 inline ::std::string* EnumValueDescriptorProto::mutable_name() { 03333 _set_bit(0); 03334 if (name_ == &_default_name_) { 03335 name_ = new ::std::string; 03336 } 03337 return name_; 03338 } 03339 03340 // optional int32 number = 2; 03341 inline bool EnumValueDescriptorProto::has_number() const { 03342 return _has_bit(1); 03343 } 03344 inline void EnumValueDescriptorProto::clear_number() { 03345 number_ = 0; 03346 _clear_bit(1); 03347 } 03348 inline ::google::protobuf::int32 EnumValueDescriptorProto::number() const { 03349 return number_; 03350 } 03351 inline void EnumValueDescriptorProto::set_number(::google::protobuf::int32 value) { 03352 _set_bit(1); 03353 number_ = value; 03354 } 03355 03356 // optional .google.protobuf.EnumValueOptions options = 3; 03357 inline bool EnumValueDescriptorProto::has_options() const { 03358 return _has_bit(2); 03359 } 03360 inline void EnumValueDescriptorProto::clear_options() { 03361 if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear(); 03362 _clear_bit(2); 03363 } 03364 inline const ::google::protobuf::EnumValueOptions& EnumValueDescriptorProto::options() const { 03365 return options_ != NULL ? *options_ : *default_instance_->options_; 03366 } 03367 inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::mutable_options() { 03368 _set_bit(2); 03369 if (options_ == NULL) options_ = new ::google::protobuf::EnumValueOptions; 03370 return options_; 03371 } 03372 03373 // ------------------------------------------------------------------- 03374 03375 // ServiceDescriptorProto 03376 03377 // optional string name = 1; 03378 inline bool ServiceDescriptorProto::has_name() const { 03379 return _has_bit(0); 03380 } 03381 inline void ServiceDescriptorProto::clear_name() { 03382 if (name_ != &_default_name_) { 03383 name_->clear(); 03384 } 03385 _clear_bit(0); 03386 } 03387 inline const ::std::string& ServiceDescriptorProto::name() const { 03388 return *name_; 03389 } 03390 inline void ServiceDescriptorProto::set_name(const ::std::string& value) { 03391 _set_bit(0); 03392 if (name_ == &_default_name_) { 03393 name_ = new ::std::string; 03394 } 03395 name_->assign(value); 03396 } 03397 inline void ServiceDescriptorProto::set_name(const char* value) { 03398 _set_bit(0); 03399 if (name_ == &_default_name_) { 03400 name_ = new ::std::string; 03401 } 03402 name_->assign(value); 03403 } 03404 inline void ServiceDescriptorProto::set_name(const char* value, size_t size) { 03405 _set_bit(0); 03406 if (name_ == &_default_name_) { 03407 name_ = new ::std::string; 03408 } 03409 name_->assign(reinterpret_cast<const char*>(value), size); 03410 } 03411 inline ::std::string* ServiceDescriptorProto::mutable_name() { 03412 _set_bit(0); 03413 if (name_ == &_default_name_) { 03414 name_ = new ::std::string; 03415 } 03416 return name_; 03417 } 03418 03419 // repeated .google.protobuf.MethodDescriptorProto method = 2; 03420 inline int ServiceDescriptorProto::method_size() const { 03421 return method_.size(); 03422 } 03423 inline void ServiceDescriptorProto::clear_method() { 03424 method_.Clear(); 03425 } 03426 inline const ::google::protobuf::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const { 03427 return method_.Get(index); 03428 } 03429 inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) { 03430 return method_.Mutable(index); 03431 } 03432 inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::add_method() { 03433 return method_.Add(); 03434 } 03435 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >& 03436 ServiceDescriptorProto::method() const { 03437 return method_; 03438 } 03439 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >* 03440 ServiceDescriptorProto::mutable_method() { 03441 return &method_; 03442 } 03443 03444 // optional .google.protobuf.ServiceOptions options = 3; 03445 inline bool ServiceDescriptorProto::has_options() const { 03446 return _has_bit(2); 03447 } 03448 inline void ServiceDescriptorProto::clear_options() { 03449 if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear(); 03450 _clear_bit(2); 03451 } 03452 inline const ::google::protobuf::ServiceOptions& ServiceDescriptorProto::options() const { 03453 return options_ != NULL ? *options_ : *default_instance_->options_; 03454 } 03455 inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::mutable_options() { 03456 _set_bit(2); 03457 if (options_ == NULL) options_ = new ::google::protobuf::ServiceOptions; 03458 return options_; 03459 } 03460 03461 // ------------------------------------------------------------------- 03462 03463 // MethodDescriptorProto 03464 03465 // optional string name = 1; 03466 inline bool MethodDescriptorProto::has_name() const { 03467 return _has_bit(0); 03468 } 03469 inline void MethodDescriptorProto::clear_name() { 03470 if (name_ != &_default_name_) { 03471 name_->clear(); 03472 } 03473 _clear_bit(0); 03474 } 03475 inline const ::std::string& MethodDescriptorProto::name() const { 03476 return *name_; 03477 } 03478 inline void MethodDescriptorProto::set_name(const ::std::string& value) { 03479 _set_bit(0); 03480 if (name_ == &_default_name_) { 03481 name_ = new ::std::string; 03482 } 03483 name_->assign(value); 03484 } 03485 inline void MethodDescriptorProto::set_name(const char* value) { 03486 _set_bit(0); 03487 if (name_ == &_default_name_) { 03488 name_ = new ::std::string; 03489 } 03490 name_->assign(value); 03491 } 03492 inline void MethodDescriptorProto::set_name(const char* value, size_t size) { 03493 _set_bit(0); 03494 if (name_ == &_default_name_) { 03495 name_ = new ::std::string; 03496 } 03497 name_->assign(reinterpret_cast<const char*>(value), size); 03498 } 03499 inline ::std::string* MethodDescriptorProto::mutable_name() { 03500 _set_bit(0); 03501 if (name_ == &_default_name_) { 03502 name_ = new ::std::string; 03503 } 03504 return name_; 03505 } 03506 03507 // optional string input_type = 2; 03508 inline bool MethodDescriptorProto::has_input_type() const { 03509 return _has_bit(1); 03510 } 03511 inline void MethodDescriptorProto::clear_input_type() { 03512 if (input_type_ != &_default_input_type_) { 03513 input_type_->clear(); 03514 } 03515 _clear_bit(1); 03516 } 03517 inline const ::std::string& MethodDescriptorProto::input_type() const { 03518 return *input_type_; 03519 } 03520 inline void MethodDescriptorProto::set_input_type(const ::std::string& value) { 03521 _set_bit(1); 03522 if (input_type_ == &_default_input_type_) { 03523 input_type_ = new ::std::string; 03524 } 03525 input_type_->assign(value); 03526 } 03527 inline void MethodDescriptorProto::set_input_type(const char* value) { 03528 _set_bit(1); 03529 if (input_type_ == &_default_input_type_) { 03530 input_type_ = new ::std::string; 03531 } 03532 input_type_->assign(value); 03533 } 03534 inline void MethodDescriptorProto::set_input_type(const char* value, size_t size) { 03535 _set_bit(1); 03536 if (input_type_ == &_default_input_type_) { 03537 input_type_ = new ::std::string; 03538 } 03539 input_type_->assign(reinterpret_cast<const char*>(value), size); 03540 } 03541 inline ::std::string* MethodDescriptorProto::mutable_input_type() { 03542 _set_bit(1); 03543 if (input_type_ == &_default_input_type_) { 03544 input_type_ = new ::std::string; 03545 } 03546 return input_type_; 03547 } 03548 03549 // optional string output_type = 3; 03550 inline bool MethodDescriptorProto::has_output_type() const { 03551 return _has_bit(2); 03552 } 03553 inline void MethodDescriptorProto::clear_output_type() { 03554 if (output_type_ != &_default_output_type_) { 03555 output_type_->clear(); 03556 } 03557 _clear_bit(2); 03558 } 03559 inline const ::std::string& MethodDescriptorProto::output_type() const { 03560 return *output_type_; 03561 } 03562 inline void MethodDescriptorProto::set_output_type(const ::std::string& value) { 03563 _set_bit(2); 03564 if (output_type_ == &_default_output_type_) { 03565 output_type_ = new ::std::string; 03566 } 03567 output_type_->assign(value); 03568 } 03569 inline void MethodDescriptorProto::set_output_type(const char* value) { 03570 _set_bit(2); 03571 if (output_type_ == &_default_output_type_) { 03572 output_type_ = new ::std::string; 03573 } 03574 output_type_->assign(value); 03575 } 03576 inline void MethodDescriptorProto::set_output_type(const char* value, size_t size) { 03577 _set_bit(2); 03578 if (output_type_ == &_default_output_type_) { 03579 output_type_ = new ::std::string; 03580 } 03581 output_type_->assign(reinterpret_cast<const char*>(value), size); 03582 } 03583 inline ::std::string* MethodDescriptorProto::mutable_output_type() { 03584 _set_bit(2); 03585 if (output_type_ == &_default_output_type_) { 03586 output_type_ = new ::std::string; 03587 } 03588 return output_type_; 03589 } 03590 03591 // optional .google.protobuf.MethodOptions options = 4; 03592 inline bool MethodDescriptorProto::has_options() const { 03593 return _has_bit(3); 03594 } 03595 inline void MethodDescriptorProto::clear_options() { 03596 if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear(); 03597 _clear_bit(3); 03598 } 03599 inline const ::google::protobuf::MethodOptions& MethodDescriptorProto::options() const { 03600 return options_ != NULL ? *options_ : *default_instance_->options_; 03601 } 03602 inline ::google::protobuf::MethodOptions* MethodDescriptorProto::mutable_options() { 03603 _set_bit(3); 03604 if (options_ == NULL) options_ = new ::google::protobuf::MethodOptions; 03605 return options_; 03606 } 03607 03608 // ------------------------------------------------------------------- 03609 03610 // FileOptions 03611 03612 // optional string java_package = 1; 03613 inline bool FileOptions::has_java_package() const { 03614 return _has_bit(0); 03615 } 03616 inline void FileOptions::clear_java_package() { 03617 if (java_package_ != &_default_java_package_) { 03618 java_package_->clear(); 03619 } 03620 _clear_bit(0); 03621 } 03622 inline const ::std::string& FileOptions::java_package() const { 03623 return *java_package_; 03624 } 03625 inline void FileOptions::set_java_package(const ::std::string& value) { 03626 _set_bit(0); 03627 if (java_package_ == &_default_java_package_) { 03628 java_package_ = new ::std::string; 03629 } 03630 java_package_->assign(value); 03631 } 03632 inline void FileOptions::set_java_package(const char* value) { 03633 _set_bit(0); 03634 if (java_package_ == &_default_java_package_) { 03635 java_package_ = new ::std::string; 03636 } 03637 java_package_->assign(value); 03638 } 03639 inline void FileOptions::set_java_package(const char* value, size_t size) { 03640 _set_bit(0); 03641 if (java_package_ == &_default_java_package_) { 03642 java_package_ = new ::std::string; 03643 } 03644 java_package_->assign(reinterpret_cast<const char*>(value), size); 03645 } 03646 inline ::std::string* FileOptions::mutable_java_package() { 03647 _set_bit(0); 03648 if (java_package_ == &_default_java_package_) { 03649 java_package_ = new ::std::string; 03650 } 03651 return java_package_; 03652 } 03653 03654 // optional string java_outer_classname = 8; 03655 inline bool FileOptions::has_java_outer_classname() const { 03656 return _has_bit(1); 03657 } 03658 inline void FileOptions::clear_java_outer_classname() { 03659 if (java_outer_classname_ != &_default_java_outer_classname_) { 03660 java_outer_classname_->clear(); 03661 } 03662 _clear_bit(1); 03663 } 03664 inline const ::std::string& FileOptions::java_outer_classname() const { 03665 return *java_outer_classname_; 03666 } 03667 inline void FileOptions::set_java_outer_classname(const ::std::string& value) { 03668 _set_bit(1); 03669 if (java_outer_classname_ == &_default_java_outer_classname_) { 03670 java_outer_classname_ = new ::std::string; 03671 } 03672 java_outer_classname_->assign(value); 03673 } 03674 inline void FileOptions::set_java_outer_classname(const char* value) { 03675 _set_bit(1); 03676 if (java_outer_classname_ == &_default_java_outer_classname_) { 03677 java_outer_classname_ = new ::std::string; 03678 } 03679 java_outer_classname_->assign(value); 03680 } 03681 inline void FileOptions::set_java_outer_classname(const char* value, size_t size) { 03682 _set_bit(1); 03683 if (java_outer_classname_ == &_default_java_outer_classname_) { 03684 java_outer_classname_ = new ::std::string; 03685 } 03686 java_outer_classname_->assign(reinterpret_cast<const char*>(value), size); 03687 } 03688 inline ::std::string* FileOptions::mutable_java_outer_classname() { 03689 _set_bit(1); 03690 if (java_outer_classname_ == &_default_java_outer_classname_) { 03691 java_outer_classname_ = new ::std::string; 03692 } 03693 return java_outer_classname_; 03694 } 03695 03696 // optional bool java_multiple_files = 10 [default = false]; 03697 inline bool FileOptions::has_java_multiple_files() const { 03698 return _has_bit(2); 03699 } 03700 inline void FileOptions::clear_java_multiple_files() { 03701 java_multiple_files_ = false; 03702 _clear_bit(2); 03703 } 03704 inline bool FileOptions::java_multiple_files() const { 03705 return java_multiple_files_; 03706 } 03707 inline void FileOptions::set_java_multiple_files(bool value) { 03708 _set_bit(2); 03709 java_multiple_files_ = value; 03710 } 03711 03712 // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED]; 03713 inline bool FileOptions::has_optimize_for() const { 03714 return _has_bit(3); 03715 } 03716 inline void FileOptions::clear_optimize_for() { 03717 optimize_for_ = 1; 03718 _clear_bit(3); 03719 } 03720 inline ::google::protobuf::FileOptions_OptimizeMode FileOptions::optimize_for() const { 03721 return static_cast< ::google::protobuf::FileOptions_OptimizeMode >(optimize_for_); 03722 } 03723 inline void FileOptions::set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value) { 03724 GOOGLE_DCHECK(::google::protobuf::FileOptions_OptimizeMode_IsValid(value)); 03725 _set_bit(3); 03726 optimize_for_ = value; 03727 } 03728 03729 // optional bool cc_generic_services = 16 [default = true]; 03730 inline bool FileOptions::has_cc_generic_services() const { 03731 return _has_bit(4); 03732 } 03733 inline void FileOptions::clear_cc_generic_services() { 03734 cc_generic_services_ = true; 03735 _clear_bit(4); 03736 } 03737 inline bool FileOptions::cc_generic_services() const { 03738 return cc_generic_services_; 03739 } 03740 inline void FileOptions::set_cc_generic_services(bool value) { 03741 _set_bit(4); 03742 cc_generic_services_ = value; 03743 } 03744 03745 // optional bool java_generic_services = 17 [default = true]; 03746 inline bool FileOptions::has_java_generic_services() const { 03747 return _has_bit(5); 03748 } 03749 inline void FileOptions::clear_java_generic_services() { 03750 java_generic_services_ = true; 03751 _clear_bit(5); 03752 } 03753 inline bool FileOptions::java_generic_services() const { 03754 return java_generic_services_; 03755 } 03756 inline void FileOptions::set_java_generic_services(bool value) { 03757 _set_bit(5); 03758 java_generic_services_ = value; 03759 } 03760 03761 // optional bool py_generic_services = 18 [default = true]; 03762 inline bool FileOptions::has_py_generic_services() const { 03763 return _has_bit(6); 03764 } 03765 inline void FileOptions::clear_py_generic_services() { 03766 py_generic_services_ = true; 03767 _clear_bit(6); 03768 } 03769 inline bool FileOptions::py_generic_services() const { 03770 return py_generic_services_; 03771 } 03772 inline void FileOptions::set_py_generic_services(bool value) { 03773 _set_bit(6); 03774 py_generic_services_ = value; 03775 } 03776 03777 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 03778 inline int FileOptions::uninterpreted_option_size() const { 03779 return uninterpreted_option_.size(); 03780 } 03781 inline void FileOptions::clear_uninterpreted_option() { 03782 uninterpreted_option_.Clear(); 03783 } 03784 inline const ::google::protobuf::UninterpretedOption& FileOptions::uninterpreted_option(int index) const { 03785 return uninterpreted_option_.Get(index); 03786 } 03787 inline ::google::protobuf::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) { 03788 return uninterpreted_option_.Mutable(index); 03789 } 03790 inline ::google::protobuf::UninterpretedOption* FileOptions::add_uninterpreted_option() { 03791 return uninterpreted_option_.Add(); 03792 } 03793 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 03794 FileOptions::uninterpreted_option() const { 03795 return uninterpreted_option_; 03796 } 03797 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 03798 FileOptions::mutable_uninterpreted_option() { 03799 return &uninterpreted_option_; 03800 } 03801 03802 // ------------------------------------------------------------------- 03803 03804 // MessageOptions 03805 03806 // optional bool message_set_wire_format = 1 [default = false]; 03807 inline bool MessageOptions::has_message_set_wire_format() const { 03808 return _has_bit(0); 03809 } 03810 inline void MessageOptions::clear_message_set_wire_format() { 03811 message_set_wire_format_ = false; 03812 _clear_bit(0); 03813 } 03814 inline bool MessageOptions::message_set_wire_format() const { 03815 return message_set_wire_format_; 03816 } 03817 inline void MessageOptions::set_message_set_wire_format(bool value) { 03818 _set_bit(0); 03819 message_set_wire_format_ = value; 03820 } 03821 03822 // optional bool no_standard_descriptor_accessor = 2 [default = false]; 03823 inline bool MessageOptions::has_no_standard_descriptor_accessor() const { 03824 return _has_bit(1); 03825 } 03826 inline void MessageOptions::clear_no_standard_descriptor_accessor() { 03827 no_standard_descriptor_accessor_ = false; 03828 _clear_bit(1); 03829 } 03830 inline bool MessageOptions::no_standard_descriptor_accessor() const { 03831 return no_standard_descriptor_accessor_; 03832 } 03833 inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) { 03834 _set_bit(1); 03835 no_standard_descriptor_accessor_ = value; 03836 } 03837 03838 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 03839 inline int MessageOptions::uninterpreted_option_size() const { 03840 return uninterpreted_option_.size(); 03841 } 03842 inline void MessageOptions::clear_uninterpreted_option() { 03843 uninterpreted_option_.Clear(); 03844 } 03845 inline const ::google::protobuf::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const { 03846 return uninterpreted_option_.Get(index); 03847 } 03848 inline ::google::protobuf::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) { 03849 return uninterpreted_option_.Mutable(index); 03850 } 03851 inline ::google::protobuf::UninterpretedOption* MessageOptions::add_uninterpreted_option() { 03852 return uninterpreted_option_.Add(); 03853 } 03854 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 03855 MessageOptions::uninterpreted_option() const { 03856 return uninterpreted_option_; 03857 } 03858 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 03859 MessageOptions::mutable_uninterpreted_option() { 03860 return &uninterpreted_option_; 03861 } 03862 03863 // ------------------------------------------------------------------- 03864 03865 // FieldOptions 03866 03867 // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING]; 03868 inline bool FieldOptions::has_ctype() const { 03869 return _has_bit(0); 03870 } 03871 inline void FieldOptions::clear_ctype() { 03872 ctype_ = 0; 03873 _clear_bit(0); 03874 } 03875 inline ::google::protobuf::FieldOptions_CType FieldOptions::ctype() const { 03876 return static_cast< ::google::protobuf::FieldOptions_CType >(ctype_); 03877 } 03878 inline void FieldOptions::set_ctype(::google::protobuf::FieldOptions_CType value) { 03879 GOOGLE_DCHECK(::google::protobuf::FieldOptions_CType_IsValid(value)); 03880 _set_bit(0); 03881 ctype_ = value; 03882 } 03883 03884 // optional bool packed = 2; 03885 inline bool FieldOptions::has_packed() const { 03886 return _has_bit(1); 03887 } 03888 inline void FieldOptions::clear_packed() { 03889 packed_ = false; 03890 _clear_bit(1); 03891 } 03892 inline bool FieldOptions::packed() const { 03893 return packed_; 03894 } 03895 inline void FieldOptions::set_packed(bool value) { 03896 _set_bit(1); 03897 packed_ = value; 03898 } 03899 03900 // optional bool deprecated = 3 [default = false]; 03901 inline bool FieldOptions::has_deprecated() const { 03902 return _has_bit(2); 03903 } 03904 inline void FieldOptions::clear_deprecated() { 03905 deprecated_ = false; 03906 _clear_bit(2); 03907 } 03908 inline bool FieldOptions::deprecated() const { 03909 return deprecated_; 03910 } 03911 inline void FieldOptions::set_deprecated(bool value) { 03912 _set_bit(2); 03913 deprecated_ = value; 03914 } 03915 03916 // optional string experimental_map_key = 9; 03917 inline bool FieldOptions::has_experimental_map_key() const { 03918 return _has_bit(3); 03919 } 03920 inline void FieldOptions::clear_experimental_map_key() { 03921 if (experimental_map_key_ != &_default_experimental_map_key_) { 03922 experimental_map_key_->clear(); 03923 } 03924 _clear_bit(3); 03925 } 03926 inline const ::std::string& FieldOptions::experimental_map_key() const { 03927 return *experimental_map_key_; 03928 } 03929 inline void FieldOptions::set_experimental_map_key(const ::std::string& value) { 03930 _set_bit(3); 03931 if (experimental_map_key_ == &_default_experimental_map_key_) { 03932 experimental_map_key_ = new ::std::string; 03933 } 03934 experimental_map_key_->assign(value); 03935 } 03936 inline void FieldOptions::set_experimental_map_key(const char* value) { 03937 _set_bit(3); 03938 if (experimental_map_key_ == &_default_experimental_map_key_) { 03939 experimental_map_key_ = new ::std::string; 03940 } 03941 experimental_map_key_->assign(value); 03942 } 03943 inline void FieldOptions::set_experimental_map_key(const char* value, size_t size) { 03944 _set_bit(3); 03945 if (experimental_map_key_ == &_default_experimental_map_key_) { 03946 experimental_map_key_ = new ::std::string; 03947 } 03948 experimental_map_key_->assign(reinterpret_cast<const char*>(value), size); 03949 } 03950 inline ::std::string* FieldOptions::mutable_experimental_map_key() { 03951 _set_bit(3); 03952 if (experimental_map_key_ == &_default_experimental_map_key_) { 03953 experimental_map_key_ = new ::std::string; 03954 } 03955 return experimental_map_key_; 03956 } 03957 03958 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 03959 inline int FieldOptions::uninterpreted_option_size() const { 03960 return uninterpreted_option_.size(); 03961 } 03962 inline void FieldOptions::clear_uninterpreted_option() { 03963 uninterpreted_option_.Clear(); 03964 } 03965 inline const ::google::protobuf::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const { 03966 return uninterpreted_option_.Get(index); 03967 } 03968 inline ::google::protobuf::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) { 03969 return uninterpreted_option_.Mutable(index); 03970 } 03971 inline ::google::protobuf::UninterpretedOption* FieldOptions::add_uninterpreted_option() { 03972 return uninterpreted_option_.Add(); 03973 } 03974 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 03975 FieldOptions::uninterpreted_option() const { 03976 return uninterpreted_option_; 03977 } 03978 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 03979 FieldOptions::mutable_uninterpreted_option() { 03980 return &uninterpreted_option_; 03981 } 03982 03983 // ------------------------------------------------------------------- 03984 03985 // EnumOptions 03986 03987 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 03988 inline int EnumOptions::uninterpreted_option_size() const { 03989 return uninterpreted_option_.size(); 03990 } 03991 inline void EnumOptions::clear_uninterpreted_option() { 03992 uninterpreted_option_.Clear(); 03993 } 03994 inline const ::google::protobuf::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const { 03995 return uninterpreted_option_.Get(index); 03996 } 03997 inline ::google::protobuf::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) { 03998 return uninterpreted_option_.Mutable(index); 03999 } 04000 inline ::google::protobuf::UninterpretedOption* EnumOptions::add_uninterpreted_option() { 04001 return uninterpreted_option_.Add(); 04002 } 04003 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 04004 EnumOptions::uninterpreted_option() const { 04005 return uninterpreted_option_; 04006 } 04007 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 04008 EnumOptions::mutable_uninterpreted_option() { 04009 return &uninterpreted_option_; 04010 } 04011 04012 // ------------------------------------------------------------------- 04013 04014 // EnumValueOptions 04015 04016 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 04017 inline int EnumValueOptions::uninterpreted_option_size() const { 04018 return uninterpreted_option_.size(); 04019 } 04020 inline void EnumValueOptions::clear_uninterpreted_option() { 04021 uninterpreted_option_.Clear(); 04022 } 04023 inline const ::google::protobuf::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const { 04024 return uninterpreted_option_.Get(index); 04025 } 04026 inline ::google::protobuf::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) { 04027 return uninterpreted_option_.Mutable(index); 04028 } 04029 inline ::google::protobuf::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() { 04030 return uninterpreted_option_.Add(); 04031 } 04032 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 04033 EnumValueOptions::uninterpreted_option() const { 04034 return uninterpreted_option_; 04035 } 04036 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 04037 EnumValueOptions::mutable_uninterpreted_option() { 04038 return &uninterpreted_option_; 04039 } 04040 04041 // ------------------------------------------------------------------- 04042 04043 // ServiceOptions 04044 04045 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 04046 inline int ServiceOptions::uninterpreted_option_size() const { 04047 return uninterpreted_option_.size(); 04048 } 04049 inline void ServiceOptions::clear_uninterpreted_option() { 04050 uninterpreted_option_.Clear(); 04051 } 04052 inline const ::google::protobuf::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const { 04053 return uninterpreted_option_.Get(index); 04054 } 04055 inline ::google::protobuf::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) { 04056 return uninterpreted_option_.Mutable(index); 04057 } 04058 inline ::google::protobuf::UninterpretedOption* ServiceOptions::add_uninterpreted_option() { 04059 return uninterpreted_option_.Add(); 04060 } 04061 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 04062 ServiceOptions::uninterpreted_option() const { 04063 return uninterpreted_option_; 04064 } 04065 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 04066 ServiceOptions::mutable_uninterpreted_option() { 04067 return &uninterpreted_option_; 04068 } 04069 04070 // ------------------------------------------------------------------- 04071 04072 // MethodOptions 04073 04074 // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999; 04075 inline int MethodOptions::uninterpreted_option_size() const { 04076 return uninterpreted_option_.size(); 04077 } 04078 inline void MethodOptions::clear_uninterpreted_option() { 04079 uninterpreted_option_.Clear(); 04080 } 04081 inline const ::google::protobuf::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const { 04082 return uninterpreted_option_.Get(index); 04083 } 04084 inline ::google::protobuf::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) { 04085 return uninterpreted_option_.Mutable(index); 04086 } 04087 inline ::google::protobuf::UninterpretedOption* MethodOptions::add_uninterpreted_option() { 04088 return uninterpreted_option_.Add(); 04089 } 04090 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >& 04091 MethodOptions::uninterpreted_option() const { 04092 return uninterpreted_option_; 04093 } 04094 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >* 04095 MethodOptions::mutable_uninterpreted_option() { 04096 return &uninterpreted_option_; 04097 } 04098 04099 // ------------------------------------------------------------------- 04100 04101 // UninterpretedOption_NamePart 04102 04103 // required string name_part = 1; 04104 inline bool UninterpretedOption_NamePart::has_name_part() const { 04105 return _has_bit(0); 04106 } 04107 inline void UninterpretedOption_NamePart::clear_name_part() { 04108 if (name_part_ != &_default_name_part_) { 04109 name_part_->clear(); 04110 } 04111 _clear_bit(0); 04112 } 04113 inline const ::std::string& UninterpretedOption_NamePart::name_part() const { 04114 return *name_part_; 04115 } 04116 inline void UninterpretedOption_NamePart::set_name_part(const ::std::string& value) { 04117 _set_bit(0); 04118 if (name_part_ == &_default_name_part_) { 04119 name_part_ = new ::std::string; 04120 } 04121 name_part_->assign(value); 04122 } 04123 inline void UninterpretedOption_NamePart::set_name_part(const char* value) { 04124 _set_bit(0); 04125 if (name_part_ == &_default_name_part_) { 04126 name_part_ = new ::std::string; 04127 } 04128 name_part_->assign(value); 04129 } 04130 inline void UninterpretedOption_NamePart::set_name_part(const char* value, size_t size) { 04131 _set_bit(0); 04132 if (name_part_ == &_default_name_part_) { 04133 name_part_ = new ::std::string; 04134 } 04135 name_part_->assign(reinterpret_cast<const char*>(value), size); 04136 } 04137 inline ::std::string* UninterpretedOption_NamePart::mutable_name_part() { 04138 _set_bit(0); 04139 if (name_part_ == &_default_name_part_) { 04140 name_part_ = new ::std::string; 04141 } 04142 return name_part_; 04143 } 04144 04145 // required bool is_extension = 2; 04146 inline bool UninterpretedOption_NamePart::has_is_extension() const { 04147 return _has_bit(1); 04148 } 04149 inline void UninterpretedOption_NamePart::clear_is_extension() { 04150 is_extension_ = false; 04151 _clear_bit(1); 04152 } 04153 inline bool UninterpretedOption_NamePart::is_extension() const { 04154 return is_extension_; 04155 } 04156 inline void UninterpretedOption_NamePart::set_is_extension(bool value) { 04157 _set_bit(1); 04158 is_extension_ = value; 04159 } 04160 04161 // ------------------------------------------------------------------- 04162 04163 // UninterpretedOption 04164 04165 // repeated .google.protobuf.UninterpretedOption.NamePart name = 2; 04166 inline int UninterpretedOption::name_size() const { 04167 return name_.size(); 04168 } 04169 inline void UninterpretedOption::clear_name() { 04170 name_.Clear(); 04171 } 04172 inline const ::google::protobuf::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const { 04173 return name_.Get(index); 04174 } 04175 inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) { 04176 return name_.Mutable(index); 04177 } 04178 inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::add_name() { 04179 return name_.Add(); 04180 } 04181 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >& 04182 UninterpretedOption::name() const { 04183 return name_; 04184 } 04185 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >* 04186 UninterpretedOption::mutable_name() { 04187 return &name_; 04188 } 04189 04190 // optional string identifier_value = 3; 04191 inline bool UninterpretedOption::has_identifier_value() const { 04192 return _has_bit(1); 04193 } 04194 inline void UninterpretedOption::clear_identifier_value() { 04195 if (identifier_value_ != &_default_identifier_value_) { 04196 identifier_value_->clear(); 04197 } 04198 _clear_bit(1); 04199 } 04200 inline const ::std::string& UninterpretedOption::identifier_value() const { 04201 return *identifier_value_; 04202 } 04203 inline void UninterpretedOption::set_identifier_value(const ::std::string& value) { 04204 _set_bit(1); 04205 if (identifier_value_ == &_default_identifier_value_) { 04206 identifier_value_ = new ::std::string; 04207 } 04208 identifier_value_->assign(value); 04209 } 04210 inline void UninterpretedOption::set_identifier_value(const char* value) { 04211 _set_bit(1); 04212 if (identifier_value_ == &_default_identifier_value_) { 04213 identifier_value_ = new ::std::string; 04214 } 04215 identifier_value_->assign(value); 04216 } 04217 inline void UninterpretedOption::set_identifier_value(const char* value, size_t size) { 04218 _set_bit(1); 04219 if (identifier_value_ == &_default_identifier_value_) { 04220 identifier_value_ = new ::std::string; 04221 } 04222 identifier_value_->assign(reinterpret_cast<const char*>(value), size); 04223 } 04224 inline ::std::string* UninterpretedOption::mutable_identifier_value() { 04225 _set_bit(1); 04226 if (identifier_value_ == &_default_identifier_value_) { 04227 identifier_value_ = new ::std::string; 04228 } 04229 return identifier_value_; 04230 } 04231 04232 // optional uint64 positive_int_value = 4; 04233 inline bool UninterpretedOption::has_positive_int_value() const { 04234 return _has_bit(2); 04235 } 04236 inline void UninterpretedOption::clear_positive_int_value() { 04237 positive_int_value_ = GOOGLE_ULONGLONG(0); 04238 _clear_bit(2); 04239 } 04240 inline ::google::protobuf::uint64 UninterpretedOption::positive_int_value() const { 04241 return positive_int_value_; 04242 } 04243 inline void UninterpretedOption::set_positive_int_value(::google::protobuf::uint64 value) { 04244 _set_bit(2); 04245 positive_int_value_ = value; 04246 } 04247 04248 // optional int64 negative_int_value = 5; 04249 inline bool UninterpretedOption::has_negative_int_value() const { 04250 return _has_bit(3); 04251 } 04252 inline void UninterpretedOption::clear_negative_int_value() { 04253 negative_int_value_ = GOOGLE_LONGLONG(0); 04254 _clear_bit(3); 04255 } 04256 inline ::google::protobuf::int64 UninterpretedOption::negative_int_value() const { 04257 return negative_int_value_; 04258 } 04259 inline void UninterpretedOption::set_negative_int_value(::google::protobuf::int64 value) { 04260 _set_bit(3); 04261 negative_int_value_ = value; 04262 } 04263 04264 // optional double double_value = 6; 04265 inline bool UninterpretedOption::has_double_value() const { 04266 return _has_bit(4); 04267 } 04268 inline void UninterpretedOption::clear_double_value() { 04269 double_value_ = 0; 04270 _clear_bit(4); 04271 } 04272 inline double UninterpretedOption::double_value() const { 04273 return double_value_; 04274 } 04275 inline void UninterpretedOption::set_double_value(double value) { 04276 _set_bit(4); 04277 double_value_ = value; 04278 } 04279 04280 // optional bytes string_value = 7; 04281 inline bool UninterpretedOption::has_string_value() const { 04282 return _has_bit(5); 04283 } 04284 inline void UninterpretedOption::clear_string_value() { 04285 if (string_value_ != &_default_string_value_) { 04286 string_value_->clear(); 04287 } 04288 _clear_bit(5); 04289 } 04290 inline const ::std::string& UninterpretedOption::string_value() const { 04291 return *string_value_; 04292 } 04293 inline void UninterpretedOption::set_string_value(const ::std::string& value) { 04294 _set_bit(5); 04295 if (string_value_ == &_default_string_value_) { 04296 string_value_ = new ::std::string; 04297 } 04298 string_value_->assign(value); 04299 } 04300 inline void UninterpretedOption::set_string_value(const char* value) { 04301 _set_bit(5); 04302 if (string_value_ == &_default_string_value_) { 04303 string_value_ = new ::std::string; 04304 } 04305 string_value_->assign(value); 04306 } 04307 inline void UninterpretedOption::set_string_value(const void* value, size_t size) { 04308 _set_bit(5); 04309 if (string_value_ == &_default_string_value_) { 04310 string_value_ = new ::std::string; 04311 } 04312 string_value_->assign(reinterpret_cast<const char*>(value), size); 04313 } 04314 inline ::std::string* UninterpretedOption::mutable_string_value() { 04315 _set_bit(5); 04316 if (string_value_ == &_default_string_value_) { 04317 string_value_ = new ::std::string; 04318 } 04319 return string_value_; 04320 } 04321 04322 04323 // @@protoc_insertion_point(namespace_scope) 04324 04325 } // namespace protobuf 04326 } // namespace google 04327 04328 #ifndef SWIG 04329 namespace google { 04330 namespace protobuf { 04331 04332 template <> 04333 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type>() { 04334 return ::google::protobuf::FieldDescriptorProto_Type_descriptor(); 04335 } 04336 template <> 04337 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label>() { 04338 return ::google::protobuf::FieldDescriptorProto_Label_descriptor(); 04339 } 04340 template <> 04341 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode>() { 04342 return ::google::protobuf::FileOptions_OptimizeMode_descriptor(); 04343 } 04344 template <> 04345 inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldOptions_CType>() { 04346 return ::google::protobuf::FieldOptions_CType_descriptor(); 04347 } 04348 04349 } // namespace google 04350 } // namespace protobuf 04351 #endif // SWIG 04352 04353 // @@protoc_insertion_point(global_scope) 04354 04355 #endif // PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED
1.7.6.1
