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 28 namespace ril_proto { 29 30 // Internal implementation detail -- do not call these. 31 void protobuf_AddDesc_ril_2eproto(); 32 void protobuf_AssignDesc_ril_2eproto(); 33 void protobuf_ShutdownFile_ril_2eproto(); 34 35 class RilAppStatus; 36 class RilCardStatus; 37 class RilUusInfo; 38 class RilCall; 39 class RILGWSignalStrength; 40 class RILCDMASignalStrength; 41 class RILEVDOSignalStrength; 42 class RspStrings; 43 class RspIntegers; 44 class RspGetSimStatus; 45 class ReqEnterSimPin; 46 class RspEnterSimPin; 47 class RspGetCurrentCalls; 48 class ReqDial; 49 class ReqHangUp; 50 class RspLastCallFailCause; 51 class RspSignalStrength; 52 class RspOperator; 53 class ReqSeparateConnection; 54 class ReqSetMute; 55 class ReqScreenState; 56 57 enum 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 }; 69 bool RadioState_IsValid(int value); 70 const RadioState RadioState_MIN = RADIOSTATE_OFF; 71 const RadioState RadioState_MAX = RADIOSTATE_NV_READY; 72 const int RadioState_ARRAYSIZE = RadioState_MAX + 1; 73 74 const ::google::protobuf::EnumDescriptor* RadioState_descriptor(); 75 inline const ::std::string& RadioState_Name(RadioState value) { 76 return ::google::protobuf::internal::NameOfEnum( 77 RadioState_descriptor(), value); 78 } 79 inline bool RadioState_Parse( 80 const ::std::string& name, RadioState* value) { 81 return ::google::protobuf::internal::ParseNamedEnum<RadioState>( 82 RadioState_descriptor(), name, value); 83 } 84 enum RilCardState { 85 CARDSTATE_ABSENT = 0, 86 CARDSTATE_PRESENT = 1, 87 CARDSTATE_ERROR = 2 88 }; 89 bool RilCardState_IsValid(int value); 90 const RilCardState RilCardState_MIN = CARDSTATE_ABSENT; 91 const RilCardState RilCardState_MAX = CARDSTATE_ERROR; 92 const int RilCardState_ARRAYSIZE = RilCardState_MAX + 1; 93 94 const ::google::protobuf::EnumDescriptor* RilCardState_descriptor(); 95 inline const ::std::string& RilCardState_Name(RilCardState value) { 96 return ::google::protobuf::internal::NameOfEnum( 97 RilCardState_descriptor(), value); 98 } 99 inline bool RilCardState_Parse( 100 const ::std::string& name, RilCardState* value) { 101 return ::google::protobuf::internal::ParseNamedEnum<RilCardState>( 102 RilCardState_descriptor(), name, value); 103 } 104 enum 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 }; 131 bool RilPersoSubstate_IsValid(int value); 132 const RilPersoSubstate RilPersoSubstate_MIN = PERSOSUBSTATE_UNKNOWN; 133 const RilPersoSubstate RilPersoSubstate_MAX = PERSOSUBSTATE_RUIM_RUIM_PUK; 134 const int RilPersoSubstate_ARRAYSIZE = RilPersoSubstate_MAX + 1; 135 136 const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor(); 137 inline const ::std::string& RilPersoSubstate_Name(RilPersoSubstate value) { 138 return ::google::protobuf::internal::NameOfEnum( 139 RilPersoSubstate_descriptor(), value); 140 } 141 inline bool RilPersoSubstate_Parse( 142 const ::std::string& name, RilPersoSubstate* value) { 143 return ::google::protobuf::internal::ParseNamedEnum<RilPersoSubstate>( 144 RilPersoSubstate_descriptor(), name, value); 145 } 146 enum 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 }; 154 bool RilAppState_IsValid(int value); 155 const RilAppState RilAppState_MIN = APPSTATE_UNKNOWN; 156 const RilAppState RilAppState_MAX = APPSTATE_READY; 157 const int RilAppState_ARRAYSIZE = RilAppState_MAX + 1; 158 159 const ::google::protobuf::EnumDescriptor* RilAppState_descriptor(); 160 inline const ::std::string& RilAppState_Name(RilAppState value) { 161 return ::google::protobuf::internal::NameOfEnum( 162 RilAppState_descriptor(), value); 163 } 164 inline bool RilAppState_Parse( 165 const ::std::string& name, RilAppState* value) { 166 return ::google::protobuf::internal::ParseNamedEnum<RilAppState>( 167 RilAppState_descriptor(), name, value); 168 } 169 enum 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 }; 177 bool RilPinState_IsValid(int value); 178 const RilPinState RilPinState_MIN = PINSTATE_UNKNOWN; 179 const RilPinState RilPinState_MAX = PINSTATE_ENABLED_PERM_BLOCKED; 180 const int RilPinState_ARRAYSIZE = RilPinState_MAX + 1; 181 182 const ::google::protobuf::EnumDescriptor* RilPinState_descriptor(); 183 inline const ::std::string& RilPinState_Name(RilPinState value) { 184 return ::google::protobuf::internal::NameOfEnum( 185 RilPinState_descriptor(), value); 186 } 187 inline bool RilPinState_Parse( 188 const ::std::string& name, RilPinState* value) { 189 return ::google::protobuf::internal::ParseNamedEnum<RilPinState>( 190 RilPinState_descriptor(), name, value); 191 } 192 enum RilAppType { 193 APPTYPE_UNKNOWN = 0, 194 APPTYPE_SIM = 1, 195 APPTYPE_USIM = 2, 196 APPTYPE_RUIM = 3, 197 APPTYPE_CSIM = 4 198 }; 199 bool RilAppType_IsValid(int value); 200 const RilAppType RilAppType_MIN = APPTYPE_UNKNOWN; 201 const RilAppType RilAppType_MAX = APPTYPE_CSIM; 202 const int RilAppType_ARRAYSIZE = RilAppType_MAX + 1; 203 204 const ::google::protobuf::EnumDescriptor* RilAppType_descriptor(); 205 inline const ::std::string& RilAppType_Name(RilAppType value) { 206 return ::google::protobuf::internal::NameOfEnum( 207 RilAppType_descriptor(), value); 208 } 209 inline bool RilAppType_Parse( 210 const ::std::string& name, RilAppType* value) { 211 return ::google::protobuf::internal::ParseNamedEnum<RilAppType>( 212 RilAppType_descriptor(), name, value); 213 } 214 enum 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 }; 223 bool RilUusType_IsValid(int value); 224 const RilUusType RilUusType_MIN = RILUUSTYPE1_IMPLICIT; 225 const RilUusType RilUusType_MAX = RILUUSTYPE3_NOT_REQUIRED; 226 const int RilUusType_ARRAYSIZE = RilUusType_MAX + 1; 227 228 const ::google::protobuf::EnumDescriptor* RilUusType_descriptor(); 229 inline const ::std::string& RilUusType_Name(RilUusType value) { 230 return ::google::protobuf::internal::NameOfEnum( 231 RilUusType_descriptor(), value); 232 } 233 inline bool RilUusType_Parse( 234 const ::std::string& name, RilUusType* value) { 235 return ::google::protobuf::internal::ParseNamedEnum<RilUusType>( 236 RilUusType_descriptor(), name, value); 237 } 238 enum RilUusDcs { 239 RILUUSDCS_USP = 0, 240 RILUUSDCS_OSIHLP = 1, 241 RILUUSDCS_X244 = 2, 242 RILUUSDCS_RMCF = 3, 243 RILUUSDCS_IA5c = 4 244 }; 245 bool RilUusDcs_IsValid(int value); 246 const RilUusDcs RilUusDcs_MIN = RILUUSDCS_USP; 247 const RilUusDcs RilUusDcs_MAX = RILUUSDCS_IA5c; 248 const int RilUusDcs_ARRAYSIZE = RilUusDcs_MAX + 1; 249 250 const ::google::protobuf::EnumDescriptor* RilUusDcs_descriptor(); 251 inline const ::std::string& RilUusDcs_Name(RilUusDcs value) { 252 return ::google::protobuf::internal::NameOfEnum( 253 RilUusDcs_descriptor(), value); 254 } 255 inline bool RilUusDcs_Parse( 256 const ::std::string& name, RilUusDcs* value) { 257 return ::google::protobuf::internal::ParseNamedEnum<RilUusDcs>( 258 RilUusDcs_descriptor(), name, value); 259 } 260 enum 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 }; 268 bool RilCallState_IsValid(int value); 269 const RilCallState RilCallState_MIN = CALLSTATE_ACTIVE; 270 const RilCallState RilCallState_MAX = CALLSTATE_WAITING; 271 const int RilCallState_ARRAYSIZE = RilCallState_MAX + 1; 272 273 const ::google::protobuf::EnumDescriptor* RilCallState_descriptor(); 274 inline const ::std::string& RilCallState_Name(RilCallState value) { 275 return ::google::protobuf::internal::NameOfEnum( 276 RilCallState_descriptor(), value); 277 } 278 inline 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 285 class 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 438 class 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 572 class 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 689 class 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 882 class 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 979 class 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 1076 class 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 1181 class 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 1279 class 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 1373 class 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 1462 class 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 1555 class 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 1644 class 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 1738 class 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 1847 class 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 1936 class 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 2025 class 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 2130 class 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 2247 class 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 2336 class 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 2425 class 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; 2520 inline bool RilAppStatus::has_app_type() const { 2521 return _has_bit(0); 2522 } 2523 inline void RilAppStatus::clear_app_type() { 2524 app_type_ = 0; 2525 _clear_bit(0); 2526 } 2527 inline ril_proto::RilAppType RilAppStatus::app_type() const { 2528 return static_cast< ril_proto::RilAppType >(app_type_); 2529 } 2530 inline 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; 2537 inline bool RilAppStatus::has_app_state() const { 2538 return _has_bit(1); 2539 } 2540 inline void RilAppStatus::clear_app_state() { 2541 app_state_ = 0; 2542 _clear_bit(1); 2543 } 2544 inline ril_proto::RilAppState RilAppStatus::app_state() const { 2545 return static_cast< ril_proto::RilAppState >(app_state_); 2546 } 2547 inline 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; 2554 inline bool RilAppStatus::has_perso_substate() const { 2555 return _has_bit(2); 2556 } 2557 inline void RilAppStatus::clear_perso_substate() { 2558 perso_substate_ = 0; 2559 _clear_bit(2); 2560 } 2561 inline ril_proto::RilPersoSubstate RilAppStatus::perso_substate() const { 2562 return static_cast< ril_proto::RilPersoSubstate >(perso_substate_); 2563 } 2564 inline 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; 2571 inline bool RilAppStatus::has_aid() const { 2572 return _has_bit(3); 2573 } 2574 inline void RilAppStatus::clear_aid() { 2575 if (aid_ != &_default_aid_) { 2576 aid_->clear(); 2577 } 2578 _clear_bit(3); 2579 } 2580 inline const ::std::string& RilAppStatus::aid() const { 2581 return *aid_; 2582 } 2583 inline 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 } 2590 inline 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 } 2597 inline 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 } 2604 inline ::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; 2613 inline bool RilAppStatus::has_app_label() const { 2614 return _has_bit(4); 2615 } 2616 inline void RilAppStatus::clear_app_label() { 2617 if (app_label_ != &_default_app_label_) { 2618 app_label_->clear(); 2619 } 2620 _clear_bit(4); 2621 } 2622 inline const ::std::string& RilAppStatus::app_label() const { 2623 return *app_label_; 2624 } 2625 inline 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 } 2632 inline 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 } 2639 inline 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 } 2646 inline ::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; 2655 inline bool RilAppStatus::has_pin1_replaced() const { 2656 return _has_bit(5); 2657 } 2658 inline void RilAppStatus::clear_pin1_replaced() { 2659 pin1_replaced_ = 0; 2660 _clear_bit(5); 2661 } 2662 inline ::google::protobuf::int32 RilAppStatus::pin1_replaced() const { 2663 return pin1_replaced_; 2664 } 2665 inline 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; 2671 inline bool RilAppStatus::has_pin1() const { 2672 return _has_bit(6); 2673 } 2674 inline void RilAppStatus::clear_pin1() { 2675 pin1_ = 0; 2676 _clear_bit(6); 2677 } 2678 inline ril_proto::RilPinState RilAppStatus::pin1() const { 2679 return static_cast< ril_proto::RilPinState >(pin1_); 2680 } 2681 inline 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; 2688 inline bool RilAppStatus::has_pin2() const { 2689 return _has_bit(7); 2690 } 2691 inline void RilAppStatus::clear_pin2() { 2692 pin2_ = 0; 2693 _clear_bit(7); 2694 } 2695 inline ril_proto::RilPinState RilAppStatus::pin2() const { 2696 return static_cast< ril_proto::RilPinState >(pin2_); 2697 } 2698 inline 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; 2709 inline bool RilCardStatus::has_card_state() const { 2710 return _has_bit(0); 2711 } 2712 inline void RilCardStatus::clear_card_state() { 2713 card_state_ = 0; 2714 _clear_bit(0); 2715 } 2716 inline ril_proto::RilCardState RilCardStatus::card_state() const { 2717 return static_cast< ril_proto::RilCardState >(card_state_); 2718 } 2719 inline 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; 2726 inline bool RilCardStatus::has_universal_pin_state() const { 2727 return _has_bit(1); 2728 } 2729 inline void RilCardStatus::clear_universal_pin_state() { 2730 universal_pin_state_ = 0; 2731 _clear_bit(1); 2732 } 2733 inline ril_proto::RilPinState RilCardStatus::universal_pin_state() const { 2734 return static_cast< ril_proto::RilPinState >(universal_pin_state_); 2735 } 2736 inline 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; 2743 inline bool RilCardStatus::has_gsm_umts_subscription_app_index() const { 2744 return _has_bit(2); 2745 } 2746 inline void RilCardStatus::clear_gsm_umts_subscription_app_index() { 2747 gsm_umts_subscription_app_index_ = 0; 2748 _clear_bit(2); 2749 } 2750 inline ::google::protobuf::int32 RilCardStatus::gsm_umts_subscription_app_index() const { 2751 return gsm_umts_subscription_app_index_; 2752 } 2753 inline 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; 2759 inline bool RilCardStatus::has_cdma_subscription_app_index() const { 2760 return _has_bit(3); 2761 } 2762 inline void RilCardStatus::clear_cdma_subscription_app_index() { 2763 cdma_subscription_app_index_ = 0; 2764 _clear_bit(3); 2765 } 2766 inline ::google::protobuf::int32 RilCardStatus::cdma_subscription_app_index() const { 2767 return cdma_subscription_app_index_; 2768 } 2769 inline 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; 2775 inline bool RilCardStatus::has_num_applications() const { 2776 return _has_bit(4); 2777 } 2778 inline void RilCardStatus::clear_num_applications() { 2779 num_applications_ = 0; 2780 _clear_bit(4); 2781 } 2782 inline ::google::protobuf::int32 RilCardStatus::num_applications() const { 2783 return num_applications_; 2784 } 2785 inline 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; 2791 inline int RilCardStatus::applications_size() const { 2792 return applications_.size(); 2793 } 2794 inline void RilCardStatus::clear_applications() { 2795 applications_.Clear(); 2796 } 2797 inline const ::ril_proto::RilAppStatus& RilCardStatus::applications(int index) const { 2798 return applications_.Get(index); 2799 } 2800 inline ::ril_proto::RilAppStatus* RilCardStatus::mutable_applications(int index) { 2801 return applications_.Mutable(index); 2802 } 2803 inline ::ril_proto::RilAppStatus* RilCardStatus::add_applications() { 2804 return applications_.Add(); 2805 } 2806 inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >& 2807 RilCardStatus::applications() const { 2808 return applications_; 2809 } 2810 inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >* 2811 RilCardStatus::mutable_applications() { 2812 return &applications_; 2813 } 2814 2815 // ------------------------------------------------------------------- 2816 2817 // RilUusInfo 2818 2819 // optional .ril_proto.RilUusType uus_type = 1; 2820 inline bool RilUusInfo::has_uus_type() const { 2821 return _has_bit(0); 2822 } 2823 inline void RilUusInfo::clear_uus_type() { 2824 uus_type_ = 0; 2825 _clear_bit(0); 2826 } 2827 inline ril_proto::RilUusType RilUusInfo::uus_type() const { 2828 return static_cast< ril_proto::RilUusType >(uus_type_); 2829 } 2830 inline 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; 2837 inline bool RilUusInfo::has_uus_dcs() const { 2838 return _has_bit(1); 2839 } 2840 inline void RilUusInfo::clear_uus_dcs() { 2841 uus_dcs_ = 0; 2842 _clear_bit(1); 2843 } 2844 inline ril_proto::RilUusDcs RilUusInfo::uus_dcs() const { 2845 return static_cast< ril_proto::RilUusDcs >(uus_dcs_); 2846 } 2847 inline 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; 2854 inline bool RilUusInfo::has_uus_length() const { 2855 return _has_bit(2); 2856 } 2857 inline void RilUusInfo::clear_uus_length() { 2858 uus_length_ = 0; 2859 _clear_bit(2); 2860 } 2861 inline ::google::protobuf::int32 RilUusInfo::uus_length() const { 2862 return uus_length_; 2863 } 2864 inline 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; 2870 inline bool RilUusInfo::has_uus_data() const { 2871 return _has_bit(3); 2872 } 2873 inline void RilUusInfo::clear_uus_data() { 2874 if (uus_data_ != &_default_uus_data_) { 2875 uus_data_->clear(); 2876 } 2877 _clear_bit(3); 2878 } 2879 inline const ::std::string& RilUusInfo::uus_data() const { 2880 return *uus_data_; 2881 } 2882 inline 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 } 2889 inline 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 } 2896 inline 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 } 2903 inline ::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; 2916 inline bool RilCall::has_state() const { 2917 return _has_bit(0); 2918 } 2919 inline void RilCall::clear_state() { 2920 state_ = 0; 2921 _clear_bit(0); 2922 } 2923 inline ril_proto::RilCallState RilCall::state() const { 2924 return static_cast< ril_proto::RilCallState >(state_); 2925 } 2926 inline 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; 2933 inline bool RilCall::has_index() const { 2934 return _has_bit(1); 2935 } 2936 inline void RilCall::clear_index() { 2937 index_ = 0; 2938 _clear_bit(1); 2939 } 2940 inline ::google::protobuf::int32 RilCall::index() const { 2941 return index_; 2942 } 2943 inline void RilCall::set_index(::google::protobuf::int32 value) { 2944 _set_bit(1); 2945 index_ = value; 2946 } 2947 2948 // optional int32 toa = 3; 2949 inline bool RilCall::has_toa() const { 2950 return _has_bit(2); 2951 } 2952 inline void RilCall::clear_toa() { 2953 toa_ = 0; 2954 _clear_bit(2); 2955 } 2956 inline ::google::protobuf::int32 RilCall::toa() const { 2957 return toa_; 2958 } 2959 inline void RilCall::set_toa(::google::protobuf::int32 value) { 2960 _set_bit(2); 2961 toa_ = value; 2962 } 2963 2964 // optional bool is_mpty = 4; 2965 inline bool RilCall::has_is_mpty() const { 2966 return _has_bit(3); 2967 } 2968 inline void RilCall::clear_is_mpty() { 2969 is_mpty_ = false; 2970 _clear_bit(3); 2971 } 2972 inline bool RilCall::is_mpty() const { 2973 return is_mpty_; 2974 } 2975 inline void RilCall::set_is_mpty(bool value) { 2976 _set_bit(3); 2977 is_mpty_ = value; 2978 } 2979 2980 // optional bool is_mt = 5; 2981 inline bool RilCall::has_is_mt() const { 2982 return _has_bit(4); 2983 } 2984 inline void RilCall::clear_is_mt() { 2985 is_mt_ = false; 2986 _clear_bit(4); 2987 } 2988 inline bool RilCall::is_mt() const { 2989 return is_mt_; 2990 } 2991 inline void RilCall::set_is_mt(bool value) { 2992 _set_bit(4); 2993 is_mt_ = value; 2994 } 2995 2996 // optional int32 als = 6; 2997 inline bool RilCall::has_als() const { 2998 return _has_bit(5); 2999 } 3000 inline void RilCall::clear_als() { 3001 als_ = 0; 3002 _clear_bit(5); 3003 } 3004 inline ::google::protobuf::int32 RilCall::als() const { 3005 return als_; 3006 } 3007 inline void RilCall::set_als(::google::protobuf::int32 value) { 3008 _set_bit(5); 3009 als_ = value; 3010 } 3011 3012 // optional bool is_voice = 7; 3013 inline bool RilCall::has_is_voice() const { 3014 return _has_bit(6); 3015 } 3016 inline void RilCall::clear_is_voice() { 3017 is_voice_ = false; 3018 _clear_bit(6); 3019 } 3020 inline bool RilCall::is_voice() const { 3021 return is_voice_; 3022 } 3023 inline void RilCall::set_is_voice(bool value) { 3024 _set_bit(6); 3025 is_voice_ = value; 3026 } 3027 3028 // optional bool is_voice_privacy = 8; 3029 inline bool RilCall::has_is_voice_privacy() const { 3030 return _has_bit(7); 3031 } 3032 inline void RilCall::clear_is_voice_privacy() { 3033 is_voice_privacy_ = false; 3034 _clear_bit(7); 3035 } 3036 inline bool RilCall::is_voice_privacy() const { 3037 return is_voice_privacy_; 3038 } 3039 inline void RilCall::set_is_voice_privacy(bool value) { 3040 _set_bit(7); 3041 is_voice_privacy_ = value; 3042 } 3043 3044 // optional string number = 9; 3045 inline bool RilCall::has_number() const { 3046 return _has_bit(8); 3047 } 3048 inline void RilCall::clear_number() { 3049 if (number_ != &_default_number_) { 3050 number_->clear(); 3051 } 3052 _clear_bit(8); 3053 } 3054 inline const ::std::string& RilCall::number() const { 3055 return *number_; 3056 } 3057 inline 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 } 3064 inline 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 } 3071 inline 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 } 3078 inline ::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; 3087 inline bool RilCall::has_number_presentation() const { 3088 return _has_bit(9); 3089 } 3090 inline void RilCall::clear_number_presentation() { 3091 number_presentation_ = 0; 3092 _clear_bit(9); 3093 } 3094 inline ::google::protobuf::int32 RilCall::number_presentation() const { 3095 return number_presentation_; 3096 } 3097 inline void RilCall::set_number_presentation(::google::protobuf::int32 value) { 3098 _set_bit(9); 3099 number_presentation_ = value; 3100 } 3101 3102 // optional string name = 11; 3103 inline bool RilCall::has_name() const { 3104 return _has_bit(10); 3105 } 3106 inline void RilCall::clear_name() { 3107 if (name_ != &_default_name_) { 3108 name_->clear(); 3109 } 3110 _clear_bit(10); 3111 } 3112 inline const ::std::string& RilCall::name() const { 3113 return *name_; 3114 } 3115 inline 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 } 3122 inline 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 } 3129 inline 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 } 3136 inline ::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; 3145 inline bool RilCall::has_name_presentation() const { 3146 return _has_bit(11); 3147 } 3148 inline void RilCall::clear_name_presentation() { 3149 name_presentation_ = 0; 3150 _clear_bit(11); 3151 } 3152 inline ::google::protobuf::int32 RilCall::name_presentation() const { 3153 return name_presentation_; 3154 } 3155 inline 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; 3161 inline bool RilCall::has_uus_info() const { 3162 return _has_bit(12); 3163 } 3164 inline void RilCall::clear_uus_info() { 3165 if (uus_info_ != NULL) uus_info_->::ril_proto::RilUusInfo::Clear(); 3166 _clear_bit(12); 3167 } 3168 inline const ::ril_proto::RilUusInfo& RilCall::uus_info() const { 3169 return uus_info_ != NULL ? *uus_info_ : *default_instance_->uus_info_; 3170 } 3171 inline ::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; 3182 inline bool RILGWSignalStrength::has_signal_strength() const { 3183 return _has_bit(0); 3184 } 3185 inline void RILGWSignalStrength::clear_signal_strength() { 3186 signal_strength_ = 0; 3187 _clear_bit(0); 3188 } 3189 inline ::google::protobuf::int32 RILGWSignalStrength::signal_strength() const { 3190 return signal_strength_; 3191 } 3192 inline 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; 3198 inline bool RILGWSignalStrength::has_bit_error_rate() const { 3199 return _has_bit(1); 3200 } 3201 inline void RILGWSignalStrength::clear_bit_error_rate() { 3202 bit_error_rate_ = 0; 3203 _clear_bit(1); 3204 } 3205 inline ::google::protobuf::int32 RILGWSignalStrength::bit_error_rate() const { 3206 return bit_error_rate_; 3207 } 3208 inline 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; 3218 inline bool RILCDMASignalStrength::has_dbm() const { 3219 return _has_bit(0); 3220 } 3221 inline void RILCDMASignalStrength::clear_dbm() { 3222 dbm_ = 0; 3223 _clear_bit(0); 3224 } 3225 inline ::google::protobuf::int32 RILCDMASignalStrength::dbm() const { 3226 return dbm_; 3227 } 3228 inline void RILCDMASignalStrength::set_dbm(::google::protobuf::int32 value) { 3229 _set_bit(0); 3230 dbm_ = value; 3231 } 3232 3233 // optional int32 ecio = 2; 3234 inline bool RILCDMASignalStrength::has_ecio() const { 3235 return _has_bit(1); 3236 } 3237 inline void RILCDMASignalStrength::clear_ecio() { 3238 ecio_ = 0; 3239 _clear_bit(1); 3240 } 3241 inline ::google::protobuf::int32 RILCDMASignalStrength::ecio() const { 3242 return ecio_; 3243 } 3244 inline 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; 3254 inline bool RILEVDOSignalStrength::has_dbm() const { 3255 return _has_bit(0); 3256 } 3257 inline void RILEVDOSignalStrength::clear_dbm() { 3258 dbm_ = 0; 3259 _clear_bit(0); 3260 } 3261 inline ::google::protobuf::int32 RILEVDOSignalStrength::dbm() const { 3262 return dbm_; 3263 } 3264 inline void RILEVDOSignalStrength::set_dbm(::google::protobuf::int32 value) { 3265 _set_bit(0); 3266 dbm_ = value; 3267 } 3268 3269 // optional int32 ecio = 2; 3270 inline bool RILEVDOSignalStrength::has_ecio() const { 3271 return _has_bit(1); 3272 } 3273 inline void RILEVDOSignalStrength::clear_ecio() { 3274 ecio_ = 0; 3275 _clear_bit(1); 3276 } 3277 inline ::google::protobuf::int32 RILEVDOSignalStrength::ecio() const { 3278 return ecio_; 3279 } 3280 inline void RILEVDOSignalStrength::set_ecio(::google::protobuf::int32 value) { 3281 _set_bit(1); 3282 ecio_ = value; 3283 } 3284 3285 // optional int32 signal_noise_ratio = 3; 3286 inline bool RILEVDOSignalStrength::has_signal_noise_ratio() const { 3287 return _has_bit(2); 3288 } 3289 inline void RILEVDOSignalStrength::clear_signal_noise_ratio() { 3290 signal_noise_ratio_ = 0; 3291 _clear_bit(2); 3292 } 3293 inline ::google::protobuf::int32 RILEVDOSignalStrength::signal_noise_ratio() const { 3294 return signal_noise_ratio_; 3295 } 3296 inline 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; 3306 inline int RspStrings::strings_size() const { 3307 return strings_.size(); 3308 } 3309 inline void RspStrings::clear_strings() { 3310 strings_.Clear(); 3311 } 3312 inline const ::std::string& RspStrings::strings(int index) const { 3313 return strings_.Get(index); 3314 } 3315 inline ::std::string* RspStrings::mutable_strings(int index) { 3316 return strings_.Mutable(index); 3317 } 3318 inline void RspStrings::set_strings(int index, const ::std::string& value) { 3319 strings_.Mutable(index)->assign(value); 3320 } 3321 inline void RspStrings::set_strings(int index, const char* value) { 3322 strings_.Mutable(index)->assign(value); 3323 } 3324 inline 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 } 3328 inline ::std::string* RspStrings::add_strings() { 3329 return strings_.Add(); 3330 } 3331 inline void RspStrings::add_strings(const ::std::string& value) { 3332 strings_.Add()->assign(value); 3333 } 3334 inline void RspStrings::add_strings(const char* value) { 3335 strings_.Add()->assign(value); 3336 } 3337 inline void RspStrings::add_strings(const char* value, size_t size) { 3338 strings_.Add()->assign(reinterpret_cast<const char*>(value), size); 3339 } 3340 inline const ::google::protobuf::RepeatedPtrField< ::std::string>& 3341 RspStrings::strings() const { 3342 return strings_; 3343 } 3344 inline ::google::protobuf::RepeatedPtrField< ::std::string>* 3345 RspStrings::mutable_strings() { 3346 return &strings_; 3347 } 3348 3349 // ------------------------------------------------------------------- 3350 3351 // RspIntegers 3352 3353 // repeated int32 integers = 1; 3354 inline int RspIntegers::integers_size() const { 3355 return integers_.size(); 3356 } 3357 inline void RspIntegers::clear_integers() { 3358 integers_.Clear(); 3359 } 3360 inline ::google::protobuf::int32 RspIntegers::integers(int index) const { 3361 return integers_.Get(index); 3362 } 3363 inline void RspIntegers::set_integers(int index, ::google::protobuf::int32 value) { 3364 integers_.Set(index, value); 3365 } 3366 inline void RspIntegers::add_integers(::google::protobuf::int32 value) { 3367 integers_.Add(value); 3368 } 3369 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >& 3370 RspIntegers::integers() const { 3371 return integers_; 3372 } 3373 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >* 3374 RspIntegers::mutable_integers() { 3375 return &integers_; 3376 } 3377 3378 // ------------------------------------------------------------------- 3379 3380 // RspGetSimStatus 3381 3382 // required .ril_proto.RilCardStatus card_status = 1; 3383 inline bool RspGetSimStatus::has_card_status() const { 3384 return _has_bit(0); 3385 } 3386 inline void RspGetSimStatus::clear_card_status() { 3387 if (card_status_ != NULL) card_status_->::ril_proto::RilCardStatus::Clear(); 3388 _clear_bit(0); 3389 } 3390 inline const ::ril_proto::RilCardStatus& RspGetSimStatus::card_status() const { 3391 return card_status_ != NULL ? *card_status_ : *default_instance_->card_status_; 3392 } 3393 inline ::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; 3404 inline bool ReqEnterSimPin::has_pin() const { 3405 return _has_bit(0); 3406 } 3407 inline void ReqEnterSimPin::clear_pin() { 3408 if (pin_ != &_default_pin_) { 3409 pin_->clear(); 3410 } 3411 _clear_bit(0); 3412 } 3413 inline const ::std::string& ReqEnterSimPin::pin() const { 3414 return *pin_; 3415 } 3416 inline 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 } 3423 inline 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 } 3430 inline 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 } 3437 inline ::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; 3450 inline bool RspEnterSimPin::has_retries_remaining() const { 3451 return _has_bit(0); 3452 } 3453 inline void RspEnterSimPin::clear_retries_remaining() { 3454 retries_remaining_ = 0; 3455 _clear_bit(0); 3456 } 3457 inline ::google::protobuf::int32 RspEnterSimPin::retries_remaining() const { 3458 return retries_remaining_; 3459 } 3460 inline 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; 3470 inline int RspGetCurrentCalls::calls_size() const { 3471 return calls_.size(); 3472 } 3473 inline void RspGetCurrentCalls::clear_calls() { 3474 calls_.Clear(); 3475 } 3476 inline const ::ril_proto::RilCall& RspGetCurrentCalls::calls(int index) const { 3477 return calls_.Get(index); 3478 } 3479 inline ::ril_proto::RilCall* RspGetCurrentCalls::mutable_calls(int index) { 3480 return calls_.Mutable(index); 3481 } 3482 inline ::ril_proto::RilCall* RspGetCurrentCalls::add_calls() { 3483 return calls_.Add(); 3484 } 3485 inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall >& 3486 RspGetCurrentCalls::calls() const { 3487 return calls_; 3488 } 3489 inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilCall >* 3490 RspGetCurrentCalls::mutable_calls() { 3491 return &calls_; 3492 } 3493 3494 // ------------------------------------------------------------------- 3495 3496 // ReqDial 3497 3498 // optional string address = 1; 3499 inline bool ReqDial::has_address() const { 3500 return _has_bit(0); 3501 } 3502 inline void ReqDial::clear_address() { 3503 if (address_ != &_default_address_) { 3504 address_->clear(); 3505 } 3506 _clear_bit(0); 3507 } 3508 inline const ::std::string& ReqDial::address() const { 3509 return *address_; 3510 } 3511 inline 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 } 3518 inline 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 } 3525 inline 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 } 3532 inline ::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; 3541 inline bool ReqDial::has_clir() const { 3542 return _has_bit(1); 3543 } 3544 inline void ReqDial::clear_clir() { 3545 clir_ = 0; 3546 _clear_bit(1); 3547 } 3548 inline ::google::protobuf::int32 ReqDial::clir() const { 3549 return clir_; 3550 } 3551 inline 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; 3557 inline bool ReqDial::has_uus_info() const { 3558 return _has_bit(2); 3559 } 3560 inline void ReqDial::clear_uus_info() { 3561 if (uus_info_ != NULL) uus_info_->::ril_proto::RilUusInfo::Clear(); 3562 _clear_bit(2); 3563 } 3564 inline const ::ril_proto::RilUusInfo& ReqDial::uus_info() const { 3565 return uus_info_ != NULL ? *uus_info_ : *default_instance_->uus_info_; 3566 } 3567 inline ::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; 3578 inline bool ReqHangUp::has_connection_index() const { 3579 return _has_bit(0); 3580 } 3581 inline void ReqHangUp::clear_connection_index() { 3582 connection_index_ = 0; 3583 _clear_bit(0); 3584 } 3585 inline ::google::protobuf::int32 ReqHangUp::connection_index() const { 3586 return connection_index_; 3587 } 3588 inline 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; 3598 inline bool RspLastCallFailCause::has_last_call_fail_cause() const { 3599 return _has_bit(0); 3600 } 3601 inline void RspLastCallFailCause::clear_last_call_fail_cause() { 3602 last_call_fail_cause_ = 0; 3603 _clear_bit(0); 3604 } 3605 inline ::google::protobuf::int32 RspLastCallFailCause::last_call_fail_cause() const { 3606 return last_call_fail_cause_; 3607 } 3608 inline 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; 3618 inline bool RspSignalStrength::has_gw_signalstrength() const { 3619 return _has_bit(0); 3620 } 3621 inline void RspSignalStrength::clear_gw_signalstrength() { 3622 if (gw_signalstrength_ != NULL) gw_signalstrength_->::ril_proto::RILGWSignalStrength::Clear(); 3623 _clear_bit(0); 3624 } 3625 inline const ::ril_proto::RILGWSignalStrength& RspSignalStrength::gw_signalstrength() const { 3626 return gw_signalstrength_ != NULL ? *gw_signalstrength_ : *default_instance_->gw_signalstrength_; 3627 } 3628 inline ::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; 3635 inline bool RspSignalStrength::has_cdma_signalstrength() const { 3636 return _has_bit(1); 3637 } 3638 inline void RspSignalStrength::clear_cdma_signalstrength() { 3639 if (cdma_signalstrength_ != NULL) cdma_signalstrength_->::ril_proto::RILCDMASignalStrength::Clear(); 3640 _clear_bit(1); 3641 } 3642 inline const ::ril_proto::RILCDMASignalStrength& RspSignalStrength::cdma_signalstrength() const { 3643 return cdma_signalstrength_ != NULL ? *cdma_signalstrength_ : *default_instance_->cdma_signalstrength_; 3644 } 3645 inline ::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; 3652 inline bool RspSignalStrength::has_evdo_signalstrength() const { 3653 return _has_bit(2); 3654 } 3655 inline void RspSignalStrength::clear_evdo_signalstrength() { 3656 if (evdo_signalstrength_ != NULL) evdo_signalstrength_->::ril_proto::RILEVDOSignalStrength::Clear(); 3657 _clear_bit(2); 3658 } 3659 inline const ::ril_proto::RILEVDOSignalStrength& RspSignalStrength::evdo_signalstrength() const { 3660 return evdo_signalstrength_ != NULL ? *evdo_signalstrength_ : *default_instance_->evdo_signalstrength_; 3661 } 3662 inline ::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; 3673 inline bool RspOperator::has_long_alpha_ons() const { 3674 return _has_bit(0); 3675 } 3676 inline 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 } 3682 inline const ::std::string& RspOperator::long_alpha_ons() const { 3683 return *long_alpha_ons_; 3684 } 3685 inline 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 } 3692 inline 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 } 3699 inline 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 } 3706 inline ::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; 3715 inline bool RspOperator::has_short_alpha_ons() const { 3716 return _has_bit(1); 3717 } 3718 inline 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 } 3724 inline const ::std::string& RspOperator::short_alpha_ons() const { 3725 return *short_alpha_ons_; 3726 } 3727 inline 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 } 3734 inline 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 } 3741 inline 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 } 3748 inline ::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; 3757 inline bool RspOperator::has_mcc_mnc() const { 3758 return _has_bit(2); 3759 } 3760 inline void RspOperator::clear_mcc_mnc() { 3761 if (mcc_mnc_ != &_default_mcc_mnc_) { 3762 mcc_mnc_->clear(); 3763 } 3764 _clear_bit(2); 3765 } 3766 inline const ::std::string& RspOperator::mcc_mnc() const { 3767 return *mcc_mnc_; 3768 } 3769 inline 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 } 3776 inline 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 } 3783 inline 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 } 3790 inline ::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; 3803 inline bool ReqSeparateConnection::has_index() const { 3804 return _has_bit(0); 3805 } 3806 inline void ReqSeparateConnection::clear_index() { 3807 index_ = 0; 3808 _clear_bit(0); 3809 } 3810 inline ::google::protobuf::int32 ReqSeparateConnection::index() const { 3811 return index_; 3812 } 3813 inline 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; 3823 inline bool ReqSetMute::has_state() const { 3824 return _has_bit(0); 3825 } 3826 inline void ReqSetMute::clear_state() { 3827 state_ = false; 3828 _clear_bit(0); 3829 } 3830 inline bool ReqSetMute::state() const { 3831 return state_; 3832 } 3833 inline 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; 3843 inline bool ReqScreenState::has_state() const { 3844 return _has_bit(0); 3845 } 3846 inline void ReqScreenState::clear_state() { 3847 state_ = false; 3848 _clear_bit(0); 3849 } 3850 inline bool ReqScreenState::state() const { 3851 return state_; 3852 } 3853 inline 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 3864 namespace google { 3865 namespace protobuf { 3866 3867 template <> 3868 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RadioState>() { 3869 return ril_proto::RadioState_descriptor(); 3870 } 3871 template <> 3872 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilCardState>() { 3873 return ril_proto::RilCardState_descriptor(); 3874 } 3875 template <> 3876 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilPersoSubstate>() { 3877 return ril_proto::RilPersoSubstate_descriptor(); 3878 } 3879 template <> 3880 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilAppState>() { 3881 return ril_proto::RilAppState_descriptor(); 3882 } 3883 template <> 3884 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilPinState>() { 3885 return ril_proto::RilPinState_descriptor(); 3886 } 3887 template <> 3888 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilAppType>() { 3889 return ril_proto::RilAppType_descriptor(); 3890 } 3891 template <> 3892 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilUusType>() { 3893 return ril_proto::RilUusType_descriptor(); 3894 } 3895 template <> 3896 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilUusDcs>() { 3897 return ril_proto::RilUusDcs_descriptor(); 3898 } 3899 template <> 3900 inline 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
