1// Generated by the protocol buffer compiler. DO NOT EDIT! 2// source: ril.proto 3 4#ifndef PROTOBUF_ril_2eproto__INCLUDED 5#define PROTOBUF_ril_2eproto__INCLUDED 6 7#include <string> 8 9#include <google/protobuf/stubs/common.h> 10 11#if GOOGLE_PROTOBUF_VERSION < 2003000 12#error This file was generated by a newer version of protoc which is 13#error incompatible with your Protocol Buffer headers. Please update 14#error your headers. 15#endif 16#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 17#error This file was generated by an older version of protoc which is 18#error incompatible with your Protocol Buffer headers. Please 19#error regenerate this file with a newer version of protoc. 20#endif 21 22#include <google/protobuf/generated_message_util.h> 23#include <google/protobuf/repeated_field.h> 24#include <google/protobuf/extension_set.h> 25#include <google/protobuf/generated_message_reflection.h> 26// @@protoc_insertion_point(includes) 27 28namespace ril_proto { 29 30// Internal implementation detail -- do not call these. 31void protobuf_AddDesc_ril_2eproto(); 32void protobuf_AssignDesc_ril_2eproto(); 33void protobuf_ShutdownFile_ril_2eproto(); 34 35class RilAppStatus; 36class RilCardStatus; 37class RilUusInfo; 38class RilCall; 39class RILGWSignalStrength; 40class RILCDMASignalStrength; 41class RILEVDOSignalStrength; 42class RspStrings; 43class RspIntegers; 44class RspGetSimStatus; 45class ReqEnterSimPin; 46class RspEnterSimPin; 47class RspGetCurrentCalls; 48class ReqDial; 49class ReqHangUp; 50class RspLastCallFailCause; 51class RspSignalStrength; 52class RspOperator; 53class ReqSeparateConnection; 54class ReqSetMute; 55class ReqScreenState; 56 57enum RadioState { 58 RADIOSTATE_OFF = 0, 59 RADIOSTATE_UNAVAILABLE = 1, 60 RADIOSTATE_SIM_NOT_READY = 2, 61 RADIOSTATE_SIM_LOCKED_OR_ABSENT = 3, 62 RADIOSTATE_SIM_READY = 4, 63 RADIOSTATE_RUIM_NOT_READY = 5, 64 RADIOSTATE_RUIM_READY = 6, 65 RADIOSTATE_RUIM_LOCKED_OR_ABSENT = 7, 66 RADIOSTATE_NV_NOT_READY = 8, 67 RADIOSTATE_NV_READY = 9 68}; 69bool RadioState_IsValid(int value); 70const RadioState RadioState_MIN = RADIOSTATE_OFF; 71const RadioState RadioState_MAX = RADIOSTATE_NV_READY; 72const int RadioState_ARRAYSIZE = RadioState_MAX + 1; 73 74const ::google::protobuf::EnumDescriptor* RadioState_descriptor(); 75inline const ::std::string& RadioState_Name(RadioState value) { 76 return ::google::protobuf::internal::NameOfEnum( 77 RadioState_descriptor(), value); 78} 79inline bool RadioState_Parse( 80 const ::std::string& name, RadioState* value) { 81 return ::google::protobuf::internal::ParseNamedEnum<RadioState>( 82 RadioState_descriptor(), name, value); 83} 84enum RilCardState { 85 CARDSTATE_ABSENT = 0, 86 CARDSTATE_PRESENT = 1, 87 CARDSTATE_ERROR = 2 88}; 89bool RilCardState_IsValid(int value); 90const RilCardState RilCardState_MIN = CARDSTATE_ABSENT; 91const RilCardState RilCardState_MAX = CARDSTATE_ERROR; 92const int RilCardState_ARRAYSIZE = RilCardState_MAX + 1; 93 94const ::google::protobuf::EnumDescriptor* RilCardState_descriptor(); 95inline const ::std::string& RilCardState_Name(RilCardState value) { 96 return ::google::protobuf::internal::NameOfEnum( 97 RilCardState_descriptor(), value); 98} 99inline bool RilCardState_Parse( 100 const ::std::string& name, RilCardState* value) { 101 return ::google::protobuf::internal::ParseNamedEnum<RilCardState>( 102 RilCardState_descriptor(), name, value); 103} 104enum RilPersoSubstate { 105 PERSOSUBSTATE_UNKNOWN = 0, 106 PERSOSUBSTATE_IN_PROGRESS = 1, 107 PERSOSUBSTATE_READY = 2, 108 PERSOSUBSTATE_SIM_NETWORK = 3, 109 PERSOSUBSTATE_SIM_NETWORK_SUBSET = 4, 110 PERSOSUBSTATE_SIM_CORPORATE = 5, 111 PERSOSUBSTATE_SIM_SERVICE_PROVIDER = 6, 112 PERSOSUBSTATE_SIM_SIM = 7, 113 PERSOSUBSTATE_SIM_NETWORK_PUK = 8, 114 PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK = 9, 115 PERSOSUBSTATE_SIM_CORPORATE_PUK = 10, 116 PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK = 11, 117 PERSOSUBSTATE_SIM_SIM_PUK = 12, 118 PERSOSUBSTATE_RUIM_NETWORK1 = 13, 119 PERSOSUBSTATE_RUIM_NETWORK2 = 14, 120 PERSOSUBSTATE_RUIM_HRPD = 15, 121 PERSOSUBSTATE_RUIM_CORPORATE = 16, 122 PERSOSUBSTATE_RUIM_SERVICE_PROVIDER = 17, 123 PERSOSUBSTATE_RUIM_RUIM = 18, 124 PERSOSUBSTATE_RUIM_NETWORK1_PUK = 19, 125 PERSOSUBSTATE_RUIM_NETWORK2_PUK = 20, 126 PERSOSUBSTATE_RUIM_HRPD_PUK = 21, 127 PERSOSUBSTATE_RUIM_CORPORATE_PUK = 22, 128 PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK = 23, 129 PERSOSUBSTATE_RUIM_RUIM_PUK = 24 130}; 131bool RilPersoSubstate_IsValid(int value); 132const RilPersoSubstate RilPersoSubstate_MIN = PERSOSUBSTATE_UNKNOWN; 133const RilPersoSubstate RilPersoSubstate_MAX = PERSOSUBSTATE_RUIM_RUIM_PUK; 134const int RilPersoSubstate_ARRAYSIZE = RilPersoSubstate_MAX + 1; 135 136const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor(); 137inline const ::std::string& RilPersoSubstate_Name(RilPersoSubstate value) { 138 return ::google::protobuf::internal::NameOfEnum( 139 RilPersoSubstate_descriptor(), value); 140} 141inline bool RilPersoSubstate_Parse( 142 const ::std::string& name, RilPersoSubstate* value) { 143 return ::google::protobuf::internal::ParseNamedEnum<RilPersoSubstate>( 144 RilPersoSubstate_descriptor(), name, value); 145} 146enum RilAppState { 147 APPSTATE_UNKNOWN = 0, 148 APPSTATE_DETECTED = 1, 149 APPSTATE_PIN = 2, 150 APPSTATE_PUK = 3, 151 APPSTATE_SUBSCRIPTION_PERSO = 4, 152 APPSTATE_READY = 5 153}; 154bool RilAppState_IsValid(int value); 155const RilAppState RilAppState_MIN = APPSTATE_UNKNOWN; 156const RilAppState RilAppState_MAX = APPSTATE_READY; 157const int RilAppState_ARRAYSIZE = RilAppState_MAX + 1; 158 159const ::google::protobuf::EnumDescriptor* RilAppState_descriptor(); 160inline const ::std::string& RilAppState_Name(RilAppState value) { 161 return ::google::protobuf::internal::NameOfEnum( 162 RilAppState_descriptor(), value); 163} 164inline bool RilAppState_Parse( 165 const ::std::string& name, RilAppState* value) { 166 return ::google::protobuf::internal::ParseNamedEnum<RilAppState>( 167 RilAppState_descriptor(), name, value); 168} 169enum RilPinState { 170 PINSTATE_UNKNOWN = 0, 171 PINSTATE_ENABLED_NOT_VERIFIED = 1, 172 PINSTATE_ENABLED_VERIFIED = 2, 173 PINSTATE_DISABLED = 3, 174 PINSTATE_ENABLED_BLOCKED = 4, 175 PINSTATE_ENABLED_PERM_BLOCKED = 5 176}; 177bool RilPinState_IsValid(int value); 178const RilPinState RilPinState_MIN = PINSTATE_UNKNOWN; 179const RilPinState RilPinState_MAX = PINSTATE_ENABLED_PERM_BLOCKED; 180const int RilPinState_ARRAYSIZE = RilPinState_MAX + 1; 181 182const ::google::protobuf::EnumDescriptor* RilPinState_descriptor(); 183inline const ::std::string& RilPinState_Name(RilPinState value) { 184 return ::google::protobuf::internal::NameOfEnum( 185 RilPinState_descriptor(), value); 186} 187inline bool RilPinState_Parse( 188 const ::std::string& name, RilPinState* value) { 189 return ::google::protobuf::internal::ParseNamedEnum<RilPinState>( 190 RilPinState_descriptor(), name, value); 191} 192enum RilAppType { 193 APPTYPE_UNKNOWN = 0, 194 APPTYPE_SIM = 1, 195 APPTYPE_USIM = 2, 196 APPTYPE_RUIM = 3, 197 APPTYPE_CSIM = 4 198}; 199bool RilAppType_IsValid(int value); 200const RilAppType RilAppType_MIN = APPTYPE_UNKNOWN; 201const RilAppType RilAppType_MAX = APPTYPE_CSIM; 202const int RilAppType_ARRAYSIZE = RilAppType_MAX + 1; 203 204const ::google::protobuf::EnumDescriptor* RilAppType_descriptor(); 205inline const ::std::string& RilAppType_Name(RilAppType value) { 206 return ::google::protobuf::internal::NameOfEnum( 207 RilAppType_descriptor(), value); 208} 209inline bool RilAppType_Parse( 210 const ::std::string& name, RilAppType* value) { 211 return ::google::protobuf::internal::ParseNamedEnum<RilAppType>( 212 RilAppType_descriptor(), name, value); 213} 214enum RilUusType { 215 RILUUSTYPE1_IMPLICIT = 0, 216 RILUUSTYPE1_REQUIRED = 1, 217 RILUUSTYPE1_NOT_REQUIRED = 2, 218 RILUUSTYPE2_REQUIRED = 3, 219 RILUUSTYPE2_NOT_REQUIRED = 4, 220 RILUUSTYPE3_REQUIRED = 5, 221 RILUUSTYPE3_NOT_REQUIRED = 6 222}; 223bool RilUusType_IsValid(int value); 224const RilUusType RilUusType_MIN = RILUUSTYPE1_IMPLICIT; 225const RilUusType RilUusType_MAX = RILUUSTYPE3_NOT_REQUIRED; 226const int RilUusType_ARRAYSIZE = RilUusType_MAX + 1; 227 228const ::google::protobuf::EnumDescriptor* RilUusType_descriptor(); 229inline const ::std::string& RilUusType_Name(RilUusType value) { 230 return ::google::protobuf::internal::NameOfEnum( 231 RilUusType_descriptor(), value); 232} 233inline bool RilUusType_Parse( 234 const ::std::string& name, RilUusType* value) { 235 return ::google::protobuf::internal::ParseNamedEnum<RilUusType>( 236 RilUusType_descriptor(), name, value); 237} 238enum RilUusDcs { 239 RILUUSDCS_USP = 0, 240 RILUUSDCS_OSIHLP = 1, 241 RILUUSDCS_X244 = 2, 242 RILUUSDCS_RMCF = 3, 243 RILUUSDCS_IA5c = 4 244}; 245bool RilUusDcs_IsValid(int value); 246const RilUusDcs RilUusDcs_MIN = RILUUSDCS_USP; 247const RilUusDcs RilUusDcs_MAX = RILUUSDCS_IA5c; 248const int RilUusDcs_ARRAYSIZE = RilUusDcs_MAX + 1; 249 250const ::google::protobuf::EnumDescriptor* RilUusDcs_descriptor(); 251inline const ::std::string& RilUusDcs_Name(RilUusDcs value) { 252 return ::google::protobuf::internal::NameOfEnum( 253 RilUusDcs_descriptor(), value); 254} 255inline bool RilUusDcs_Parse( 256 const ::std::string& name, RilUusDcs* value) { 257 return ::google::protobuf::internal::ParseNamedEnum<RilUusDcs>( 258 RilUusDcs_descriptor(), name, value); 259} 260enum RilCallState { 261 CALLSTATE_ACTIVE = 0, 262 CALLSTATE_HOLDING = 1, 263 CALLSTATE_DIALING = 2, 264 CALLSTATE_ALERTING = 3, 265 CALLSTATE_INCOMING = 4, 266 CALLSTATE_WAITING = 5 267}; 268bool RilCallState_IsValid(int value); 269const RilCallState RilCallState_MIN = CALLSTATE_ACTIVE; 270const RilCallState RilCallState_MAX = CALLSTATE_WAITING; 271const int RilCallState_ARRAYSIZE = RilCallState_MAX + 1; 272 273const ::google::protobuf::EnumDescriptor* RilCallState_descriptor(); 274inline const ::std::string& RilCallState_Name(RilCallState value) { 275 return ::google::protobuf::internal::NameOfEnum( 276 RilCallState_descriptor(), value); 277} 278inline bool RilCallState_Parse( 279 const ::std::string& name, RilCallState* value) { 280 return ::google::protobuf::internal::ParseNamedEnum<RilCallState>( 281 RilCallState_descriptor(), name, value); 282} 283// =================================================================== 284 285class RilAppStatus : public ::google::protobuf::Message { 286 public: 287 RilAppStatus(); 288 virtual ~RilAppStatus(); 289 290 RilAppStatus(const RilAppStatus& from); 291 292 inline RilAppStatus& operator=(const RilAppStatus& from) { 293 CopyFrom(from); 294 return *this; 295 } 296 297 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 298 return _unknown_fields_; 299 } 300 301 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 302 return &_unknown_fields_; 303 } 304 305 static const ::google::protobuf::Descriptor* descriptor(); 306 static const RilAppStatus& default_instance(); 307 308 void Swap(RilAppStatus* other); 309 310 // implements Message ---------------------------------------------- 311 312 RilAppStatus* New() const; 313 void CopyFrom(const ::google::protobuf::Message& from); 314 void MergeFrom(const ::google::protobuf::Message& from); 315 void CopyFrom(const RilAppStatus& from); 316 void MergeFrom(const RilAppStatus& from); 317 void Clear(); 318 bool IsInitialized() const; 319 320 int ByteSize() const; 321 bool MergePartialFromCodedStream( 322 ::google::protobuf::io::CodedInputStream* input); 323 void SerializeWithCachedSizes( 324 ::google::protobuf::io::CodedOutputStream* output) const; 325 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 326 int GetCachedSize() const { return _cached_size_; } 327 private: 328 void SharedCtor(); 329 void SharedDtor(); 330 void SetCachedSize(int size) const; 331 public: 332 333 ::google::protobuf::Metadata GetMetadata() const; 334 335 // nested types ---------------------------------------------------- 336 337 // accessors ------------------------------------------------------- 338 339 // optional .ril_proto.RilAppType app_type = 1; 340 inline bool has_app_type() const; 341 inline void clear_app_type(); 342 static const int kAppTypeFieldNumber = 1; 343 inline ril_proto::RilAppType app_type() const; 344 inline void set_app_type(ril_proto::RilAppType value); 345 346 // optional .ril_proto.RilAppState app_state = 2; 347 inline bool has_app_state() const; 348 inline void clear_app_state(); 349 static const int kAppStateFieldNumber = 2; 350 inline ril_proto::RilAppState app_state() const; 351 inline void set_app_state(ril_proto::RilAppState value); 352 353 // optional .ril_proto.RilPersoSubstate perso_substate = 3; 354 inline bool has_perso_substate() const; 355 inline void clear_perso_substate(); 356 static const int kPersoSubstateFieldNumber = 3; 357 inline ril_proto::RilPersoSubstate perso_substate() const; 358 inline void set_perso_substate(ril_proto::RilPersoSubstate value); 359 360 // optional string aid = 4; 361 inline bool has_aid() const; 362 inline void clear_aid(); 363 static const int kAidFieldNumber = 4; 364 inline const ::std::string& aid() const; 365 inline void set_aid(const ::std::string& value); 366 inline void set_aid(const char* value); 367 inline void set_aid(const char* value, size_t size); 368 inline ::std::string* mutable_aid(); 369 370 // optional string app_label = 5; 371 inline bool has_app_label() const; 372 inline void clear_app_label(); 373 static const int kAppLabelFieldNumber = 5; 374 inline const ::std::string& app_label() const; 375 inline void set_app_label(const ::std::string& value); 376 inline void set_app_label(const char* value); 377 inline void set_app_label(const char* value, size_t size); 378 inline ::std::string* mutable_app_label(); 379 380 // optional int32 pin1_replaced = 6; 381 inline bool has_pin1_replaced() const; 382 inline void clear_pin1_replaced(); 383 static const int kPin1ReplacedFieldNumber = 6; 384 inline ::google::protobuf::int32 pin1_replaced() const; 385 inline void set_pin1_replaced(::google::protobuf::int32 value); 386 387 // optional .ril_proto.RilPinState pin1 = 7; 388 inline bool has_pin1() const; 389 inline void clear_pin1(); 390 static const int kPin1FieldNumber = 7; 391 inline ril_proto::RilPinState pin1() const; 392 inline void set_pin1(ril_proto::RilPinState value); 393 394 // optional .ril_proto.RilPinState pin2 = 8; 395 inline bool has_pin2() const; 396 inline void clear_pin2(); 397 static const int kPin2FieldNumber = 8; 398 inline ril_proto::RilPinState pin2() const; 399 inline void set_pin2(ril_proto::RilPinState value); 400 401 // @@protoc_insertion_point(class_scope:ril_proto.RilAppStatus) 402 private: 403 ::google::protobuf::UnknownFieldSet _unknown_fields_; 404 mutable int _cached_size_; 405 406 int app_type_; 407 int app_state_; 408 int perso_substate_; 409 ::std::string* aid_; 410 static const ::std::string _default_aid_; 411 ::std::string* app_label_; 412 static const ::std::string _default_app_label_; 413 ::google::protobuf::int32 pin1_replaced_; 414 int pin1_; 415 int pin2_; 416 friend void protobuf_AddDesc_ril_2eproto(); 417 friend void protobuf_AssignDesc_ril_2eproto(); 418 friend void protobuf_ShutdownFile_ril_2eproto(); 419 420 ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32]; 421 422 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 423 inline bool _has_bit(int index) const { 424 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 425 } 426 inline void _set_bit(int index) { 427 _has_bits_[index / 32] |= (1u << (index % 32)); 428 } 429 inline void _clear_bit(int index) { 430 _has_bits_[index / 32] &= ~(1u << (index % 32)); 431 } 432 433 void InitAsDefaultInstance(); 434 static RilAppStatus* default_instance_; 435}; 436// ------------------------------------------------------------------- 437 438class RilCardStatus : public ::google::protobuf::Message { 439 public: 440 RilCardStatus(); 441 virtual ~RilCardStatus(); 442 443 RilCardStatus(const RilCardStatus& from); 444 445 inline RilCardStatus& operator=(const RilCardStatus& from) { 446 CopyFrom(from); 447 return *this; 448 } 449 450 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 451 return _unknown_fields_; 452 } 453 454 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 455 return &_unknown_fields_; 456 } 457 458 static const ::google::protobuf::Descriptor* descriptor(); 459 static const RilCardStatus& default_instance(); 460 461 void Swap(RilCardStatus* other); 462 463 // implements Message ---------------------------------------------- 464 465 RilCardStatus* New() const; 466 void CopyFrom(const ::google::protobuf::Message& from); 467 void MergeFrom(const ::google::protobuf::Message& from); 468 void CopyFrom(const RilCardStatus& from); 469 void MergeFrom(const RilCardStatus& from); 470 void Clear(); 471 bool IsInitialized() const; 472 473 int ByteSize() const; 474 bool MergePartialFromCodedStream( 475 ::google::protobuf::io::CodedInputStream* input); 476 void SerializeWithCachedSizes( 477 ::google::protobuf::io::CodedOutputStream* output) const; 478 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 479 int GetCachedSize() const { return _cached_size_; } 480 private: 481 void SharedCtor(); 482 void SharedDtor(); 483 void SetCachedSize(int size) const; 484 public: 485 486 ::google::protobuf::Metadata GetMetadata() const; 487 488 // nested types ---------------------------------------------------- 489 490 // accessors ------------------------------------------------------- 491 492 // optional .ril_proto.RilCardState card_state = 1; 493 inline bool has_card_state() const; 494 inline void clear_card_state(); 495 static const int kCardStateFieldNumber = 1; 496 inline ril_proto::RilCardState card_state() const; 497 inline void set_card_state(ril_proto::RilCardState value); 498 499 // optional .ril_proto.RilPinState universal_pin_state = 2; 500 inline bool has_universal_pin_state() const; 501 inline void clear_universal_pin_state(); 502 static const int kUniversalPinStateFieldNumber = 2; 503 inline ril_proto::RilPinState universal_pin_state() const; 504 inline void set_universal_pin_state(ril_proto::RilPinState value); 505 506 // optional int32 gsm_umts_subscription_app_index = 3; 507 inline bool has_gsm_umts_subscription_app_index() const; 508 inline void clear_gsm_umts_subscription_app_index(); 509 static const int kGsmUmtsSubscriptionAppIndexFieldNumber = 3; 510 inline ::google::protobuf::int32 gsm_umts_subscription_app_index() const; 511 inline void set_gsm_umts_subscription_app_index(::google::protobuf::int32 value); 512 513 // optional int32 cdma_subscription_app_index = 4; 514 inline bool has_cdma_subscription_app_index() const; 515 inline void clear_cdma_subscription_app_index(); 516 static const int kCdmaSubscriptionAppIndexFieldNumber = 4; 517 inline ::google::protobuf::int32 cdma_subscription_app_index() const; 518 inline void set_cdma_subscription_app_index(::google::protobuf::int32 value); 519 520 // optional int32 num_applications = 5; 521 inline bool has_num_applications() const; 522 inline void clear_num_applications(); 523 static const int kNumApplicationsFieldNumber = 5; 524 inline ::google::protobuf::int32 num_applications() const; 525 inline void set_num_applications(::google::protobuf::int32 value); 526 527 // repeated .ril_proto.RilAppStatus applications = 6; 528 inline int applications_size() const; 529 inline void clear_applications(); 530 static const int kApplicationsFieldNumber = 6; 531 inline const ::ril_proto::RilAppStatus& applications(int index) const; 532 inline ::ril_proto::RilAppStatus* mutable_applications(int index); 533 inline ::ril_proto::RilAppStatus* add_applications(); 534 inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >& 535 applications() const; 536 inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >* 537 mutable_applications(); 538 539 // @@protoc_insertion_point(class_scope:ril_proto.RilCardStatus) 540 private: 541 ::google::protobuf::UnknownFieldSet _unknown_fields_; 542 mutable int _cached_size_; 543 544 int card_state_; 545 int universal_pin_state_; 546 ::google::protobuf::int32 gsm_umts_subscription_app_index_; 547 ::google::protobuf::int32 cdma_subscription_app_index_; 548 ::google::protobuf::int32 num_applications_; 549 ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus > applications_; 550 friend void protobuf_AddDesc_ril_2eproto(); 551 friend void protobuf_AssignDesc_ril_2eproto(); 552 friend void protobuf_ShutdownFile_ril_2eproto(); 553 554 ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; 555 556 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 557 inline bool _has_bit(int index) const { 558 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 559 } 560 inline void _set_bit(int index) { 561 _has_bits_[index / 32] |= (1u << (index % 32)); 562 } 563 inline void _clear_bit(int index) { 564 _has_bits_[index / 32] &= ~(1u << (index % 32)); 565 } 566 567 void InitAsDefaultInstance(); 568 static RilCardStatus* default_instance_; 569}; 570// ------------------------------------------------------------------- 571 572class RilUusInfo : public ::google::protobuf::Message { 573 public: 574 RilUusInfo(); 575 virtual ~RilUusInfo(); 576 577 RilUusInfo(const RilUusInfo& from); 578 579 inline RilUusInfo& operator=(const RilUusInfo& from) { 580 CopyFrom(from); 581 return *this; 582 } 583 584 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 585 return _unknown_fields_; 586 } 587 588 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 589 return &_unknown_fields_; 590 } 591 592 static const ::google::protobuf::Descriptor* descriptor(); 593 static const RilUusInfo& default_instance(); 594 595 void Swap(RilUusInfo* other); 596 597 // implements Message ---------------------------------------------- 598 599 RilUusInfo* New() const; 600 void CopyFrom(const ::google::protobuf::Message& from); 601 void MergeFrom(const ::google::protobuf::Message& from); 602 void CopyFrom(const RilUusInfo& from); 603 void MergeFrom(const RilUusInfo& from); 604 void Clear(); 605 bool IsInitialized() const; 606 607 int ByteSize() const; 608 bool MergePartialFromCodedStream( 609 ::google::protobuf::io::CodedInputStream* input); 610 void SerializeWithCachedSizes( 611 ::google::protobuf::io::CodedOutputStream* output) const; 612 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 613 int GetCachedSize() const { return _cached_size_; } 614 private: 615 void SharedCtor(); 616 void SharedDtor(); 617 void SetCachedSize(int size) const; 618 public: 619 620 ::google::protobuf::Metadata GetMetadata() const; 621 622 // nested types ---------------------------------------------------- 623 624 // accessors ------------------------------------------------------- 625 626 // optional .ril_proto.RilUusType uus_type = 1; 627 inline bool has_uus_type() const; 628 inline void clear_uus_type(); 629 static const int kUusTypeFieldNumber = 1; 630 inline ril_proto::RilUusType uus_type() const; 631 inline void set_uus_type(ril_proto::RilUusType value); 632 633 // optional .ril_proto.RilUusDcs uus_dcs = 2; 634 inline bool has_uus_dcs() const; 635 inline void clear_uus_dcs(); 636 static const int kUusDcsFieldNumber = 2; 637 inline ril_proto::RilUusDcs uus_dcs() const; 638 inline void set_uus_dcs(ril_proto::RilUusDcs value); 639 640 // optional int32 uus_length = 3; 641 inline bool has_uus_length() const; 642 inline void clear_uus_length(); 643 static const int kUusLengthFieldNumber = 3; 644 inline ::google::protobuf::int32 uus_length() const; 645 inline void set_uus_length(::google::protobuf::int32 value); 646 647 // optional string uus_data = 4; 648 inline bool has_uus_data() const; 649 inline void clear_uus_data(); 650 static const int kUusDataFieldNumber = 4; 651 inline const ::std::string& uus_data() const; 652 inline void set_uus_data(const ::std::string& value); 653 inline void set_uus_data(const char* value); 654 inline void set_uus_data(const char* value, size_t size); 655 inline ::std::string* mutable_uus_data(); 656 657 // @@protoc_insertion_point(class_scope:ril_proto.RilUusInfo) 658 private: 659 ::google::protobuf::UnknownFieldSet _unknown_fields_; 660 mutable int _cached_size_; 661 662 int uus_type_; 663 int uus_dcs_; 664 ::google::protobuf::int32 uus_length_; 665 ::std::string* uus_data_; 666 static const ::std::string _default_uus_data_; 667 friend void protobuf_AddDesc_ril_2eproto(); 668 friend void protobuf_AssignDesc_ril_2eproto(); 669 friend void protobuf_ShutdownFile_ril_2eproto(); 670 671 ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; 672 673 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 674 inline bool _has_bit(int index) const { 675 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 676 } 677 inline void _set_bit(int index) { 678 _has_bits_[index / 32] |= (1u << (index % 32)); 679 } 680 inline void _clear_bit(int index) { 681 _has_bits_[index / 32] &= ~(1u << (index % 32)); 682 } 683 684 void InitAsDefaultInstance(); 685 static RilUusInfo* default_instance_; 686}; 687// ------------------------------------------------------------------- 688 689class RilCall : public ::google::protobuf::Message { 690 public: 691 RilCall(); 692 virtual ~RilCall(); 693 694 RilCall(const RilCall& from); 695 696 inline RilCall& operator=(const RilCall& from) { 697 CopyFrom(from); 698 return *this; 699 } 700 701 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 702 return _unknown_fields_; 703 } 704 705 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 706 return &_unknown_fields_; 707 } 708 709 static const ::google::protobuf::Descriptor* descriptor(); 710 static const RilCall& default_instance(); 711 712 void Swap(RilCall* other); 713 714 // implements Message ---------------------------------------------- 715 716 RilCall* New() const; 717 void CopyFrom(const ::google::protobuf::Message& from); 718 void MergeFrom(const ::google::protobuf::Message& from); 719 void CopyFrom(const RilCall& from); 720 void MergeFrom(const RilCall& from); 721 void Clear(); 722 bool IsInitialized() const; 723 724 int ByteSize() const; 725 bool MergePartialFromCodedStream( 726 ::google::protobuf::io::CodedInputStream* input); 727 void SerializeWithCachedSizes( 728 ::google::protobuf::io::CodedOutputStream* output) const; 729 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 730 int GetCachedSize() const { return _cached_size_; } 731 private: 732 void SharedCtor(); 733 void SharedDtor(); 734 void SetCachedSize(int size) const; 735 public: 736 737 ::google::protobuf::Metadata GetMetadata() const; 738 739 // nested types ---------------------------------------------------- 740 741 // accessors ------------------------------------------------------- 742 743 // optional .ril_proto.RilCallState state = 1; 744 inline bool has_state() const; 745 inline void clear_state(); 746 static const int kStateFieldNumber = 1; 747 inline ril_proto::RilCallState state() const; 748 inline void set_state(ril_proto::RilCallState value); 749 750 // optional int32 index = 2; 751 inline bool has_index() const; 752 inline void clear_index(); 753 static const int kIndexFieldNumber = 2; 754 inline ::google::protobuf::int32 index() const; 755 inline void set_index(::google::protobuf::int32 value); 756 757 // optional int32 toa = 3; 758 inline bool has_toa() const; 759 inline void clear_toa(); 760 static const int kToaFieldNumber = 3; 761 inline ::google::protobuf::int32 toa() const; 762 inline void set_toa(::google::protobuf::int32 value); 763 764 // optional bool is_mpty = 4; 765 inline bool has_is_mpty() const; 766 inline void clear_is_mpty(); 767 static const int kIsMptyFieldNumber = 4; 768 inline bool is_mpty() const; 769 inline void set_is_mpty(bool value); 770 771 // optional bool is_mt = 5; 772 inline bool has_is_mt() const; 773 inline void clear_is_mt(); 774 static const int kIsMtFieldNumber = 5; 775 inline bool is_mt() const; 776 inline void set_is_mt(bool value); 777 778 // optional int32 als = 6; 779 inline bool has_als() const; 780 inline void clear_als(); 781 static const int kAlsFieldNumber = 6; 782 inline ::google::protobuf::int32 als() const; 783 inline void set_als(::google::protobuf::int32 value); 784 785 // optional bool is_voice = 7; 786 inline bool has_is_voice() const; 787 inline void clear_is_voice(); 788 static const int kIsVoiceFieldNumber = 7; 789 inline bool is_voice() const; 790 inline void set_is_voice(bool value); 791 792 // optional bool is_voice_privacy = 8; 793 inline bool has_is_voice_privacy() const; 794 inline void clear_is_voice_privacy(); 795 static const int kIsVoicePrivacyFieldNumber = 8; 796 inline bool is_voice_privacy() const; 797 inline void set_is_voice_privacy(bool value); 798 799 // optional string number = 9; 800 inline bool has_number() const; 801 inline void clear_number(); 802 static const int kNumberFieldNumber = 9; 803 inline const ::std::string& number() const; 804 inline void set_number(const ::std::string& value); 805 inline void set_number(const char* value); 806 inline void set_number(const char* value, size_t size); 807 inline ::std::string* mutable_number(); 808 809 // optional int32 number_presentation = 10; 810 inline bool has_number_presentation() const; 811 inline void clear_number_presentation(); 812 static const int kNumberPresentationFieldNumber = 10; 813 inline ::google::protobuf::int32 number_presentation() const; 814 inline void set_number_presentation(::google::protobuf::int32 value); 815 816 // optional string name = 11; 817 inline bool has_name() const; 818 inline void clear_name(); 819 static const int kNameFieldNumber = 11; 820 inline const ::std::string& name() const; 821 inline void set_name(const ::std::string& value); 822 inline void set_name(const char* value); 823 inline void set_name(const char* value, size_t size); 824 inline ::std::string* mutable_name(); 825 826 // optional int32 name_presentation = 12; 827 inline bool has_name_presentation() const; 828 inline void clear_name_presentation(); 829 static const int kNamePresentationFieldNumber = 12; 830 inline ::google::protobuf::int32 name_presentation() const; 831 inline void set_name_presentation(::google::protobuf::int32 value); 832 833 // optional .ril_proto.RilUusInfo uus_info = 13; 834 inline bool has_uus_info() const; 835 inline void clear_uus_info(); 836 static const int kUusInfoFieldNumber = 13; 837 inline const ::ril_proto::RilUusInfo& uus_info() const; 838 inline ::ril_proto::RilUusInfo* mutable_uus_info(); 839 840 // @@protoc_insertion_point(class_scope:ril_proto.RilCall) 841 private: 842 ::google::protobuf::UnknownFieldSet _unknown_fields_; 843 mutable int _cached_size_; 844 845 int state_; 846 ::google::protobuf::int32 index_; 847 ::google::protobuf::int32 toa_; 848 bool is_mpty_; 849 bool is_mt_; 850 ::google::protobuf::int32 als_; 851 bool is_voice_; 852 bool is_voice_privacy_; 853 ::std::string* number_; 854 static const ::std::string _default_number_; 855 ::google::protobuf::int32 number_presentation_; 856 ::std::string* name_; 857 static const ::std::string _default_name_; 858 ::google::protobuf::int32 name_presentation_; 859 ::ril_proto::RilUusInfo* uus_info_; 860 friend void protobuf_AddDesc_ril_2eproto(); 861 friend void protobuf_AssignDesc_ril_2eproto(); 862 friend void protobuf_ShutdownFile_ril_2eproto(); 863 864 ::google::protobuf::uint32 _has_bits_[(13 + 31) / 32]; 865 866 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 867 inline bool _has_bit(int index) const { 868 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 869 } 870 inline void _set_bit(int index) { 871 _has_bits_[index / 32] |= (1u << (index % 32)); 872 } 873 inline void _clear_bit(int index) { 874 _has_bits_[index / 32] &= ~(1u << (index % 32)); 875 } 876 877 void InitAsDefaultInstance(); 878 static RilCall* default_instance_; 879}; 880// ------------------------------------------------------------------- 881 882class RILGWSignalStrength : public ::google::protobuf::Message { 883 public: 884 RILGWSignalStrength(); 885 virtual ~RILGWSignalStrength(); 886 887 RILGWSignalStrength(const RILGWSignalStrength& from); 888 889 inline RILGWSignalStrength& operator=(const RILGWSignalStrength& from) { 890 CopyFrom(from); 891 return *this; 892 } 893 894 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 895 return _unknown_fields_; 896 } 897 898 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 899 return &_unknown_fields_; 900 } 901 902 static const ::google::protobuf::Descriptor* descriptor(); 903 static const RILGWSignalStrength& default_instance(); 904 905 void Swap(RILGWSignalStrength* other); 906 907 // implements Message ---------------------------------------------- 908 909 RILGWSignalStrength* New() const; 910 void CopyFrom(const ::google::protobuf::Message& from); 911 void MergeFrom(const ::google::protobuf::Message& from); 912 void CopyFrom(const RILGWSignalStrength& from); 913 void MergeFrom(const RILGWSignalStrength& from); 914 void Clear(); 915 bool IsInitialized() const; 916 917 int ByteSize() const; 918 bool MergePartialFromCodedStream( 919 ::google::protobuf::io::CodedInputStream* input); 920 void SerializeWithCachedSizes( 921 ::google::protobuf::io::CodedOutputStream* output) const; 922 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 923 int GetCachedSize() const { return _cached_size_; } 924 private: 925 void SharedCtor(); 926 void SharedDtor(); 927 void SetCachedSize(int size) const; 928 public: 929 930 ::google::protobuf::Metadata GetMetadata() const; 931 932 // nested types ---------------------------------------------------- 933 934 // accessors ------------------------------------------------------- 935 936 // optional int32 signal_strength = 1; 937 inline bool has_signal_strength() const; 938 inline void clear_signal_strength(); 939 static const int kSignalStrengthFieldNumber = 1; 940 inline ::google::protobuf::int32 signal_strength() const; 941 inline void set_signal_strength(::google::protobuf::int32 value); 942 943 // optional int32 bit_error_rate = 2; 944 inline bool has_bit_error_rate() const; 945 inline void clear_bit_error_rate(); 946 static const int kBitErrorRateFieldNumber = 2; 947 inline ::google::protobuf::int32 bit_error_rate() const; 948 inline void set_bit_error_rate(::google::protobuf::int32 value); 949 950 // @@protoc_insertion_point(class_scope:ril_proto.RILGWSignalStrength) 951 private: 952 ::google::protobuf::UnknownFieldSet _unknown_fields_; 953 mutable int _cached_size_; 954 955 ::google::protobuf::int32 signal_strength_; 956 ::google::protobuf::int32 bit_error_rate_; 957 friend void protobuf_AddDesc_ril_2eproto(); 958 friend void protobuf_AssignDesc_ril_2eproto(); 959 friend void protobuf_ShutdownFile_ril_2eproto(); 960 961 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 962 963 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 964 inline bool _has_bit(int index) const { 965 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 966 } 967 inline void _set_bit(int index) { 968 _has_bits_[index / 32] |= (1u << (index % 32)); 969 } 970 inline void _clear_bit(int index) { 971 _has_bits_[index / 32] &= ~(1u << (index % 32)); 972 } 973 974 void InitAsDefaultInstance(); 975 static RILGWSignalStrength* default_instance_; 976}; 977// ------------------------------------------------------------------- 978 979class RILCDMASignalStrength : public ::google::protobuf::Message { 980 public: 981 RILCDMASignalStrength(); 982 virtual ~RILCDMASignalStrength(); 983 984 RILCDMASignalStrength(const RILCDMASignalStrength& from); 985 986 inline RILCDMASignalStrength& operator=(const RILCDMASignalStrength& from) { 987 CopyFrom(from); 988 return *this; 989 } 990 991 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 992 return _unknown_fields_; 993 } 994 995 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 996 return &_unknown_fields_; 997 } 998 999 static const ::google::protobuf::Descriptor* descriptor(); 1000 static const RILCDMASignalStrength& default_instance(); 1001 1002 void Swap(RILCDMASignalStrength* other); 1003 1004 // implements Message ---------------------------------------------- 1005 1006 RILCDMASignalStrength* New() const; 1007 void CopyFrom(const ::google::protobuf::Message& from); 1008 void MergeFrom(const ::google::protobuf::Message& from); 1009 void CopyFrom(const RILCDMASignalStrength& from); 1010 void MergeFrom(const RILCDMASignalStrength& from); 1011 void Clear(); 1012 bool IsInitialized() const; 1013 1014 int ByteSize() const; 1015 bool MergePartialFromCodedStream( 1016 ::google::protobuf::io::CodedInputStream* input); 1017 void SerializeWithCachedSizes( 1018 ::google::protobuf::io::CodedOutputStream* output) const; 1019 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1020 int GetCachedSize() const { return _cached_size_; } 1021 private: 1022 void SharedCtor(); 1023 void SharedDtor(); 1024 void SetCachedSize(int size) const; 1025 public: 1026 1027 ::google::protobuf::Metadata GetMetadata() const; 1028 1029 // nested types ---------------------------------------------------- 1030 1031 // accessors ------------------------------------------------------- 1032 1033 // optional int32 dbm = 1; 1034 inline bool has_dbm() const; 1035 inline void clear_dbm(); 1036 static const int kDbmFieldNumber = 1; 1037 inline ::google::protobuf::int32 dbm() const; 1038 inline void set_dbm(::google::protobuf::int32 value); 1039 1040 // optional int32 ecio = 2; 1041 inline bool has_ecio() const; 1042 inline void clear_ecio(); 1043 static const int kEcioFieldNumber = 2; 1044 inline ::google::protobuf::int32 ecio() const; 1045 inline void set_ecio(::google::protobuf::int32 value); 1046 1047 // @@protoc_insertion_point(class_scope:ril_proto.RILCDMASignalStrength) 1048 private: 1049 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1050 mutable int _cached_size_; 1051 1052 ::google::protobuf::int32 dbm_; 1053 ::google::protobuf::int32 ecio_; 1054 friend void protobuf_AddDesc_ril_2eproto(); 1055 friend void protobuf_AssignDesc_ril_2eproto(); 1056 friend void protobuf_ShutdownFile_ril_2eproto(); 1057 1058 ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; 1059 1060 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1061 inline bool _has_bit(int index) const { 1062 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1063 } 1064 inline void _set_bit(int index) { 1065 _has_bits_[index / 32] |= (1u << (index % 32)); 1066 } 1067 inline void _clear_bit(int index) { 1068 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1069 } 1070 1071 void InitAsDefaultInstance(); 1072 static RILCDMASignalStrength* default_instance_; 1073}; 1074// ------------------------------------------------------------------- 1075 1076class RILEVDOSignalStrength : public ::google::protobuf::Message { 1077 public: 1078 RILEVDOSignalStrength(); 1079 virtual ~RILEVDOSignalStrength(); 1080 1081 RILEVDOSignalStrength(const RILEVDOSignalStrength& from); 1082 1083 inline RILEVDOSignalStrength& operator=(const RILEVDOSignalStrength& from) { 1084 CopyFrom(from); 1085 return *this; 1086 } 1087 1088 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1089 return _unknown_fields_; 1090 } 1091 1092 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1093 return &_unknown_fields_; 1094 } 1095 1096 static const ::google::protobuf::Descriptor* descriptor(); 1097 static const RILEVDOSignalStrength& default_instance(); 1098 1099 void Swap(RILEVDOSignalStrength* other); 1100 1101 // implements Message ---------------------------------------------- 1102 1103 RILEVDOSignalStrength* New() const; 1104 void CopyFrom(const ::google::protobuf::Message& from); 1105 void MergeFrom(const ::google::protobuf::Message& from); 1106 void CopyFrom(const RILEVDOSignalStrength& from); 1107 void MergeFrom(const RILEVDOSignalStrength& from); 1108 void Clear(); 1109 bool IsInitialized() const; 1110 1111 int ByteSize() const; 1112 bool MergePartialFromCodedStream( 1113 ::google::protobuf::io::CodedInputStream* input); 1114 void SerializeWithCachedSizes( 1115 ::google::protobuf::io::CodedOutputStream* output) const; 1116 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1117 int GetCachedSize() const { return _cached_size_; } 1118 private: 1119 void SharedCtor(); 1120 void SharedDtor(); 1121 void SetCachedSize(int size) const; 1122 public: 1123 1124 ::google::protobuf::Metadata GetMetadata() const; 1125 1126 // nested types ---------------------------------------------------- 1127 1128 // accessors ------------------------------------------------------- 1129 1130 // optional int32 dbm = 1; 1131 inline bool has_dbm() const; 1132 inline void clear_dbm(); 1133 static const int kDbmFieldNumber = 1; 1134 inline ::google::protobuf::int32 dbm() const; 1135 inline void set_dbm(::google::protobuf::int32 value); 1136 1137 // optional int32 ecio = 2; 1138 inline bool has_ecio() const; 1139 inline void clear_ecio(); 1140 static const int kEcioFieldNumber = 2; 1141 inline ::google::protobuf::int32 ecio() const; 1142 inline void set_ecio(::google::protobuf::int32 value); 1143 1144 // optional int32 signal_noise_ratio = 3; 1145 inline bool has_signal_noise_ratio() const; 1146 inline void clear_signal_noise_ratio(); 1147 static const int kSignalNoiseRatioFieldNumber = 3; 1148 inline ::google::protobuf::int32 signal_noise_ratio() const; 1149 inline void set_signal_noise_ratio(::google::protobuf::int32 value); 1150 1151 // @@protoc_insertion_point(class_scope:ril_proto.RILEVDOSignalStrength) 1152 private: 1153 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1154 mutable int _cached_size_; 1155 1156 ::google::protobuf::int32 dbm_; 1157 ::google::protobuf::int32 ecio_; 1158 ::google::protobuf::int32 signal_noise_ratio_; 1159 friend void protobuf_AddDesc_ril_2eproto(); 1160 friend void protobuf_AssignDesc_ril_2eproto(); 1161 friend void protobuf_ShutdownFile_ril_2eproto(); 1162 1163 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1164 1165 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1166 inline bool _has_bit(int index) const { 1167 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1168 } 1169 inline void _set_bit(int index) { 1170 _has_bits_[index / 32] |= (1u << (index % 32)); 1171 } 1172 inline void _clear_bit(int index) { 1173 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1174 } 1175 1176 void InitAsDefaultInstance(); 1177 static RILEVDOSignalStrength* default_instance_; 1178}; 1179// ------------------------------------------------------------------- 1180 1181class RspStrings : public ::google::protobuf::Message { 1182 public: 1183 RspStrings(); 1184 virtual ~RspStrings(); 1185 1186 RspStrings(const RspStrings& from); 1187 1188 inline RspStrings& operator=(const RspStrings& from) { 1189 CopyFrom(from); 1190 return *this; 1191 } 1192 1193 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1194 return _unknown_fields_; 1195 } 1196 1197 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1198 return &_unknown_fields_; 1199 } 1200 1201 static const ::google::protobuf::Descriptor* descriptor(); 1202 static const RspStrings& default_instance(); 1203 1204 void Swap(RspStrings* other); 1205 1206 // implements Message ---------------------------------------------- 1207 1208 RspStrings* New() const; 1209 void CopyFrom(const ::google::protobuf::Message& from); 1210 void MergeFrom(const ::google::protobuf::Message& from); 1211 void CopyFrom(const RspStrings& from); 1212 void MergeFrom(const RspStrings& from); 1213 void Clear(); 1214 bool IsInitialized() const; 1215 1216 int ByteSize() const; 1217 bool MergePartialFromCodedStream( 1218 ::google::protobuf::io::CodedInputStream* input); 1219 void SerializeWithCachedSizes( 1220 ::google::protobuf::io::CodedOutputStream* output) const; 1221 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1222 int GetCachedSize() const { return _cached_size_; } 1223 private: 1224 void SharedCtor(); 1225 void SharedDtor(); 1226 void SetCachedSize(int size) const; 1227 public: 1228 1229 ::google::protobuf::Metadata GetMetadata() const; 1230 1231 // nested types ---------------------------------------------------- 1232 1233 // accessors ------------------------------------------------------- 1234 1235 // repeated string strings = 1; 1236 inline int strings_size() const; 1237 inline void clear_strings(); 1238 static const int kStringsFieldNumber = 1; 1239 inline const ::std::string& strings(int index) const; 1240 inline ::std::string* mutable_strings(int index); 1241 inline void set_strings(int index, const ::std::string& value); 1242 inline void set_strings(int index, const char* value); 1243 inline void set_strings(int index, const char* value, size_t size); 1244 inline ::std::string* add_strings(); 1245 inline void add_strings(const ::std::string& value); 1246 inline void add_strings(const char* value); 1247 inline void add_strings(const char* value, size_t size); 1248 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& strings() const; 1249 inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_strings(); 1250 1251 // @@protoc_insertion_point(class_scope:ril_proto.RspStrings) 1252 private: 1253 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1254 mutable int _cached_size_; 1255 1256 ::google::protobuf::RepeatedPtrField< ::std::string> strings_; 1257 friend void protobuf_AddDesc_ril_2eproto(); 1258 friend void protobuf_AssignDesc_ril_2eproto(); 1259 friend void protobuf_ShutdownFile_ril_2eproto(); 1260 1261 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1262 1263 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1264 inline bool _has_bit(int index) const { 1265 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1266 } 1267 inline void _set_bit(int index) { 1268 _has_bits_[index / 32] |= (1u << (index % 32)); 1269 } 1270 inline void _clear_bit(int index) { 1271 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1272 } 1273 1274 void InitAsDefaultInstance(); 1275 static RspStrings* default_instance_; 1276}; 1277// ------------------------------------------------------------------- 1278 1279class RspIntegers : public ::google::protobuf::Message { 1280 public: 1281 RspIntegers(); 1282 virtual ~RspIntegers(); 1283 1284 RspIntegers(const RspIntegers& from); 1285 1286 inline RspIntegers& operator=(const RspIntegers& from) { 1287 CopyFrom(from); 1288 return *this; 1289 } 1290 1291 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1292 return _unknown_fields_; 1293 } 1294 1295 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1296 return &_unknown_fields_; 1297 } 1298 1299 static const ::google::protobuf::Descriptor* descriptor(); 1300 static const RspIntegers& default_instance(); 1301 1302 void Swap(RspIntegers* other); 1303 1304 // implements Message ---------------------------------------------- 1305 1306 RspIntegers* New() const; 1307 void CopyFrom(const ::google::protobuf::Message& from); 1308 void MergeFrom(const ::google::protobuf::Message& from); 1309 void CopyFrom(const RspIntegers& from); 1310 void MergeFrom(const RspIntegers& from); 1311 void Clear(); 1312 bool IsInitialized() const; 1313 1314 int ByteSize() const; 1315 bool MergePartialFromCodedStream( 1316 ::google::protobuf::io::CodedInputStream* input); 1317 void SerializeWithCachedSizes( 1318 ::google::protobuf::io::CodedOutputStream* output) const; 1319 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1320 int GetCachedSize() const { return _cached_size_; } 1321 private: 1322 void SharedCtor(); 1323 void SharedDtor(); 1324 void SetCachedSize(int size) const; 1325 public: 1326 1327 ::google::protobuf::Metadata GetMetadata() const; 1328 1329 // nested types ---------------------------------------------------- 1330 1331 // accessors ------------------------------------------------------- 1332 1333 // repeated int32 integers = 1; 1334 inline int integers_size() const; 1335 inline void clear_integers(); 1336 static const int kIntegersFieldNumber = 1; 1337 inline ::google::protobuf::int32 integers(int index) const; 1338 inline void set_integers(int index, ::google::protobuf::int32 value); 1339 inline void add_integers(::google::protobuf::int32 value); 1340 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 1341 integers() const; 1342 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 1343 mutable_integers(); 1344 1345 // @@protoc_insertion_point(class_scope:ril_proto.RspIntegers) 1346 private: 1347 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1348 mutable int _cached_size_; 1349 1350 ::google::protobuf::RepeatedField< ::google::protobuf::int32 > integers_; 1351 friend void protobuf_AddDesc_ril_2eproto(); 1352 friend void protobuf_AssignDesc_ril_2eproto(); 1353 friend void protobuf_ShutdownFile_ril_2eproto(); 1354 1355 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1356 1357 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1358 inline bool _has_bit(int index) const { 1359 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1360 } 1361 inline void _set_bit(int index) { 1362 _has_bits_[index / 32] |= (1u << (index % 32)); 1363 } 1364 inline void _clear_bit(int index) { 1365 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1366 } 1367 1368 void InitAsDefaultInstance(); 1369 static RspIntegers* default_instance_; 1370}; 1371// ------------------------------------------------------------------- 1372 1373class RspGetSimStatus : public ::google::protobuf::Message { 1374 public: 1375 RspGetSimStatus(); 1376 virtual ~RspGetSimStatus(); 1377 1378 RspGetSimStatus(const RspGetSimStatus& from); 1379 1380 inline RspGetSimStatus& operator=(const RspGetSimStatus& from) { 1381 CopyFrom(from); 1382 return *this; 1383 } 1384 1385 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1386 return _unknown_fields_; 1387 } 1388 1389 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1390 return &_unknown_fields_; 1391 } 1392 1393 static const ::google::protobuf::Descriptor* descriptor(); 1394 static const RspGetSimStatus& default_instance(); 1395 1396 void Swap(RspGetSimStatus* other); 1397 1398 // implements Message ---------------------------------------------- 1399 1400 RspGetSimStatus* New() const; 1401 void CopyFrom(const ::google::protobuf::Message& from); 1402 void MergeFrom(const ::google::protobuf::Message& from); 1403 void CopyFrom(const RspGetSimStatus& from); 1404 void MergeFrom(const RspGetSimStatus& from); 1405 void Clear(); 1406 bool IsInitialized() const; 1407 1408 int ByteSize() const; 1409 bool MergePartialFromCodedStream( 1410 ::google::protobuf::io::CodedInputStream* input); 1411 void SerializeWithCachedSizes( 1412 ::google::protobuf::io::CodedOutputStream* output) const; 1413 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1414 int GetCachedSize() const { return _cached_size_; } 1415 private: 1416 void SharedCtor(); 1417 void SharedDtor(); 1418 void SetCachedSize(int size) const; 1419 public: 1420 1421 ::google::protobuf::Metadata GetMetadata() const; 1422 1423 // nested types ---------------------------------------------------- 1424 1425 // accessors ------------------------------------------------------- 1426 1427 // required .ril_proto.RilCardStatus card_status = 1; 1428 inline bool has_card_status() const; 1429 inline void clear_card_status(); 1430 static const int kCardStatusFieldNumber = 1; 1431 inline const ::ril_proto::RilCardStatus& card_status() const; 1432 inline ::ril_proto::RilCardStatus* mutable_card_status(); 1433 1434 // @@protoc_insertion_point(class_scope:ril_proto.RspGetSimStatus) 1435 private: 1436 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1437 mutable int _cached_size_; 1438 1439 ::ril_proto::RilCardStatus* card_status_; 1440 friend void protobuf_AddDesc_ril_2eproto(); 1441 friend void protobuf_AssignDesc_ril_2eproto(); 1442 friend void protobuf_ShutdownFile_ril_2eproto(); 1443 1444 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1445 1446 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1447 inline bool _has_bit(int index) const { 1448 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1449 } 1450 inline void _set_bit(int index) { 1451 _has_bits_[index / 32] |= (1u << (index % 32)); 1452 } 1453 inline void _clear_bit(int index) { 1454 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1455 } 1456 1457 void InitAsDefaultInstance(); 1458 static RspGetSimStatus* default_instance_; 1459}; 1460// ------------------------------------------------------------------- 1461 1462class ReqEnterSimPin : public ::google::protobuf::Message { 1463 public: 1464 ReqEnterSimPin(); 1465 virtual ~ReqEnterSimPin(); 1466 1467 ReqEnterSimPin(const ReqEnterSimPin& from); 1468 1469 inline ReqEnterSimPin& operator=(const ReqEnterSimPin& from) { 1470 CopyFrom(from); 1471 return *this; 1472 } 1473 1474 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1475 return _unknown_fields_; 1476 } 1477 1478 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1479 return &_unknown_fields_; 1480 } 1481 1482 static const ::google::protobuf::Descriptor* descriptor(); 1483 static const ReqEnterSimPin& default_instance(); 1484 1485 void Swap(ReqEnterSimPin* other); 1486 1487 // implements Message ---------------------------------------------- 1488 1489 ReqEnterSimPin* New() const; 1490 void CopyFrom(const ::google::protobuf::Message& from); 1491 void MergeFrom(const ::google::protobuf::Message& from); 1492 void CopyFrom(const ReqEnterSimPin& from); 1493 void MergeFrom(const ReqEnterSimPin& from); 1494 void Clear(); 1495 bool IsInitialized() const; 1496 1497 int ByteSize() const; 1498 bool MergePartialFromCodedStream( 1499 ::google::protobuf::io::CodedInputStream* input); 1500 void SerializeWithCachedSizes( 1501 ::google::protobuf::io::CodedOutputStream* output) const; 1502 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1503 int GetCachedSize() const { return _cached_size_; } 1504 private: 1505 void SharedCtor(); 1506 void SharedDtor(); 1507 void SetCachedSize(int size) const; 1508 public: 1509 1510 ::google::protobuf::Metadata GetMetadata() const; 1511 1512 // nested types ---------------------------------------------------- 1513 1514 // accessors ------------------------------------------------------- 1515 1516 // required string pin = 1; 1517 inline bool has_pin() const; 1518 inline void clear_pin(); 1519 static const int kPinFieldNumber = 1; 1520 inline const ::std::string& pin() const; 1521 inline void set_pin(const ::std::string& value); 1522 inline void set_pin(const char* value); 1523 inline void set_pin(const char* value, size_t size); 1524 inline ::std::string* mutable_pin(); 1525 1526 // @@protoc_insertion_point(class_scope:ril_proto.ReqEnterSimPin) 1527 private: 1528 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1529 mutable int _cached_size_; 1530 1531 ::std::string* pin_; 1532 static const ::std::string _default_pin_; 1533 friend void protobuf_AddDesc_ril_2eproto(); 1534 friend void protobuf_AssignDesc_ril_2eproto(); 1535 friend void protobuf_ShutdownFile_ril_2eproto(); 1536 1537 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1538 1539 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1540 inline bool _has_bit(int index) const { 1541 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1542 } 1543 inline void _set_bit(int index) { 1544 _has_bits_[index / 32] |= (1u << (index % 32)); 1545 } 1546 inline void _clear_bit(int index) { 1547 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1548 } 1549 1550 void InitAsDefaultInstance(); 1551 static ReqEnterSimPin* default_instance_; 1552}; 1553// ------------------------------------------------------------------- 1554 1555class RspEnterSimPin : public ::google::protobuf::Message { 1556 public: 1557 RspEnterSimPin(); 1558 virtual ~RspEnterSimPin(); 1559 1560 RspEnterSimPin(const RspEnterSimPin& from); 1561 1562 inline RspEnterSimPin& operator=(const RspEnterSimPin& from) { 1563 CopyFrom(from); 1564 return *this; 1565 } 1566 1567 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1568 return _unknown_fields_; 1569 } 1570 1571 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1572 return &_unknown_fields_; 1573 } 1574 1575 static const ::google::protobuf::Descriptor* descriptor(); 1576 static const RspEnterSimPin& default_instance(); 1577 1578 void Swap(RspEnterSimPin* other); 1579 1580 // implements Message ---------------------------------------------- 1581 1582 RspEnterSimPin* New() const; 1583 void CopyFrom(const ::google::protobuf::Message& from); 1584 void MergeFrom(const ::google::protobuf::Message& from); 1585 void CopyFrom(const RspEnterSimPin& from); 1586 void MergeFrom(const RspEnterSimPin& from); 1587 void Clear(); 1588 bool IsInitialized() const; 1589 1590 int ByteSize() const; 1591 bool MergePartialFromCodedStream( 1592 ::google::protobuf::io::CodedInputStream* input); 1593 void SerializeWithCachedSizes( 1594 ::google::protobuf::io::CodedOutputStream* output) const; 1595 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1596 int GetCachedSize() const { return _cached_size_; } 1597 private: 1598 void SharedCtor(); 1599 void SharedDtor(); 1600 void SetCachedSize(int size) const; 1601 public: 1602 1603 ::google::protobuf::Metadata GetMetadata() const; 1604 1605 // nested types ---------------------------------------------------- 1606 1607 // accessors ------------------------------------------------------- 1608 1609 // required int32 retries_remaining = 1; 1610 inline bool has_retries_remaining() const; 1611 inline void clear_retries_remaining(); 1612 static const int kRetriesRemainingFieldNumber = 1; 1613 inline ::google::protobuf::int32 retries_remaining() const; 1614 inline void set_retries_remaining(::google::protobuf::int32 value); 1615 1616 // @@protoc_insertion_point(class_scope:ril_proto.RspEnterSimPin) 1617 private: 1618 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1619 mutable int _cached_size_; 1620 1621 ::google::protobuf::int32 retries_remaining_; 1622 friend void protobuf_AddDesc_ril_2eproto(); 1623 friend void protobuf_AssignDesc_ril_2eproto(); 1624 friend void protobuf_ShutdownFile_ril_2eproto(); 1625 1626 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1627 1628 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1629 inline bool _has_bit(int index) const { 1630 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1631 } 1632 inline void _set_bit(int index) { 1633 _has_bits_[index / 32] |= (1u << (index % 32)); 1634 } 1635 inline void _clear_bit(int index) { 1636 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1637 } 1638 1639 void InitAsDefaultInstance(); 1640 static RspEnterSimPin* default_instance_; 1641}; 1642// ------------------------------------------------------------------- 1643 1644class RspGetCurrentCalls : public ::google::protobuf::Message { 1645 public: 1646 RspGetCurrentCalls(); 1647 virtual ~RspGetCurrentCalls(); 1648 1649 RspGetCurrentCalls(const RspGetCurrentCalls& from); 1650 1651 inline RspGetCurrentCalls& operator=(const RspGetCurrentCalls& from) { 1652 CopyFrom(from); 1653 return *this; 1654 } 1655 1656 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1657 return _unknown_fields_; 1658 } 1659 1660 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1661 return &_unknown_fields_; 1662 } 1663 1664 static const ::google::protobuf::Descriptor* descriptor(); 1665 static const RspGetCurrentCalls& default_instance(); 1666 1667 void Swap(RspGetCurrentCalls* other); 1668 1669 // implements Message ---------------------------------------------- 1670 1671 RspGetCurrentCalls* New() const; 1672 void CopyFrom(const ::google::protobuf::Message& from); 1673 void MergeFrom(const ::google::protobuf::Message& from); 1674 void CopyFrom(const RspGetCurrentCalls& from); 1675 void MergeFrom(const RspGetCurrentCalls& from); 1676 void Clear(); 1677 bool IsInitialized() const; 1678 1679 int ByteSize() const; 1680 bool MergePartialFromCodedStream( 1681 ::google::protobuf::io::CodedInputStream* input); 1682 void SerializeWithCachedSizes( 1683 ::google::protobuf::io::CodedOutputStream* output) const; 1684 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1685 int GetCachedSize() const { return _cached_size_; } 1686 private: 1687 void SharedCtor(); 1688 void SharedDtor(); 1689 void SetCachedSize(int size) const; 1690 public: 1691 1692 ::google::protobuf::Metadata GetMetadata() const; 1693 1694 // nested types ---------------------------------------------------- 1695 1696 // accessors ------------------------------------------------------- 1697 1698 // repeated .ril_proto.RilCall calls = 1; 1699 inline int calls_size() const; 1700 inline void clear_calls(); 1701 static const int kCallsFieldNumber = 1; 1702 inline const ::ril_proto::RilCall& calls(int index) const; 1703 inline ::ril_proto::RilCall* mutable_calls(int index); 1704 inline ::ril_proto::RilCall* add_calls(); 1705 inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall >& 1706 calls() const; 1707 inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall >* 1708 mutable_calls(); 1709 1710 // @@protoc_insertion_point(class_scope:ril_proto.RspGetCurrentCalls) 1711 private: 1712 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1713 mutable int _cached_size_; 1714 1715 ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall > calls_; 1716 friend void protobuf_AddDesc_ril_2eproto(); 1717 friend void protobuf_AssignDesc_ril_2eproto(); 1718 friend void protobuf_ShutdownFile_ril_2eproto(); 1719 1720 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1721 1722 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1723 inline bool _has_bit(int index) const { 1724 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1725 } 1726 inline void _set_bit(int index) { 1727 _has_bits_[index / 32] |= (1u << (index % 32)); 1728 } 1729 inline void _clear_bit(int index) { 1730 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1731 } 1732 1733 void InitAsDefaultInstance(); 1734 static RspGetCurrentCalls* default_instance_; 1735}; 1736// ------------------------------------------------------------------- 1737 1738class ReqDial : public ::google::protobuf::Message { 1739 public: 1740 ReqDial(); 1741 virtual ~ReqDial(); 1742 1743 ReqDial(const ReqDial& from); 1744 1745 inline ReqDial& operator=(const ReqDial& from) { 1746 CopyFrom(from); 1747 return *this; 1748 } 1749 1750 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1751 return _unknown_fields_; 1752 } 1753 1754 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1755 return &_unknown_fields_; 1756 } 1757 1758 static const ::google::protobuf::Descriptor* descriptor(); 1759 static const ReqDial& default_instance(); 1760 1761 void Swap(ReqDial* other); 1762 1763 // implements Message ---------------------------------------------- 1764 1765 ReqDial* New() const; 1766 void CopyFrom(const ::google::protobuf::Message& from); 1767 void MergeFrom(const ::google::protobuf::Message& from); 1768 void CopyFrom(const ReqDial& from); 1769 void MergeFrom(const ReqDial& from); 1770 void Clear(); 1771 bool IsInitialized() const; 1772 1773 int ByteSize() const; 1774 bool MergePartialFromCodedStream( 1775 ::google::protobuf::io::CodedInputStream* input); 1776 void SerializeWithCachedSizes( 1777 ::google::protobuf::io::CodedOutputStream* output) const; 1778 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1779 int GetCachedSize() const { return _cached_size_; } 1780 private: 1781 void SharedCtor(); 1782 void SharedDtor(); 1783 void SetCachedSize(int size) const; 1784 public: 1785 1786 ::google::protobuf::Metadata GetMetadata() const; 1787 1788 // nested types ---------------------------------------------------- 1789 1790 // accessors ------------------------------------------------------- 1791 1792 // optional string address = 1; 1793 inline bool has_address() const; 1794 inline void clear_address(); 1795 static const int kAddressFieldNumber = 1; 1796 inline const ::std::string& address() const; 1797 inline void set_address(const ::std::string& value); 1798 inline void set_address(const char* value); 1799 inline void set_address(const char* value, size_t size); 1800 inline ::std::string* mutable_address(); 1801 1802 // optional int32 clir = 2; 1803 inline bool has_clir() const; 1804 inline void clear_clir(); 1805 static const int kClirFieldNumber = 2; 1806 inline ::google::protobuf::int32 clir() const; 1807 inline void set_clir(::google::protobuf::int32 value); 1808 1809 // optional .ril_proto.RilUusInfo uus_info = 3; 1810 inline bool has_uus_info() const; 1811 inline void clear_uus_info(); 1812 static const int kUusInfoFieldNumber = 3; 1813 inline const ::ril_proto::RilUusInfo& uus_info() const; 1814 inline ::ril_proto::RilUusInfo* mutable_uus_info(); 1815 1816 // @@protoc_insertion_point(class_scope:ril_proto.ReqDial) 1817 private: 1818 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1819 mutable int _cached_size_; 1820 1821 ::std::string* address_; 1822 static const ::std::string _default_address_; 1823 ::google::protobuf::int32 clir_; 1824 ::ril_proto::RilUusInfo* uus_info_; 1825 friend void protobuf_AddDesc_ril_2eproto(); 1826 friend void protobuf_AssignDesc_ril_2eproto(); 1827 friend void protobuf_ShutdownFile_ril_2eproto(); 1828 1829 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 1830 1831 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1832 inline bool _has_bit(int index) const { 1833 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1834 } 1835 inline void _set_bit(int index) { 1836 _has_bits_[index / 32] |= (1u << (index % 32)); 1837 } 1838 inline void _clear_bit(int index) { 1839 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1840 } 1841 1842 void InitAsDefaultInstance(); 1843 static ReqDial* default_instance_; 1844}; 1845// ------------------------------------------------------------------- 1846 1847class ReqHangUp : public ::google::protobuf::Message { 1848 public: 1849 ReqHangUp(); 1850 virtual ~ReqHangUp(); 1851 1852 ReqHangUp(const ReqHangUp& from); 1853 1854 inline ReqHangUp& operator=(const ReqHangUp& from) { 1855 CopyFrom(from); 1856 return *this; 1857 } 1858 1859 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1860 return _unknown_fields_; 1861 } 1862 1863 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1864 return &_unknown_fields_; 1865 } 1866 1867 static const ::google::protobuf::Descriptor* descriptor(); 1868 static const ReqHangUp& default_instance(); 1869 1870 void Swap(ReqHangUp* other); 1871 1872 // implements Message ---------------------------------------------- 1873 1874 ReqHangUp* New() const; 1875 void CopyFrom(const ::google::protobuf::Message& from); 1876 void MergeFrom(const ::google::protobuf::Message& from); 1877 void CopyFrom(const ReqHangUp& from); 1878 void MergeFrom(const ReqHangUp& from); 1879 void Clear(); 1880 bool IsInitialized() const; 1881 1882 int ByteSize() const; 1883 bool MergePartialFromCodedStream( 1884 ::google::protobuf::io::CodedInputStream* input); 1885 void SerializeWithCachedSizes( 1886 ::google::protobuf::io::CodedOutputStream* output) const; 1887 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1888 int GetCachedSize() const { return _cached_size_; } 1889 private: 1890 void SharedCtor(); 1891 void SharedDtor(); 1892 void SetCachedSize(int size) const; 1893 public: 1894 1895 ::google::protobuf::Metadata GetMetadata() const; 1896 1897 // nested types ---------------------------------------------------- 1898 1899 // accessors ------------------------------------------------------- 1900 1901 // required int32 connection_index = 1; 1902 inline bool has_connection_index() const; 1903 inline void clear_connection_index(); 1904 static const int kConnectionIndexFieldNumber = 1; 1905 inline ::google::protobuf::int32 connection_index() const; 1906 inline void set_connection_index(::google::protobuf::int32 value); 1907 1908 // @@protoc_insertion_point(class_scope:ril_proto.ReqHangUp) 1909 private: 1910 ::google::protobuf::UnknownFieldSet _unknown_fields_; 1911 mutable int _cached_size_; 1912 1913 ::google::protobuf::int32 connection_index_; 1914 friend void protobuf_AddDesc_ril_2eproto(); 1915 friend void protobuf_AssignDesc_ril_2eproto(); 1916 friend void protobuf_ShutdownFile_ril_2eproto(); 1917 1918 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 1919 1920 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 1921 inline bool _has_bit(int index) const { 1922 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 1923 } 1924 inline void _set_bit(int index) { 1925 _has_bits_[index / 32] |= (1u << (index % 32)); 1926 } 1927 inline void _clear_bit(int index) { 1928 _has_bits_[index / 32] &= ~(1u << (index % 32)); 1929 } 1930 1931 void InitAsDefaultInstance(); 1932 static ReqHangUp* default_instance_; 1933}; 1934// ------------------------------------------------------------------- 1935 1936class RspLastCallFailCause : public ::google::protobuf::Message { 1937 public: 1938 RspLastCallFailCause(); 1939 virtual ~RspLastCallFailCause(); 1940 1941 RspLastCallFailCause(const RspLastCallFailCause& from); 1942 1943 inline RspLastCallFailCause& operator=(const RspLastCallFailCause& from) { 1944 CopyFrom(from); 1945 return *this; 1946 } 1947 1948 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 1949 return _unknown_fields_; 1950 } 1951 1952 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 1953 return &_unknown_fields_; 1954 } 1955 1956 static const ::google::protobuf::Descriptor* descriptor(); 1957 static const RspLastCallFailCause& default_instance(); 1958 1959 void Swap(RspLastCallFailCause* other); 1960 1961 // implements Message ---------------------------------------------- 1962 1963 RspLastCallFailCause* New() const; 1964 void CopyFrom(const ::google::protobuf::Message& from); 1965 void MergeFrom(const ::google::protobuf::Message& from); 1966 void CopyFrom(const RspLastCallFailCause& from); 1967 void MergeFrom(const RspLastCallFailCause& from); 1968 void Clear(); 1969 bool IsInitialized() const; 1970 1971 int ByteSize() const; 1972 bool MergePartialFromCodedStream( 1973 ::google::protobuf::io::CodedInputStream* input); 1974 void SerializeWithCachedSizes( 1975 ::google::protobuf::io::CodedOutputStream* output) const; 1976 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 1977 int GetCachedSize() const { return _cached_size_; } 1978 private: 1979 void SharedCtor(); 1980 void SharedDtor(); 1981 void SetCachedSize(int size) const; 1982 public: 1983 1984 ::google::protobuf::Metadata GetMetadata() const; 1985 1986 // nested types ---------------------------------------------------- 1987 1988 // accessors ------------------------------------------------------- 1989 1990 // required int32 last_call_fail_cause = 1; 1991 inline bool has_last_call_fail_cause() const; 1992 inline void clear_last_call_fail_cause(); 1993 static const int kLastCallFailCauseFieldNumber = 1; 1994 inline ::google::protobuf::int32 last_call_fail_cause() const; 1995 inline void set_last_call_fail_cause(::google::protobuf::int32 value); 1996 1997 // @@protoc_insertion_point(class_scope:ril_proto.RspLastCallFailCause) 1998 private: 1999 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2000 mutable int _cached_size_; 2001 2002 ::google::protobuf::int32 last_call_fail_cause_; 2003 friend void protobuf_AddDesc_ril_2eproto(); 2004 friend void protobuf_AssignDesc_ril_2eproto(); 2005 friend void protobuf_ShutdownFile_ril_2eproto(); 2006 2007 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2008 2009 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2010 inline bool _has_bit(int index) const { 2011 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2012 } 2013 inline void _set_bit(int index) { 2014 _has_bits_[index / 32] |= (1u << (index % 32)); 2015 } 2016 inline void _clear_bit(int index) { 2017 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2018 } 2019 2020 void InitAsDefaultInstance(); 2021 static RspLastCallFailCause* default_instance_; 2022}; 2023// ------------------------------------------------------------------- 2024 2025class RspSignalStrength : public ::google::protobuf::Message { 2026 public: 2027 RspSignalStrength(); 2028 virtual ~RspSignalStrength(); 2029 2030 RspSignalStrength(const RspSignalStrength& from); 2031 2032 inline RspSignalStrength& operator=(const RspSignalStrength& from) { 2033 CopyFrom(from); 2034 return *this; 2035 } 2036 2037 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2038 return _unknown_fields_; 2039 } 2040 2041 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2042 return &_unknown_fields_; 2043 } 2044 2045 static const ::google::protobuf::Descriptor* descriptor(); 2046 static const RspSignalStrength& default_instance(); 2047 2048 void Swap(RspSignalStrength* other); 2049 2050 // implements Message ---------------------------------------------- 2051 2052 RspSignalStrength* New() const; 2053 void CopyFrom(const ::google::protobuf::Message& from); 2054 void MergeFrom(const ::google::protobuf::Message& from); 2055 void CopyFrom(const RspSignalStrength& from); 2056 void MergeFrom(const RspSignalStrength& from); 2057 void Clear(); 2058 bool IsInitialized() const; 2059 2060 int ByteSize() const; 2061 bool MergePartialFromCodedStream( 2062 ::google::protobuf::io::CodedInputStream* input); 2063 void SerializeWithCachedSizes( 2064 ::google::protobuf::io::CodedOutputStream* output) const; 2065 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2066 int GetCachedSize() const { return _cached_size_; } 2067 private: 2068 void SharedCtor(); 2069 void SharedDtor(); 2070 void SetCachedSize(int size) const; 2071 public: 2072 2073 ::google::protobuf::Metadata GetMetadata() const; 2074 2075 // nested types ---------------------------------------------------- 2076 2077 // accessors ------------------------------------------------------- 2078 2079 // optional .ril_proto.RILGWSignalStrength gw_signalstrength = 1; 2080 inline bool has_gw_signalstrength() const; 2081 inline void clear_gw_signalstrength(); 2082 static const int kGwSignalstrengthFieldNumber = 1; 2083 inline const ::ril_proto::RILGWSignalStrength& gw_signalstrength() const; 2084 inline ::ril_proto::RILGWSignalStrength* mutable_gw_signalstrength(); 2085 2086 // optional .ril_proto.RILCDMASignalStrength cdma_signalstrength = 2; 2087 inline bool has_cdma_signalstrength() const; 2088 inline void clear_cdma_signalstrength(); 2089 static const int kCdmaSignalstrengthFieldNumber = 2; 2090 inline const ::ril_proto::RILCDMASignalStrength& cdma_signalstrength() const; 2091 inline ::ril_proto::RILCDMASignalStrength* mutable_cdma_signalstrength(); 2092 2093 // optional .ril_proto.RILEVDOSignalStrength evdo_signalstrength = 3; 2094 inline bool has_evdo_signalstrength() const; 2095 inline void clear_evdo_signalstrength(); 2096 static const int kEvdoSignalstrengthFieldNumber = 3; 2097 inline const ::ril_proto::RILEVDOSignalStrength& evdo_signalstrength() const; 2098 inline ::ril_proto::RILEVDOSignalStrength* mutable_evdo_signalstrength(); 2099 2100 // @@protoc_insertion_point(class_scope:ril_proto.RspSignalStrength) 2101 private: 2102 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2103 mutable int _cached_size_; 2104 2105 ::ril_proto::RILGWSignalStrength* gw_signalstrength_; 2106 ::ril_proto::RILCDMASignalStrength* cdma_signalstrength_; 2107 ::ril_proto::RILEVDOSignalStrength* evdo_signalstrength_; 2108 friend void protobuf_AddDesc_ril_2eproto(); 2109 friend void protobuf_AssignDesc_ril_2eproto(); 2110 friend void protobuf_ShutdownFile_ril_2eproto(); 2111 2112 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 2113 2114 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2115 inline bool _has_bit(int index) const { 2116 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2117 } 2118 inline void _set_bit(int index) { 2119 _has_bits_[index / 32] |= (1u << (index % 32)); 2120 } 2121 inline void _clear_bit(int index) { 2122 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2123 } 2124 2125 void InitAsDefaultInstance(); 2126 static RspSignalStrength* default_instance_; 2127}; 2128// ------------------------------------------------------------------- 2129 2130class RspOperator : public ::google::protobuf::Message { 2131 public: 2132 RspOperator(); 2133 virtual ~RspOperator(); 2134 2135 RspOperator(const RspOperator& from); 2136 2137 inline RspOperator& operator=(const RspOperator& from) { 2138 CopyFrom(from); 2139 return *this; 2140 } 2141 2142 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2143 return _unknown_fields_; 2144 } 2145 2146 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2147 return &_unknown_fields_; 2148 } 2149 2150 static const ::google::protobuf::Descriptor* descriptor(); 2151 static const RspOperator& default_instance(); 2152 2153 void Swap(RspOperator* other); 2154 2155 // implements Message ---------------------------------------------- 2156 2157 RspOperator* New() const; 2158 void CopyFrom(const ::google::protobuf::Message& from); 2159 void MergeFrom(const ::google::protobuf::Message& from); 2160 void CopyFrom(const RspOperator& from); 2161 void MergeFrom(const RspOperator& from); 2162 void Clear(); 2163 bool IsInitialized() const; 2164 2165 int ByteSize() const; 2166 bool MergePartialFromCodedStream( 2167 ::google::protobuf::io::CodedInputStream* input); 2168 void SerializeWithCachedSizes( 2169 ::google::protobuf::io::CodedOutputStream* output) const; 2170 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2171 int GetCachedSize() const { return _cached_size_; } 2172 private: 2173 void SharedCtor(); 2174 void SharedDtor(); 2175 void SetCachedSize(int size) const; 2176 public: 2177 2178 ::google::protobuf::Metadata GetMetadata() const; 2179 2180 // nested types ---------------------------------------------------- 2181 2182 // accessors ------------------------------------------------------- 2183 2184 // optional string long_alpha_ons = 1; 2185 inline bool has_long_alpha_ons() const; 2186 inline void clear_long_alpha_ons(); 2187 static const int kLongAlphaOnsFieldNumber = 1; 2188 inline const ::std::string& long_alpha_ons() const; 2189 inline void set_long_alpha_ons(const ::std::string& value); 2190 inline void set_long_alpha_ons(const char* value); 2191 inline void set_long_alpha_ons(const char* value, size_t size); 2192 inline ::std::string* mutable_long_alpha_ons(); 2193 2194 // optional string short_alpha_ons = 2; 2195 inline bool has_short_alpha_ons() const; 2196 inline void clear_short_alpha_ons(); 2197 static const int kShortAlphaOnsFieldNumber = 2; 2198 inline const ::std::string& short_alpha_ons() const; 2199 inline void set_short_alpha_ons(const ::std::string& value); 2200 inline void set_short_alpha_ons(const char* value); 2201 inline void set_short_alpha_ons(const char* value, size_t size); 2202 inline ::std::string* mutable_short_alpha_ons(); 2203 2204 // optional string mcc_mnc = 3; 2205 inline bool has_mcc_mnc() const; 2206 inline void clear_mcc_mnc(); 2207 static const int kMccMncFieldNumber = 3; 2208 inline const ::std::string& mcc_mnc() const; 2209 inline void set_mcc_mnc(const ::std::string& value); 2210 inline void set_mcc_mnc(const char* value); 2211 inline void set_mcc_mnc(const char* value, size_t size); 2212 inline ::std::string* mutable_mcc_mnc(); 2213 2214 // @@protoc_insertion_point(class_scope:ril_proto.RspOperator) 2215 private: 2216 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2217 mutable int _cached_size_; 2218 2219 ::std::string* long_alpha_ons_; 2220 static const ::std::string _default_long_alpha_ons_; 2221 ::std::string* short_alpha_ons_; 2222 static const ::std::string _default_short_alpha_ons_; 2223 ::std::string* mcc_mnc_; 2224 static const ::std::string _default_mcc_mnc_; 2225 friend void protobuf_AddDesc_ril_2eproto(); 2226 friend void protobuf_AssignDesc_ril_2eproto(); 2227 friend void protobuf_ShutdownFile_ril_2eproto(); 2228 2229 ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; 2230 2231 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2232 inline bool _has_bit(int index) const { 2233 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2234 } 2235 inline void _set_bit(int index) { 2236 _has_bits_[index / 32] |= (1u << (index % 32)); 2237 } 2238 inline void _clear_bit(int index) { 2239 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2240 } 2241 2242 void InitAsDefaultInstance(); 2243 static RspOperator* default_instance_; 2244}; 2245// ------------------------------------------------------------------- 2246 2247class ReqSeparateConnection : public ::google::protobuf::Message { 2248 public: 2249 ReqSeparateConnection(); 2250 virtual ~ReqSeparateConnection(); 2251 2252 ReqSeparateConnection(const ReqSeparateConnection& from); 2253 2254 inline ReqSeparateConnection& operator=(const ReqSeparateConnection& from) { 2255 CopyFrom(from); 2256 return *this; 2257 } 2258 2259 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2260 return _unknown_fields_; 2261 } 2262 2263 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2264 return &_unknown_fields_; 2265 } 2266 2267 static const ::google::protobuf::Descriptor* descriptor(); 2268 static const ReqSeparateConnection& default_instance(); 2269 2270 void Swap(ReqSeparateConnection* other); 2271 2272 // implements Message ---------------------------------------------- 2273 2274 ReqSeparateConnection* New() const; 2275 void CopyFrom(const ::google::protobuf::Message& from); 2276 void MergeFrom(const ::google::protobuf::Message& from); 2277 void CopyFrom(const ReqSeparateConnection& from); 2278 void MergeFrom(const ReqSeparateConnection& from); 2279 void Clear(); 2280 bool IsInitialized() const; 2281 2282 int ByteSize() const; 2283 bool MergePartialFromCodedStream( 2284 ::google::protobuf::io::CodedInputStream* input); 2285 void SerializeWithCachedSizes( 2286 ::google::protobuf::io::CodedOutputStream* output) const; 2287 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2288 int GetCachedSize() const { return _cached_size_; } 2289 private: 2290 void SharedCtor(); 2291 void SharedDtor(); 2292 void SetCachedSize(int size) const; 2293 public: 2294 2295 ::google::protobuf::Metadata GetMetadata() const; 2296 2297 // nested types ---------------------------------------------------- 2298 2299 // accessors ------------------------------------------------------- 2300 2301 // required int32 index = 1; 2302 inline bool has_index() const; 2303 inline void clear_index(); 2304 static const int kIndexFieldNumber = 1; 2305 inline ::google::protobuf::int32 index() const; 2306 inline void set_index(::google::protobuf::int32 value); 2307 2308 // @@protoc_insertion_point(class_scope:ril_proto.ReqSeparateConnection) 2309 private: 2310 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2311 mutable int _cached_size_; 2312 2313 ::google::protobuf::int32 index_; 2314 friend void protobuf_AddDesc_ril_2eproto(); 2315 friend void protobuf_AssignDesc_ril_2eproto(); 2316 friend void protobuf_ShutdownFile_ril_2eproto(); 2317 2318 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2319 2320 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2321 inline bool _has_bit(int index) const { 2322 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2323 } 2324 inline void _set_bit(int index) { 2325 _has_bits_[index / 32] |= (1u << (index % 32)); 2326 } 2327 inline void _clear_bit(int index) { 2328 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2329 } 2330 2331 void InitAsDefaultInstance(); 2332 static ReqSeparateConnection* default_instance_; 2333}; 2334// ------------------------------------------------------------------- 2335 2336class ReqSetMute : public ::google::protobuf::Message { 2337 public: 2338 ReqSetMute(); 2339 virtual ~ReqSetMute(); 2340 2341 ReqSetMute(const ReqSetMute& from); 2342 2343 inline ReqSetMute& operator=(const ReqSetMute& from) { 2344 CopyFrom(from); 2345 return *this; 2346 } 2347 2348 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2349 return _unknown_fields_; 2350 } 2351 2352 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2353 return &_unknown_fields_; 2354 } 2355 2356 static const ::google::protobuf::Descriptor* descriptor(); 2357 static const ReqSetMute& default_instance(); 2358 2359 void Swap(ReqSetMute* other); 2360 2361 // implements Message ---------------------------------------------- 2362 2363 ReqSetMute* New() const; 2364 void CopyFrom(const ::google::protobuf::Message& from); 2365 void MergeFrom(const ::google::protobuf::Message& from); 2366 void CopyFrom(const ReqSetMute& from); 2367 void MergeFrom(const ReqSetMute& from); 2368 void Clear(); 2369 bool IsInitialized() const; 2370 2371 int ByteSize() const; 2372 bool MergePartialFromCodedStream( 2373 ::google::protobuf::io::CodedInputStream* input); 2374 void SerializeWithCachedSizes( 2375 ::google::protobuf::io::CodedOutputStream* output) const; 2376 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2377 int GetCachedSize() const { return _cached_size_; } 2378 private: 2379 void SharedCtor(); 2380 void SharedDtor(); 2381 void SetCachedSize(int size) const; 2382 public: 2383 2384 ::google::protobuf::Metadata GetMetadata() const; 2385 2386 // nested types ---------------------------------------------------- 2387 2388 // accessors ------------------------------------------------------- 2389 2390 // required bool state = 1; 2391 inline bool has_state() const; 2392 inline void clear_state(); 2393 static const int kStateFieldNumber = 1; 2394 inline bool state() const; 2395 inline void set_state(bool value); 2396 2397 // @@protoc_insertion_point(class_scope:ril_proto.ReqSetMute) 2398 private: 2399 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2400 mutable int _cached_size_; 2401 2402 bool state_; 2403 friend void protobuf_AddDesc_ril_2eproto(); 2404 friend void protobuf_AssignDesc_ril_2eproto(); 2405 friend void protobuf_ShutdownFile_ril_2eproto(); 2406 2407 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2408 2409 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2410 inline bool _has_bit(int index) const { 2411 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2412 } 2413 inline void _set_bit(int index) { 2414 _has_bits_[index / 32] |= (1u << (index % 32)); 2415 } 2416 inline void _clear_bit(int index) { 2417 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2418 } 2419 2420 void InitAsDefaultInstance(); 2421 static ReqSetMute* default_instance_; 2422}; 2423// ------------------------------------------------------------------- 2424 2425class ReqScreenState : public ::google::protobuf::Message { 2426 public: 2427 ReqScreenState(); 2428 virtual ~ReqScreenState(); 2429 2430 ReqScreenState(const ReqScreenState& from); 2431 2432 inline ReqScreenState& operator=(const ReqScreenState& from) { 2433 CopyFrom(from); 2434 return *this; 2435 } 2436 2437 inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { 2438 return _unknown_fields_; 2439 } 2440 2441 inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { 2442 return &_unknown_fields_; 2443 } 2444 2445 static const ::google::protobuf::Descriptor* descriptor(); 2446 static const ReqScreenState& default_instance(); 2447 2448 void Swap(ReqScreenState* other); 2449 2450 // implements Message ---------------------------------------------- 2451 2452 ReqScreenState* New() const; 2453 void CopyFrom(const ::google::protobuf::Message& from); 2454 void MergeFrom(const ::google::protobuf::Message& from); 2455 void CopyFrom(const ReqScreenState& from); 2456 void MergeFrom(const ReqScreenState& from); 2457 void Clear(); 2458 bool IsInitialized() const; 2459 2460 int ByteSize() const; 2461 bool MergePartialFromCodedStream( 2462 ::google::protobuf::io::CodedInputStream* input); 2463 void SerializeWithCachedSizes( 2464 ::google::protobuf::io::CodedOutputStream* output) const; 2465 ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; 2466 int GetCachedSize() const { return _cached_size_; } 2467 private: 2468 void SharedCtor(); 2469 void SharedDtor(); 2470 void SetCachedSize(int size) const; 2471 public: 2472 2473 ::google::protobuf::Metadata GetMetadata() const; 2474 2475 // nested types ---------------------------------------------------- 2476 2477 // accessors ------------------------------------------------------- 2478 2479 // required bool state = 1; 2480 inline bool has_state() const; 2481 inline void clear_state(); 2482 static const int kStateFieldNumber = 1; 2483 inline bool state() const; 2484 inline void set_state(bool value); 2485 2486 // @@protoc_insertion_point(class_scope:ril_proto.ReqScreenState) 2487 private: 2488 ::google::protobuf::UnknownFieldSet _unknown_fields_; 2489 mutable int _cached_size_; 2490 2491 bool state_; 2492 friend void protobuf_AddDesc_ril_2eproto(); 2493 friend void protobuf_AssignDesc_ril_2eproto(); 2494 friend void protobuf_ShutdownFile_ril_2eproto(); 2495 2496 ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; 2497 2498 // WHY DOES & HAVE LOWER PRECEDENCE THAN != !? 2499 inline bool _has_bit(int index) const { 2500 return (_has_bits_[index / 32] & (1u << (index % 32))) != 0; 2501 } 2502 inline void _set_bit(int index) { 2503 _has_bits_[index / 32] |= (1u << (index % 32)); 2504 } 2505 inline void _clear_bit(int index) { 2506 _has_bits_[index / 32] &= ~(1u << (index % 32)); 2507 } 2508 2509 void InitAsDefaultInstance(); 2510 static ReqScreenState* default_instance_; 2511}; 2512// =================================================================== 2513 2514 2515// =================================================================== 2516 2517// RilAppStatus 2518 2519// optional .ril_proto.RilAppType app_type = 1; 2520inline bool RilAppStatus::has_app_type() const { 2521 return _has_bit(0); 2522} 2523inline void RilAppStatus::clear_app_type() { 2524 app_type_ = 0; 2525 _clear_bit(0); 2526} 2527inline ril_proto::RilAppType RilAppStatus::app_type() const { 2528 return static_cast< ril_proto::RilAppType >(app_type_); 2529} 2530inline void RilAppStatus::set_app_type(ril_proto::RilAppType value) { 2531 GOOGLE_DCHECK(ril_proto::RilAppType_IsValid(value)); 2532 _set_bit(0); 2533 app_type_ = value; 2534} 2535 2536// optional .ril_proto.RilAppState app_state = 2; 2537inline bool RilAppStatus::has_app_state() const { 2538 return _has_bit(1); 2539} 2540inline void RilAppStatus::clear_app_state() { 2541 app_state_ = 0; 2542 _clear_bit(1); 2543} 2544inline ril_proto::RilAppState RilAppStatus::app_state() const { 2545 return static_cast< ril_proto::RilAppState >(app_state_); 2546} 2547inline void RilAppStatus::set_app_state(ril_proto::RilAppState value) { 2548 GOOGLE_DCHECK(ril_proto::RilAppState_IsValid(value)); 2549 _set_bit(1); 2550 app_state_ = value; 2551} 2552 2553// optional .ril_proto.RilPersoSubstate perso_substate = 3; 2554inline bool RilAppStatus::has_perso_substate() const { 2555 return _has_bit(2); 2556} 2557inline void RilAppStatus::clear_perso_substate() { 2558 perso_substate_ = 0; 2559 _clear_bit(2); 2560} 2561inline ril_proto::RilPersoSubstate RilAppStatus::perso_substate() const { 2562 return static_cast< ril_proto::RilPersoSubstate >(perso_substate_); 2563} 2564inline void RilAppStatus::set_perso_substate(ril_proto::RilPersoSubstate value) { 2565 GOOGLE_DCHECK(ril_proto::RilPersoSubstate_IsValid(value)); 2566 _set_bit(2); 2567 perso_substate_ = value; 2568} 2569 2570// optional string aid = 4; 2571inline bool RilAppStatus::has_aid() const { 2572 return _has_bit(3); 2573} 2574inline void RilAppStatus::clear_aid() { 2575 if (aid_ != &_default_aid_) { 2576 aid_->clear(); 2577 } 2578 _clear_bit(3); 2579} 2580inline const ::std::string& RilAppStatus::aid() const { 2581 return *aid_; 2582} 2583inline void RilAppStatus::set_aid(const ::std::string& value) { 2584 _set_bit(3); 2585 if (aid_ == &_default_aid_) { 2586 aid_ = new ::std::string; 2587 } 2588 aid_->assign(value); 2589} 2590inline void RilAppStatus::set_aid(const char* value) { 2591 _set_bit(3); 2592 if (aid_ == &_default_aid_) { 2593 aid_ = new ::std::string; 2594 } 2595 aid_->assign(value); 2596} 2597inline void RilAppStatus::set_aid(const char* value, size_t size) { 2598 _set_bit(3); 2599 if (aid_ == &_default_aid_) { 2600 aid_ = new ::std::string; 2601 } 2602 aid_->assign(reinterpret_cast<const char*>(value), size); 2603} 2604inline ::std::string* RilAppStatus::mutable_aid() { 2605 _set_bit(3); 2606 if (aid_ == &_default_aid_) { 2607 aid_ = new ::std::string; 2608 } 2609 return aid_; 2610} 2611 2612// optional string app_label = 5; 2613inline bool RilAppStatus::has_app_label() const { 2614 return _has_bit(4); 2615} 2616inline void RilAppStatus::clear_app_label() { 2617 if (app_label_ != &_default_app_label_) { 2618 app_label_->clear(); 2619 } 2620 _clear_bit(4); 2621} 2622inline const ::std::string& RilAppStatus::app_label() const { 2623 return *app_label_; 2624} 2625inline void RilAppStatus::set_app_label(const ::std::string& value) { 2626 _set_bit(4); 2627 if (app_label_ == &_default_app_label_) { 2628 app_label_ = new ::std::string; 2629 } 2630 app_label_->assign(value); 2631} 2632inline void RilAppStatus::set_app_label(const char* value) { 2633 _set_bit(4); 2634 if (app_label_ == &_default_app_label_) { 2635 app_label_ = new ::std::string; 2636 } 2637 app_label_->assign(value); 2638} 2639inline void RilAppStatus::set_app_label(const char* value, size_t size) { 2640 _set_bit(4); 2641 if (app_label_ == &_default_app_label_) { 2642 app_label_ = new ::std::string; 2643 } 2644 app_label_->assign(reinterpret_cast<const char*>(value), size); 2645} 2646inline ::std::string* RilAppStatus::mutable_app_label() { 2647 _set_bit(4); 2648 if (app_label_ == &_default_app_label_) { 2649 app_label_ = new ::std::string; 2650 } 2651 return app_label_; 2652} 2653 2654// optional int32 pin1_replaced = 6; 2655inline bool RilAppStatus::has_pin1_replaced() const { 2656 return _has_bit(5); 2657} 2658inline void RilAppStatus::clear_pin1_replaced() { 2659 pin1_replaced_ = 0; 2660 _clear_bit(5); 2661} 2662inline ::google::protobuf::int32 RilAppStatus::pin1_replaced() const { 2663 return pin1_replaced_; 2664} 2665inline void RilAppStatus::set_pin1_replaced(::google::protobuf::int32 value) { 2666 _set_bit(5); 2667 pin1_replaced_ = value; 2668} 2669 2670// optional .ril_proto.RilPinState pin1 = 7; 2671inline bool RilAppStatus::has_pin1() const { 2672 return _has_bit(6); 2673} 2674inline void RilAppStatus::clear_pin1() { 2675 pin1_ = 0; 2676 _clear_bit(6); 2677} 2678inline ril_proto::RilPinState RilAppStatus::pin1() const { 2679 return static_cast< ril_proto::RilPinState >(pin1_); 2680} 2681inline void RilAppStatus::set_pin1(ril_proto::RilPinState value) { 2682 GOOGLE_DCHECK(ril_proto::RilPinState_IsValid(value)); 2683 _set_bit(6); 2684 pin1_ = value; 2685} 2686 2687// optional .ril_proto.RilPinState pin2 = 8; 2688inline bool RilAppStatus::has_pin2() const { 2689 return _has_bit(7); 2690} 2691inline void RilAppStatus::clear_pin2() { 2692 pin2_ = 0; 2693 _clear_bit(7); 2694} 2695inline ril_proto::RilPinState RilAppStatus::pin2() const { 2696 return static_cast< ril_proto::RilPinState >(pin2_); 2697} 2698inline void RilAppStatus::set_pin2(ril_proto::RilPinState value) { 2699 GOOGLE_DCHECK(ril_proto::RilPinState_IsValid(value)); 2700 _set_bit(7); 2701 pin2_ = value; 2702} 2703 2704// ------------------------------------------------------------------- 2705 2706// RilCardStatus 2707 2708// optional .ril_proto.RilCardState card_state = 1; 2709inline bool RilCardStatus::has_card_state() const { 2710 return _has_bit(0); 2711} 2712inline void RilCardStatus::clear_card_state() { 2713 card_state_ = 0; 2714 _clear_bit(0); 2715} 2716inline ril_proto::RilCardState RilCardStatus::card_state() const { 2717 return static_cast< ril_proto::RilCardState >(card_state_); 2718} 2719inline void RilCardStatus::set_card_state(ril_proto::RilCardState value) { 2720 GOOGLE_DCHECK(ril_proto::RilCardState_IsValid(value)); 2721 _set_bit(0); 2722 card_state_ = value; 2723} 2724 2725// optional .ril_proto.RilPinState universal_pin_state = 2; 2726inline bool RilCardStatus::has_universal_pin_state() const { 2727 return _has_bit(1); 2728} 2729inline void RilCardStatus::clear_universal_pin_state() { 2730 universal_pin_state_ = 0; 2731 _clear_bit(1); 2732} 2733inline ril_proto::RilPinState RilCardStatus::universal_pin_state() const { 2734 return static_cast< ril_proto::RilPinState >(universal_pin_state_); 2735} 2736inline void RilCardStatus::set_universal_pin_state(ril_proto::RilPinState value) { 2737 GOOGLE_DCHECK(ril_proto::RilPinState_IsValid(value)); 2738 _set_bit(1); 2739 universal_pin_state_ = value; 2740} 2741 2742// optional int32 gsm_umts_subscription_app_index = 3; 2743inline bool RilCardStatus::has_gsm_umts_subscription_app_index() const { 2744 return _has_bit(2); 2745} 2746inline void RilCardStatus::clear_gsm_umts_subscription_app_index() { 2747 gsm_umts_subscription_app_index_ = 0; 2748 _clear_bit(2); 2749} 2750inline ::google::protobuf::int32 RilCardStatus::gsm_umts_subscription_app_index() const { 2751 return gsm_umts_subscription_app_index_; 2752} 2753inline void RilCardStatus::set_gsm_umts_subscription_app_index(::google::protobuf::int32 value) { 2754 _set_bit(2); 2755 gsm_umts_subscription_app_index_ = value; 2756} 2757 2758// optional int32 cdma_subscription_app_index = 4; 2759inline bool RilCardStatus::has_cdma_subscription_app_index() const { 2760 return _has_bit(3); 2761} 2762inline void RilCardStatus::clear_cdma_subscription_app_index() { 2763 cdma_subscription_app_index_ = 0; 2764 _clear_bit(3); 2765} 2766inline ::google::protobuf::int32 RilCardStatus::cdma_subscription_app_index() const { 2767 return cdma_subscription_app_index_; 2768} 2769inline void RilCardStatus::set_cdma_subscription_app_index(::google::protobuf::int32 value) { 2770 _set_bit(3); 2771 cdma_subscription_app_index_ = value; 2772} 2773 2774// optional int32 num_applications = 5; 2775inline bool RilCardStatus::has_num_applications() const { 2776 return _has_bit(4); 2777} 2778inline void RilCardStatus::clear_num_applications() { 2779 num_applications_ = 0; 2780 _clear_bit(4); 2781} 2782inline ::google::protobuf::int32 RilCardStatus::num_applications() const { 2783 return num_applications_; 2784} 2785inline void RilCardStatus::set_num_applications(::google::protobuf::int32 value) { 2786 _set_bit(4); 2787 num_applications_ = value; 2788} 2789 2790// repeated .ril_proto.RilAppStatus applications = 6; 2791inline int RilCardStatus::applications_size() const { 2792 return applications_.size(); 2793} 2794inline void RilCardStatus::clear_applications() { 2795 applications_.Clear(); 2796} 2797inline const ::ril_proto::RilAppStatus& RilCardStatus::applications(int index) const { 2798 return applications_.Get(index); 2799} 2800inline ::ril_proto::RilAppStatus* RilCardStatus::mutable_applications(int index) { 2801 return applications_.Mutable(index); 2802} 2803inline ::ril_proto::RilAppStatus* RilCardStatus::add_applications() { 2804 return applications_.Add(); 2805} 2806inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >& 2807RilCardStatus::applications() const { 2808 return applications_; 2809} 2810inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >* 2811RilCardStatus::mutable_applications() { 2812 return &applications_; 2813} 2814 2815// ------------------------------------------------------------------- 2816 2817// RilUusInfo 2818 2819// optional .ril_proto.RilUusType uus_type = 1; 2820inline bool RilUusInfo::has_uus_type() const { 2821 return _has_bit(0); 2822} 2823inline void RilUusInfo::clear_uus_type() { 2824 uus_type_ = 0; 2825 _clear_bit(0); 2826} 2827inline ril_proto::RilUusType RilUusInfo::uus_type() const { 2828 return static_cast< ril_proto::RilUusType >(uus_type_); 2829} 2830inline void RilUusInfo::set_uus_type(ril_proto::RilUusType value) { 2831 GOOGLE_DCHECK(ril_proto::RilUusType_IsValid(value)); 2832 _set_bit(0); 2833 uus_type_ = value; 2834} 2835 2836// optional .ril_proto.RilUusDcs uus_dcs = 2; 2837inline bool RilUusInfo::has_uus_dcs() const { 2838 return _has_bit(1); 2839} 2840inline void RilUusInfo::clear_uus_dcs() { 2841 uus_dcs_ = 0; 2842 _clear_bit(1); 2843} 2844inline ril_proto::RilUusDcs RilUusInfo::uus_dcs() const { 2845 return static_cast< ril_proto::RilUusDcs >(uus_dcs_); 2846} 2847inline void RilUusInfo::set_uus_dcs(ril_proto::RilUusDcs value) { 2848 GOOGLE_DCHECK(ril_proto::RilUusDcs_IsValid(value)); 2849 _set_bit(1); 2850 uus_dcs_ = value; 2851} 2852 2853// optional int32 uus_length = 3; 2854inline bool RilUusInfo::has_uus_length() const { 2855 return _has_bit(2); 2856} 2857inline void RilUusInfo::clear_uus_length() { 2858 uus_length_ = 0; 2859 _clear_bit(2); 2860} 2861inline ::google::protobuf::int32 RilUusInfo::uus_length() const { 2862 return uus_length_; 2863} 2864inline void RilUusInfo::set_uus_length(::google::protobuf::int32 value) { 2865 _set_bit(2); 2866 uus_length_ = value; 2867} 2868 2869// optional string uus_data = 4; 2870inline bool RilUusInfo::has_uus_data() const { 2871 return _has_bit(3); 2872} 2873inline void RilUusInfo::clear_uus_data() { 2874 if (uus_data_ != &_default_uus_data_) { 2875 uus_data_->clear(); 2876 } 2877 _clear_bit(3); 2878} 2879inline const ::std::string& RilUusInfo::uus_data() const { 2880 return *uus_data_; 2881} 2882inline void RilUusInfo::set_uus_data(const ::std::string& value) { 2883 _set_bit(3); 2884 if (uus_data_ == &_default_uus_data_) { 2885 uus_data_ = new ::std::string; 2886 } 2887 uus_data_->assign(value); 2888} 2889inline void RilUusInfo::set_uus_data(const char* value) { 2890 _set_bit(3); 2891 if (uus_data_ == &_default_uus_data_) { 2892 uus_data_ = new ::std::string; 2893 } 2894 uus_data_->assign(value); 2895} 2896inline void RilUusInfo::set_uus_data(const char* value, size_t size) { 2897 _set_bit(3); 2898 if (uus_data_ == &_default_uus_data_) { 2899 uus_data_ = new ::std::string; 2900 } 2901 uus_data_->assign(reinterpret_cast<const char*>(value), size); 2902} 2903inline ::std::string* RilUusInfo::mutable_uus_data() { 2904 _set_bit(3); 2905 if (uus_data_ == &_default_uus_data_) { 2906 uus_data_ = new ::std::string; 2907 } 2908 return uus_data_; 2909} 2910 2911// ------------------------------------------------------------------- 2912 2913// RilCall 2914 2915// optional .ril_proto.RilCallState state = 1; 2916inline bool RilCall::has_state() const { 2917 return _has_bit(0); 2918} 2919inline void RilCall::clear_state() { 2920 state_ = 0; 2921 _clear_bit(0); 2922} 2923inline ril_proto::RilCallState RilCall::state() const { 2924 return static_cast< ril_proto::RilCallState >(state_); 2925} 2926inline void RilCall::set_state(ril_proto::RilCallState value) { 2927 GOOGLE_DCHECK(ril_proto::RilCallState_IsValid(value)); 2928 _set_bit(0); 2929 state_ = value; 2930} 2931 2932// optional int32 index = 2; 2933inline bool RilCall::has_index() const { 2934 return _has_bit(1); 2935} 2936inline void RilCall::clear_index() { 2937 index_ = 0; 2938 _clear_bit(1); 2939} 2940inline ::google::protobuf::int32 RilCall::index() const { 2941 return index_; 2942} 2943inline void RilCall::set_index(::google::protobuf::int32 value) { 2944 _set_bit(1); 2945 index_ = value; 2946} 2947 2948// optional int32 toa = 3; 2949inline bool RilCall::has_toa() const { 2950 return _has_bit(2); 2951} 2952inline void RilCall::clear_toa() { 2953 toa_ = 0; 2954 _clear_bit(2); 2955} 2956inline ::google::protobuf::int32 RilCall::toa() const { 2957 return toa_; 2958} 2959inline void RilCall::set_toa(::google::protobuf::int32 value) { 2960 _set_bit(2); 2961 toa_ = value; 2962} 2963 2964// optional bool is_mpty = 4; 2965inline bool RilCall::has_is_mpty() const { 2966 return _has_bit(3); 2967} 2968inline void RilCall::clear_is_mpty() { 2969 is_mpty_ = false; 2970 _clear_bit(3); 2971} 2972inline bool RilCall::is_mpty() const { 2973 return is_mpty_; 2974} 2975inline void RilCall::set_is_mpty(bool value) { 2976 _set_bit(3); 2977 is_mpty_ = value; 2978} 2979 2980// optional bool is_mt = 5; 2981inline bool RilCall::has_is_mt() const { 2982 return _has_bit(4); 2983} 2984inline void RilCall::clear_is_mt() { 2985 is_mt_ = false; 2986 _clear_bit(4); 2987} 2988inline bool RilCall::is_mt() const { 2989 return is_mt_; 2990} 2991inline void RilCall::set_is_mt(bool value) { 2992 _set_bit(4); 2993 is_mt_ = value; 2994} 2995 2996// optional int32 als = 6; 2997inline bool RilCall::has_als() const { 2998 return _has_bit(5); 2999} 3000inline void RilCall::clear_als() { 3001 als_ = 0; 3002 _clear_bit(5); 3003} 3004inline ::google::protobuf::int32 RilCall::als() const { 3005 return als_; 3006} 3007inline void RilCall::set_als(::google::protobuf::int32 value) { 3008 _set_bit(5); 3009 als_ = value; 3010} 3011 3012// optional bool is_voice = 7; 3013inline bool RilCall::has_is_voice() const { 3014 return _has_bit(6); 3015} 3016inline void RilCall::clear_is_voice() { 3017 is_voice_ = false; 3018 _clear_bit(6); 3019} 3020inline bool RilCall::is_voice() const { 3021 return is_voice_; 3022} 3023inline void RilCall::set_is_voice(bool value) { 3024 _set_bit(6); 3025 is_voice_ = value; 3026} 3027 3028// optional bool is_voice_privacy = 8; 3029inline bool RilCall::has_is_voice_privacy() const { 3030 return _has_bit(7); 3031} 3032inline void RilCall::clear_is_voice_privacy() { 3033 is_voice_privacy_ = false; 3034 _clear_bit(7); 3035} 3036inline bool RilCall::is_voice_privacy() const { 3037 return is_voice_privacy_; 3038} 3039inline void RilCall::set_is_voice_privacy(bool value) { 3040 _set_bit(7); 3041 is_voice_privacy_ = value; 3042} 3043 3044// optional string number = 9; 3045inline bool RilCall::has_number() const { 3046 return _has_bit(8); 3047} 3048inline void RilCall::clear_number() { 3049 if (number_ != &_default_number_) { 3050 number_->clear(); 3051 } 3052 _clear_bit(8); 3053} 3054inline const ::std::string& RilCall::number() const { 3055 return *number_; 3056} 3057inline void RilCall::set_number(const ::std::string& value) { 3058 _set_bit(8); 3059 if (number_ == &_default_number_) { 3060 number_ = new ::std::string; 3061 } 3062 number_->assign(value); 3063} 3064inline void RilCall::set_number(const char* value) { 3065 _set_bit(8); 3066 if (number_ == &_default_number_) { 3067 number_ = new ::std::string; 3068 } 3069 number_->assign(value); 3070} 3071inline void RilCall::set_number(const char* value, size_t size) { 3072 _set_bit(8); 3073 if (number_ == &_default_number_) { 3074 number_ = new ::std::string; 3075 } 3076 number_->assign(reinterpret_cast<const char*>(value), size); 3077} 3078inline ::std::string* RilCall::mutable_number() { 3079 _set_bit(8); 3080 if (number_ == &_default_number_) { 3081 number_ = new ::std::string; 3082 } 3083 return number_; 3084} 3085 3086// optional int32 number_presentation = 10; 3087inline bool RilCall::has_number_presentation() const { 3088 return _has_bit(9); 3089} 3090inline void RilCall::clear_number_presentation() { 3091 number_presentation_ = 0; 3092 _clear_bit(9); 3093} 3094inline ::google::protobuf::int32 RilCall::number_presentation() const { 3095 return number_presentation_; 3096} 3097inline void RilCall::set_number_presentation(::google::protobuf::int32 value) { 3098 _set_bit(9); 3099 number_presentation_ = value; 3100} 3101 3102// optional string name = 11; 3103inline bool RilCall::has_name() const { 3104 return _has_bit(10); 3105} 3106inline void RilCall::clear_name() { 3107 if (name_ != &_default_name_) { 3108 name_->clear(); 3109 } 3110 _clear_bit(10); 3111} 3112inline const ::std::string& RilCall::name() const { 3113 return *name_; 3114} 3115inline void RilCall::set_name(const ::std::string& value) { 3116 _set_bit(10); 3117 if (name_ == &_default_name_) { 3118 name_ = new ::std::string; 3119 } 3120 name_->assign(value); 3121} 3122inline void RilCall::set_name(const char* value) { 3123 _set_bit(10); 3124 if (name_ == &_default_name_) { 3125 name_ = new ::std::string; 3126 } 3127 name_->assign(value); 3128} 3129inline void RilCall::set_name(const char* value, size_t size) { 3130 _set_bit(10); 3131 if (name_ == &_default_name_) { 3132 name_ = new ::std::string; 3133 } 3134 name_->assign(reinterpret_cast<const char*>(value), size); 3135} 3136inline ::std::string* RilCall::mutable_name() { 3137 _set_bit(10); 3138 if (name_ == &_default_name_) { 3139 name_ = new ::std::string; 3140 } 3141 return name_; 3142} 3143 3144// optional int32 name_presentation = 12; 3145inline bool RilCall::has_name_presentation() const { 3146 return _has_bit(11); 3147} 3148inline void RilCall::clear_name_presentation() { 3149 name_presentation_ = 0; 3150 _clear_bit(11); 3151} 3152inline ::google::protobuf::int32 RilCall::name_presentation() const { 3153 return name_presentation_; 3154} 3155inline void RilCall::set_name_presentation(::google::protobuf::int32 value) { 3156 _set_bit(11); 3157 name_presentation_ = value; 3158} 3159 3160// optional .ril_proto.RilUusInfo uus_info = 13; 3161inline bool RilCall::has_uus_info() const { 3162 return _has_bit(12); 3163} 3164inline void RilCall::clear_uus_info() { 3165 if (uus_info_ != NULL) uus_info_->::ril_proto::RilUusInfo::Clear(); 3166 _clear_bit(12); 3167} 3168inline const ::ril_proto::RilUusInfo& RilCall::uus_info() const { 3169 return uus_info_ != NULL ? *uus_info_ : *default_instance_->uus_info_; 3170} 3171inline ::ril_proto::RilUusInfo* RilCall::mutable_uus_info() { 3172 _set_bit(12); 3173 if (uus_info_ == NULL) uus_info_ = new ::ril_proto::RilUusInfo; 3174 return uus_info_; 3175} 3176 3177// ------------------------------------------------------------------- 3178 3179// RILGWSignalStrength 3180 3181// optional int32 signal_strength = 1; 3182inline bool RILGWSignalStrength::has_signal_strength() const { 3183 return _has_bit(0); 3184} 3185inline void RILGWSignalStrength::clear_signal_strength() { 3186 signal_strength_ = 0; 3187 _clear_bit(0); 3188} 3189inline ::google::protobuf::int32 RILGWSignalStrength::signal_strength() const { 3190 return signal_strength_; 3191} 3192inline void RILGWSignalStrength::set_signal_strength(::google::protobuf::int32 value) { 3193 _set_bit(0); 3194 signal_strength_ = value; 3195} 3196 3197// optional int32 bit_error_rate = 2; 3198inline bool RILGWSignalStrength::has_bit_error_rate() const { 3199 return _has_bit(1); 3200} 3201inline void RILGWSignalStrength::clear_bit_error_rate() { 3202 bit_error_rate_ = 0; 3203 _clear_bit(1); 3204} 3205inline ::google::protobuf::int32 RILGWSignalStrength::bit_error_rate() const { 3206 return bit_error_rate_; 3207} 3208inline void RILGWSignalStrength::set_bit_error_rate(::google::protobuf::int32 value) { 3209 _set_bit(1); 3210 bit_error_rate_ = value; 3211} 3212 3213// ------------------------------------------------------------------- 3214 3215// RILCDMASignalStrength 3216 3217// optional int32 dbm = 1; 3218inline bool RILCDMASignalStrength::has_dbm() const { 3219 return _has_bit(0); 3220} 3221inline void RILCDMASignalStrength::clear_dbm() { 3222 dbm_ = 0; 3223 _clear_bit(0); 3224} 3225inline ::google::protobuf::int32 RILCDMASignalStrength::dbm() const { 3226 return dbm_; 3227} 3228inline void RILCDMASignalStrength::set_dbm(::google::protobuf::int32 value) { 3229 _set_bit(0); 3230 dbm_ = value; 3231} 3232 3233// optional int32 ecio = 2; 3234inline bool RILCDMASignalStrength::has_ecio() const { 3235 return _has_bit(1); 3236} 3237inline void RILCDMASignalStrength::clear_ecio() { 3238 ecio_ = 0; 3239 _clear_bit(1); 3240} 3241inline ::google::protobuf::int32 RILCDMASignalStrength::ecio() const { 3242 return ecio_; 3243} 3244inline void RILCDMASignalStrength::set_ecio(::google::protobuf::int32 value) { 3245 _set_bit(1); 3246 ecio_ = value; 3247} 3248 3249// ------------------------------------------------------------------- 3250 3251// RILEVDOSignalStrength 3252 3253// optional int32 dbm = 1; 3254inline bool RILEVDOSignalStrength::has_dbm() const { 3255 return _has_bit(0); 3256} 3257inline void RILEVDOSignalStrength::clear_dbm() { 3258 dbm_ = 0; 3259 _clear_bit(0); 3260} 3261inline ::google::protobuf::int32 RILEVDOSignalStrength::dbm() const { 3262 return dbm_; 3263} 3264inline void RILEVDOSignalStrength::set_dbm(::google::protobuf::int32 value) { 3265 _set_bit(0); 3266 dbm_ = value; 3267} 3268 3269// optional int32 ecio = 2; 3270inline bool RILEVDOSignalStrength::has_ecio() const { 3271 return _has_bit(1); 3272} 3273inline void RILEVDOSignalStrength::clear_ecio() { 3274 ecio_ = 0; 3275 _clear_bit(1); 3276} 3277inline ::google::protobuf::int32 RILEVDOSignalStrength::ecio() const { 3278 return ecio_; 3279} 3280inline void RILEVDOSignalStrength::set_ecio(::google::protobuf::int32 value) { 3281 _set_bit(1); 3282 ecio_ = value; 3283} 3284 3285// optional int32 signal_noise_ratio = 3; 3286inline bool RILEVDOSignalStrength::has_signal_noise_ratio() const { 3287 return _has_bit(2); 3288} 3289inline void RILEVDOSignalStrength::clear_signal_noise_ratio() { 3290 signal_noise_ratio_ = 0; 3291 _clear_bit(2); 3292} 3293inline ::google::protobuf::int32 RILEVDOSignalStrength::signal_noise_ratio() const { 3294 return signal_noise_ratio_; 3295} 3296inline void RILEVDOSignalStrength::set_signal_noise_ratio(::google::protobuf::int32 value) { 3297 _set_bit(2); 3298 signal_noise_ratio_ = value; 3299} 3300 3301// ------------------------------------------------------------------- 3302 3303// RspStrings 3304 3305// repeated string strings = 1; 3306inline int RspStrings::strings_size() const { 3307 return strings_.size(); 3308} 3309inline void RspStrings::clear_strings() { 3310 strings_.Clear(); 3311} 3312inline const ::std::string& RspStrings::strings(int index) const { 3313 return strings_.Get(index); 3314} 3315inline ::std::string* RspStrings::mutable_strings(int index) { 3316 return strings_.Mutable(index); 3317} 3318inline void RspStrings::set_strings(int index, const ::std::string& value) { 3319 strings_.Mutable(index)->assign(value); 3320} 3321inline void RspStrings::set_strings(int index, const char* value) { 3322 strings_.Mutable(index)->assign(value); 3323} 3324inline void RspStrings::set_strings(int index, const char* value, size_t size) { 3325 strings_.Mutable(index)->assign( 3326 reinterpret_cast<const char*>(value), size); 3327} 3328inline ::std::string* RspStrings::add_strings() { 3329 return strings_.Add(); 3330} 3331inline void RspStrings::add_strings(const ::std::string& value) { 3332 strings_.Add()->assign(value); 3333} 3334inline void RspStrings::add_strings(const char* value) { 3335 strings_.Add()->assign(value); 3336} 3337inline void RspStrings::add_strings(const char* value, size_t size) { 3338 strings_.Add()->assign(reinterpret_cast<const char*>(value), size); 3339} 3340inline const ::google::protobuf::RepeatedPtrField< ::std::string>& 3341RspStrings::strings() const { 3342 return strings_; 3343} 3344inline ::google::protobuf::RepeatedPtrField< ::std::string>* 3345RspStrings::mutable_strings() { 3346 return &strings_; 3347} 3348 3349// ------------------------------------------------------------------- 3350 3351// RspIntegers 3352 3353// repeated int32 integers = 1; 3354inline int RspIntegers::integers_size() const { 3355 return integers_.size(); 3356} 3357inline void RspIntegers::clear_integers() { 3358 integers_.Clear(); 3359} 3360inline ::google::protobuf::int32 RspIntegers::integers(int index) const { 3361 return integers_.Get(index); 3362} 3363inline void RspIntegers::set_integers(int index, ::google::protobuf::int32 value) { 3364 integers_.Set(index, value); 3365} 3366inline void RspIntegers::add_integers(::google::protobuf::int32 value) { 3367 integers_.Add(value); 3368} 3369inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 3370RspIntegers::integers() const { 3371 return integers_; 3372} 3373inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 3374RspIntegers::mutable_integers() { 3375 return &integers_; 3376} 3377 3378// ------------------------------------------------------------------- 3379 3380// RspGetSimStatus 3381 3382// required .ril_proto.RilCardStatus card_status = 1; 3383inline bool RspGetSimStatus::has_card_status() const { 3384 return _has_bit(0); 3385} 3386inline void RspGetSimStatus::clear_card_status() { 3387 if (card_status_ != NULL) card_status_->::ril_proto::RilCardStatus::Clear(); 3388 _clear_bit(0); 3389} 3390inline const ::ril_proto::RilCardStatus& RspGetSimStatus::card_status() const { 3391 return card_status_ != NULL ? *card_status_ : *default_instance_->card_status_; 3392} 3393inline ::ril_proto::RilCardStatus* RspGetSimStatus::mutable_card_status() { 3394 _set_bit(0); 3395 if (card_status_ == NULL) card_status_ = new ::ril_proto::RilCardStatus; 3396 return card_status_; 3397} 3398 3399// ------------------------------------------------------------------- 3400 3401// ReqEnterSimPin 3402 3403// required string pin = 1; 3404inline bool ReqEnterSimPin::has_pin() const { 3405 return _has_bit(0); 3406} 3407inline void ReqEnterSimPin::clear_pin() { 3408 if (pin_ != &_default_pin_) { 3409 pin_->clear(); 3410 } 3411 _clear_bit(0); 3412} 3413inline const ::std::string& ReqEnterSimPin::pin() const { 3414 return *pin_; 3415} 3416inline void ReqEnterSimPin::set_pin(const ::std::string& value) { 3417 _set_bit(0); 3418 if (pin_ == &_default_pin_) { 3419 pin_ = new ::std::string; 3420 } 3421 pin_->assign(value); 3422} 3423inline void ReqEnterSimPin::set_pin(const char* value) { 3424 _set_bit(0); 3425 if (pin_ == &_default_pin_) { 3426 pin_ = new ::std::string; 3427 } 3428 pin_->assign(value); 3429} 3430inline void ReqEnterSimPin::set_pin(const char* value, size_t size) { 3431 _set_bit(0); 3432 if (pin_ == &_default_pin_) { 3433 pin_ = new ::std::string; 3434 } 3435 pin_->assign(reinterpret_cast<const char*>(value), size); 3436} 3437inline ::std::string* ReqEnterSimPin::mutable_pin() { 3438 _set_bit(0); 3439 if (pin_ == &_default_pin_) { 3440 pin_ = new ::std::string; 3441 } 3442 return pin_; 3443} 3444 3445// ------------------------------------------------------------------- 3446 3447// RspEnterSimPin 3448 3449// required int32 retries_remaining = 1; 3450inline bool RspEnterSimPin::has_retries_remaining() const { 3451 return _has_bit(0); 3452} 3453inline void RspEnterSimPin::clear_retries_remaining() { 3454 retries_remaining_ = 0; 3455 _clear_bit(0); 3456} 3457inline ::google::protobuf::int32 RspEnterSimPin::retries_remaining() const { 3458 return retries_remaining_; 3459} 3460inline void RspEnterSimPin::set_retries_remaining(::google::protobuf::int32 value) { 3461 _set_bit(0); 3462 retries_remaining_ = value; 3463} 3464 3465// ------------------------------------------------------------------- 3466 3467// RspGetCurrentCalls 3468 3469// repeated .ril_proto.RilCall calls = 1; 3470inline int RspGetCurrentCalls::calls_size() const { 3471 return calls_.size(); 3472} 3473inline void RspGetCurrentCalls::clear_calls() { 3474 calls_.Clear(); 3475} 3476inline const ::ril_proto::RilCall& RspGetCurrentCalls::calls(int index) const { 3477 return calls_.Get(index); 3478} 3479inline ::ril_proto::RilCall* RspGetCurrentCalls::mutable_calls(int index) { 3480 return calls_.Mutable(index); 3481} 3482inline ::ril_proto::RilCall* RspGetCurrentCalls::add_calls() { 3483 return calls_.Add(); 3484} 3485inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall >& 3486RspGetCurrentCalls::calls() const { 3487 return calls_; 3488} 3489inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall >* 3490RspGetCurrentCalls::mutable_calls() { 3491 return &calls_; 3492} 3493 3494// ------------------------------------------------------------------- 3495 3496// ReqDial 3497 3498// optional string address = 1; 3499inline bool ReqDial::has_address() const { 3500 return _has_bit(0); 3501} 3502inline void ReqDial::clear_address() { 3503 if (address_ != &_default_address_) { 3504 address_->clear(); 3505 } 3506 _clear_bit(0); 3507} 3508inline const ::std::string& ReqDial::address() const { 3509 return *address_; 3510} 3511inline void ReqDial::set_address(const ::std::string& value) { 3512 _set_bit(0); 3513 if (address_ == &_default_address_) { 3514 address_ = new ::std::string; 3515 } 3516 address_->assign(value); 3517} 3518inline void ReqDial::set_address(const char* value) { 3519 _set_bit(0); 3520 if (address_ == &_default_address_) { 3521 address_ = new ::std::string; 3522 } 3523 address_->assign(value); 3524} 3525inline void ReqDial::set_address(const char* value, size_t size) { 3526 _set_bit(0); 3527 if (address_ == &_default_address_) { 3528 address_ = new ::std::string; 3529 } 3530 address_->assign(reinterpret_cast<const char*>(value), size); 3531} 3532inline ::std::string* ReqDial::mutable_address() { 3533 _set_bit(0); 3534 if (address_ == &_default_address_) { 3535 address_ = new ::std::string; 3536 } 3537 return address_; 3538} 3539 3540// optional int32 clir = 2; 3541inline bool ReqDial::has_clir() const { 3542 return _has_bit(1); 3543} 3544inline void ReqDial::clear_clir() { 3545 clir_ = 0; 3546 _clear_bit(1); 3547} 3548inline ::google::protobuf::int32 ReqDial::clir() const { 3549 return clir_; 3550} 3551inline void ReqDial::set_clir(::google::protobuf::int32 value) { 3552 _set_bit(1); 3553 clir_ = value; 3554} 3555 3556// optional .ril_proto.RilUusInfo uus_info = 3; 3557inline bool ReqDial::has_uus_info() const { 3558 return _has_bit(2); 3559} 3560inline void ReqDial::clear_uus_info() { 3561 if (uus_info_ != NULL) uus_info_->::ril_proto::RilUusInfo::Clear(); 3562 _clear_bit(2); 3563} 3564inline const ::ril_proto::RilUusInfo& ReqDial::uus_info() const { 3565 return uus_info_ != NULL ? *uus_info_ : *default_instance_->uus_info_; 3566} 3567inline ::ril_proto::RilUusInfo* ReqDial::mutable_uus_info() { 3568 _set_bit(2); 3569 if (uus_info_ == NULL) uus_info_ = new ::ril_proto::RilUusInfo; 3570 return uus_info_; 3571} 3572 3573// ------------------------------------------------------------------- 3574 3575// ReqHangUp 3576 3577// required int32 connection_index = 1; 3578inline bool ReqHangUp::has_connection_index() const { 3579 return _has_bit(0); 3580} 3581inline void ReqHangUp::clear_connection_index() { 3582 connection_index_ = 0; 3583 _clear_bit(0); 3584} 3585inline ::google::protobuf::int32 ReqHangUp::connection_index() const { 3586 return connection_index_; 3587} 3588inline void ReqHangUp::set_connection_index(::google::protobuf::int32 value) { 3589 _set_bit(0); 3590 connection_index_ = value; 3591} 3592 3593// ------------------------------------------------------------------- 3594 3595// RspLastCallFailCause 3596 3597// required int32 last_call_fail_cause = 1; 3598inline bool RspLastCallFailCause::has_last_call_fail_cause() const { 3599 return _has_bit(0); 3600} 3601inline void RspLastCallFailCause::clear_last_call_fail_cause() { 3602 last_call_fail_cause_ = 0; 3603 _clear_bit(0); 3604} 3605inline ::google::protobuf::int32 RspLastCallFailCause::last_call_fail_cause() const { 3606 return last_call_fail_cause_; 3607} 3608inline void RspLastCallFailCause::set_last_call_fail_cause(::google::protobuf::int32 value) { 3609 _set_bit(0); 3610 last_call_fail_cause_ = value; 3611} 3612 3613// ------------------------------------------------------------------- 3614 3615// RspSignalStrength 3616 3617// optional .ril_proto.RILGWSignalStrength gw_signalstrength = 1; 3618inline bool RspSignalStrength::has_gw_signalstrength() const { 3619 return _has_bit(0); 3620} 3621inline void RspSignalStrength::clear_gw_signalstrength() { 3622 if (gw_signalstrength_ != NULL) gw_signalstrength_->::ril_proto::RILGWSignalStrength::Clear(); 3623 _clear_bit(0); 3624} 3625inline const ::ril_proto::RILGWSignalStrength& RspSignalStrength::gw_signalstrength() const { 3626 return gw_signalstrength_ != NULL ? *gw_signalstrength_ : *default_instance_->gw_signalstrength_; 3627} 3628inline ::ril_proto::RILGWSignalStrength* RspSignalStrength::mutable_gw_signalstrength() { 3629 _set_bit(0); 3630 if (gw_signalstrength_ == NULL) gw_signalstrength_ = new ::ril_proto::RILGWSignalStrength; 3631 return gw_signalstrength_; 3632} 3633 3634// optional .ril_proto.RILCDMASignalStrength cdma_signalstrength = 2; 3635inline bool RspSignalStrength::has_cdma_signalstrength() const { 3636 return _has_bit(1); 3637} 3638inline void RspSignalStrength::clear_cdma_signalstrength() { 3639 if (cdma_signalstrength_ != NULL) cdma_signalstrength_->::ril_proto::RILCDMASignalStrength::Clear(); 3640 _clear_bit(1); 3641} 3642inline const ::ril_proto::RILCDMASignalStrength& RspSignalStrength::cdma_signalstrength() const { 3643 return cdma_signalstrength_ != NULL ? *cdma_signalstrength_ : *default_instance_->cdma_signalstrength_; 3644} 3645inline ::ril_proto::RILCDMASignalStrength* RspSignalStrength::mutable_cdma_signalstrength() { 3646 _set_bit(1); 3647 if (cdma_signalstrength_ == NULL) cdma_signalstrength_ = new ::ril_proto::RILCDMASignalStrength; 3648 return cdma_signalstrength_; 3649} 3650 3651// optional .ril_proto.RILEVDOSignalStrength evdo_signalstrength = 3; 3652inline bool RspSignalStrength::has_evdo_signalstrength() const { 3653 return _has_bit(2); 3654} 3655inline void RspSignalStrength::clear_evdo_signalstrength() { 3656 if (evdo_signalstrength_ != NULL) evdo_signalstrength_->::ril_proto::RILEVDOSignalStrength::Clear(); 3657 _clear_bit(2); 3658} 3659inline const ::ril_proto::RILEVDOSignalStrength& RspSignalStrength::evdo_signalstrength() const { 3660 return evdo_signalstrength_ != NULL ? *evdo_signalstrength_ : *default_instance_->evdo_signalstrength_; 3661} 3662inline ::ril_proto::RILEVDOSignalStrength* RspSignalStrength::mutable_evdo_signalstrength() { 3663 _set_bit(2); 3664 if (evdo_signalstrength_ == NULL) evdo_signalstrength_ = new ::ril_proto::RILEVDOSignalStrength; 3665 return evdo_signalstrength_; 3666} 3667 3668// ------------------------------------------------------------------- 3669 3670// RspOperator 3671 3672// optional string long_alpha_ons = 1; 3673inline bool RspOperator::has_long_alpha_ons() const { 3674 return _has_bit(0); 3675} 3676inline void RspOperator::clear_long_alpha_ons() { 3677 if (long_alpha_ons_ != &_default_long_alpha_ons_) { 3678 long_alpha_ons_->clear(); 3679 } 3680 _clear_bit(0); 3681} 3682inline const ::std::string& RspOperator::long_alpha_ons() const { 3683 return *long_alpha_ons_; 3684} 3685inline void RspOperator::set_long_alpha_ons(const ::std::string& value) { 3686 _set_bit(0); 3687 if (long_alpha_ons_ == &_default_long_alpha_ons_) { 3688 long_alpha_ons_ = new ::std::string; 3689 } 3690 long_alpha_ons_->assign(value); 3691} 3692inline void RspOperator::set_long_alpha_ons(const char* value) { 3693 _set_bit(0); 3694 if (long_alpha_ons_ == &_default_long_alpha_ons_) { 3695 long_alpha_ons_ = new ::std::string; 3696 } 3697 long_alpha_ons_->assign(value); 3698} 3699inline void RspOperator::set_long_alpha_ons(const char* value, size_t size) { 3700 _set_bit(0); 3701 if (long_alpha_ons_ == &_default_long_alpha_ons_) { 3702 long_alpha_ons_ = new ::std::string; 3703 } 3704 long_alpha_ons_->assign(reinterpret_cast<const char*>(value), size); 3705} 3706inline ::std::string* RspOperator::mutable_long_alpha_ons() { 3707 _set_bit(0); 3708 if (long_alpha_ons_ == &_default_long_alpha_ons_) { 3709 long_alpha_ons_ = new ::std::string; 3710 } 3711 return long_alpha_ons_; 3712} 3713 3714// optional string short_alpha_ons = 2; 3715inline bool RspOperator::has_short_alpha_ons() const { 3716 return _has_bit(1); 3717} 3718inline void RspOperator::clear_short_alpha_ons() { 3719 if (short_alpha_ons_ != &_default_short_alpha_ons_) { 3720 short_alpha_ons_->clear(); 3721 } 3722 _clear_bit(1); 3723} 3724inline const ::std::string& RspOperator::short_alpha_ons() const { 3725 return *short_alpha_ons_; 3726} 3727inline void RspOperator::set_short_alpha_ons(const ::std::string& value) { 3728 _set_bit(1); 3729 if (short_alpha_ons_ == &_default_short_alpha_ons_) { 3730 short_alpha_ons_ = new ::std::string; 3731 } 3732 short_alpha_ons_->assign(value); 3733} 3734inline void RspOperator::set_short_alpha_ons(const char* value) { 3735 _set_bit(1); 3736 if (short_alpha_ons_ == &_default_short_alpha_ons_) { 3737 short_alpha_ons_ = new ::std::string; 3738 } 3739 short_alpha_ons_->assign(value); 3740} 3741inline void RspOperator::set_short_alpha_ons(const char* value, size_t size) { 3742 _set_bit(1); 3743 if (short_alpha_ons_ == &_default_short_alpha_ons_) { 3744 short_alpha_ons_ = new ::std::string; 3745 } 3746 short_alpha_ons_->assign(reinterpret_cast<const char*>(value), size); 3747} 3748inline ::std::string* RspOperator::mutable_short_alpha_ons() { 3749 _set_bit(1); 3750 if (short_alpha_ons_ == &_default_short_alpha_ons_) { 3751 short_alpha_ons_ = new ::std::string; 3752 } 3753 return short_alpha_ons_; 3754} 3755 3756// optional string mcc_mnc = 3; 3757inline bool RspOperator::has_mcc_mnc() const { 3758 return _has_bit(2); 3759} 3760inline void RspOperator::clear_mcc_mnc() { 3761 if (mcc_mnc_ != &_default_mcc_mnc_) { 3762 mcc_mnc_->clear(); 3763 } 3764 _clear_bit(2); 3765} 3766inline const ::std::string& RspOperator::mcc_mnc() const { 3767 return *mcc_mnc_; 3768} 3769inline void RspOperator::set_mcc_mnc(const ::std::string& value) { 3770 _set_bit(2); 3771 if (mcc_mnc_ == &_default_mcc_mnc_) { 3772 mcc_mnc_ = new ::std::string; 3773 } 3774 mcc_mnc_->assign(value); 3775} 3776inline void RspOperator::set_mcc_mnc(const char* value) { 3777 _set_bit(2); 3778 if (mcc_mnc_ == &_default_mcc_mnc_) { 3779 mcc_mnc_ = new ::std::string; 3780 } 3781 mcc_mnc_->assign(value); 3782} 3783inline void RspOperator::set_mcc_mnc(const char* value, size_t size) { 3784 _set_bit(2); 3785 if (mcc_mnc_ == &_default_mcc_mnc_) { 3786 mcc_mnc_ = new ::std::string; 3787 } 3788 mcc_mnc_->assign(reinterpret_cast<const char*>(value), size); 3789} 3790inline ::std::string* RspOperator::mutable_mcc_mnc() { 3791 _set_bit(2); 3792 if (mcc_mnc_ == &_default_mcc_mnc_) { 3793 mcc_mnc_ = new ::std::string; 3794 } 3795 return mcc_mnc_; 3796} 3797 3798// ------------------------------------------------------------------- 3799 3800// ReqSeparateConnection 3801 3802// required int32 index = 1; 3803inline bool ReqSeparateConnection::has_index() const { 3804 return _has_bit(0); 3805} 3806inline void ReqSeparateConnection::clear_index() { 3807 index_ = 0; 3808 _clear_bit(0); 3809} 3810inline ::google::protobuf::int32 ReqSeparateConnection::index() const { 3811 return index_; 3812} 3813inline void ReqSeparateConnection::set_index(::google::protobuf::int32 value) { 3814 _set_bit(0); 3815 index_ = value; 3816} 3817 3818// ------------------------------------------------------------------- 3819 3820// ReqSetMute 3821 3822// required bool state = 1; 3823inline bool ReqSetMute::has_state() const { 3824 return _has_bit(0); 3825} 3826inline void ReqSetMute::clear_state() { 3827 state_ = false; 3828 _clear_bit(0); 3829} 3830inline bool ReqSetMute::state() const { 3831 return state_; 3832} 3833inline void ReqSetMute::set_state(bool value) { 3834 _set_bit(0); 3835 state_ = value; 3836} 3837 3838// ------------------------------------------------------------------- 3839 3840// ReqScreenState 3841 3842// required bool state = 1; 3843inline bool ReqScreenState::has_state() const { 3844 return _has_bit(0); 3845} 3846inline void ReqScreenState::clear_state() { 3847 state_ = false; 3848 _clear_bit(0); 3849} 3850inline bool ReqScreenState::state() const { 3851 return state_; 3852} 3853inline void ReqScreenState::set_state(bool value) { 3854 _set_bit(0); 3855 state_ = value; 3856} 3857 3858 3859// @@protoc_insertion_point(namespace_scope) 3860 3861} // namespace ril_proto 3862 3863#ifndef SWIG 3864namespace google { 3865namespace protobuf { 3866 3867template <> 3868inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RadioState>() { 3869 return ril_proto::RadioState_descriptor(); 3870} 3871template <> 3872inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilCardState>() { 3873 return ril_proto::RilCardState_descriptor(); 3874} 3875template <> 3876inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilPersoSubstate>() { 3877 return ril_proto::RilPersoSubstate_descriptor(); 3878} 3879template <> 3880inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilAppState>() { 3881 return ril_proto::RilAppState_descriptor(); 3882} 3883template <> 3884inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilPinState>() { 3885 return ril_proto::RilPinState_descriptor(); 3886} 3887template <> 3888inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilAppType>() { 3889 return ril_proto::RilAppType_descriptor(); 3890} 3891template <> 3892inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilUusType>() { 3893 return ril_proto::RilUusType_descriptor(); 3894} 3895template <> 3896inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilUusDcs>() { 3897 return ril_proto::RilUusDcs_descriptor(); 3898} 3899template <> 3900inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilCallState>() { 3901 return ril_proto::RilCallState_descriptor(); 3902} 3903 3904} // namespace google 3905} // namespace protobuf 3906#endif // SWIG 3907 3908// @@protoc_insertion_point(global_scope) 3909 3910#endif // PROTOBUF_ril_2eproto__INCLUDED 3911