mock-ril/src/cpp/ril.pb.h

   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 RspStrings;
  38 class RspIntegers;
  39 class ReqGetSimStatus;
  40 class RspGetSimStatus;
  41 class ReqEnterSimPin;
  42 class RspEnterSimPin;
  43 class ReqHangUp;
  44 class ReqScreenState;
  45 class RspOperator;
  46
  47 enum RilCommand {
  48   CMD_GET_SIM_STATUS = 1,
  49   CMD_ENTER_SIM_PIN = 2,
  50   CMD_HANGUP = 12,
  51   CMD_SCREEN_STATE = 61
  52 };
  53 bool RilCommand_IsValid(int value);
  54 const RilCommand RilCommand_MIN = CMD_GET_SIM_STATUS;
  55 const RilCommand RilCommand_MAX = CMD_SCREEN_STATE;
  56 const int RilCommand_ARRAYSIZE = RilCommand_MAX + 1;
  57
  58 const ::google::protobuf::EnumDescriptor* RilCommand_descriptor();
  59 inline const ::std::string& RilCommand_Name(RilCommand value) {
  60   return ::google::protobuf::internal::NameOfEnum(
  61     RilCommand_descriptor(), value);
  62 }
  63 inline bool RilCommand_Parse(
  64     const ::std::string& name, RilCommand* value) {
  65   return ::google::protobuf::internal::ParseNamedEnum<RilCommand>(
  66     RilCommand_descriptor(), name, value);
  67 }
  68 enum RadioState {
  69   RADIO_STATE_OFF = 0,
  70   RADIO_STATE_UNAVAILABLE = 1,
  71   RADIO_STATE_SIM_NOT_READY = 2,
  72   RADIO_STATE_SIM_LOCKED_OR_ABSENT = 3,
  73   RADIO_STATE_SIM_READY = 4,
  74   RADIO_STATE_RUIM_NOT_READY = 5,
  75   RADIO_STATE_RUIM_READY = 6,
  76   RADIO_STATE_RUIM_LOCKED_OR_ABSENT = 7,
  77   RADIO_STATE_NV_NOT_READY = 8,
  78   RADIO_STATE_NV_READY = 9
  79 };
  80 bool RadioState_IsValid(int value);
  81 const RadioState RadioState_MIN = RADIO_STATE_OFF;
  82 const RadioState RadioState_MAX = RADIO_STATE_NV_READY;
  83 const int RadioState_ARRAYSIZE = RadioState_MAX + 1;
  84
  85 const ::google::protobuf::EnumDescriptor* RadioState_descriptor();
  86 inline const ::std::string& RadioState_Name(RadioState value) {
  87   return ::google::protobuf::internal::NameOfEnum(
  88     RadioState_descriptor(), value);
  89 }
  90 inline bool RadioState_Parse(
  91     const ::std::string& name, RadioState* value) {
  92   return ::google::protobuf::internal::ParseNamedEnum<RadioState>(
  93     RadioState_descriptor(), name, value);
  94 }
  95 enum RilCardState {
  96   CARDSTATE_ABSENT = 0,
  97   CARDSTATE_PRESENT = 1,
  98   CARDSTATE_ERROR = 2
  99 };
 100 bool RilCardState_IsValid(int value);
 101 const RilCardState RilCardState_MIN = CARDSTATE_ABSENT;
 102 const RilCardState RilCardState_MAX = CARDSTATE_ERROR;
 103 const int RilCardState_ARRAYSIZE = RilCardState_MAX + 1;
 104
 105 const ::google::protobuf::EnumDescriptor* RilCardState_descriptor();
 106 inline const ::std::string& RilCardState_Name(RilCardState value) {
 107   return ::google::protobuf::internal::NameOfEnum(
 108     RilCardState_descriptor(), value);
 109 }
 110 inline bool RilCardState_Parse(
 111     const ::std::string& name, RilCardState* value) {
 112   return ::google::protobuf::internal::ParseNamedEnum<RilCardState>(
 113     RilCardState_descriptor(), name, value);
 114 }
 115 enum RilPersoSubstate {
 116   PERSOSUBSTATE_UNKNOWN = 0,
 117   PERSOSUBSTATE_IN_PROGRESS = 1,
 118   PERSOSUBSTATE_READY = 2,
 119   PERSOSUBSTATE_SIM_NETWORK = 3,
 120   PERSOSUBSTATE_SIM_NETWORK_SUBSET = 4,
 121   PERSOSUBSTATE_SIM_CORPORATE = 5,
 122   PERSOSUBSTATE_SIM_SERVICE_PROVIDER = 6,
 123   PERSOSUBSTATE_SIM_SIM = 7,
 124   PERSOSUBSTATE_SIM_NETWORK_PUK = 8,
 125   PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK = 9,
 126   PERSOSUBSTATE_SIM_CORPORATE_PUK = 10,
 127   PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK = 11,
 128   PERSOSUBSTATE_SIM_SIM_PUK = 12,
 129   PERSOSUBSTATE_RUIM_NETWORK1 = 13,
 130   PERSOSUBSTATE_RUIM_NETWORK2 = 14,
 131   PERSOSUBSTATE_RUIM_HRPD = 15,
 132   PERSOSUBSTATE_RUIM_CORPORATE = 16,
 133   PERSOSUBSTATE_RUIM_SERVICE_PROVIDER = 17,
 134   PERSOSUBSTATE_RUIM_RUIM = 18,
 135   PERSOSUBSTATE_RUIM_NETWORK1_PUK = 19,
 136   PERSOSUBSTATE_RUIM_NETWORK2_PUK = 20,
 137   PERSOSUBSTATE_RUIM_HRPD_PUK = 21,
 138   PERSOSUBSTATE_RUIM_CORPORATE_PUK = 22,
 139   PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK = 23,
 140   PERSOSUBSTATE_RUIM_RUIM_PUK = 24
 141 };
 142 bool RilPersoSubstate_IsValid(int value);
 143 const RilPersoSubstate RilPersoSubstate_MIN = PERSOSUBSTATE_UNKNOWN;
 144 const RilPersoSubstate RilPersoSubstate_MAX = PERSOSUBSTATE_RUIM_RUIM_PUK;
 145 const int RilPersoSubstate_ARRAYSIZE = RilPersoSubstate_MAX + 1;
 146
 147 const ::google::protobuf::EnumDescriptor* RilPersoSubstate_descriptor();
 148 inline const ::std::string& RilPersoSubstate_Name(RilPersoSubstate value) {
 149   return ::google::protobuf::internal::NameOfEnum(
 150     RilPersoSubstate_descriptor(), value);
 151 }
 152 inline bool RilPersoSubstate_Parse(
 153     const ::std::string& name, RilPersoSubstate* value) {
 154   return ::google::protobuf::internal::ParseNamedEnum<RilPersoSubstate>(
 155     RilPersoSubstate_descriptor(), name, value);
 156 }
 157 enum RilAppState {
 158   APPSTATE_UNKNOWN = 0,
 159   APPSTATE_DETECTED = 1,
 160   APPSTATE_PIN = 2,
 161   APPSTATE_PUK = 3,
 162   APPSTATE_SUBSCRIPTION_PERSO = 4,
 163   APPSTATE_READY = 5
 164 };
 165 bool RilAppState_IsValid(int value);
 166 const RilAppState RilAppState_MIN = APPSTATE_UNKNOWN;
 167 const RilAppState RilAppState_MAX = APPSTATE_READY;
 168 const int RilAppState_ARRAYSIZE = RilAppState_MAX + 1;
 169
 170 const ::google::protobuf::EnumDescriptor* RilAppState_descriptor();
 171 inline const ::std::string& RilAppState_Name(RilAppState value) {
 172   return ::google::protobuf::internal::NameOfEnum(
 173     RilAppState_descriptor(), value);
 174 }
 175 inline bool RilAppState_Parse(
 176     const ::std::string& name, RilAppState* value) {
 177   return ::google::protobuf::internal::ParseNamedEnum<RilAppState>(
 178     RilAppState_descriptor(), name, value);
 179 }
 180 enum RilPinState {
 181   PINSTATE_UNKNOWN = 0,
 182   PINSTATE_ENABLED_NOT_VERIFIED = 1,
 183   PINSTATE_ENABLED_VERIFIED = 2,
 184   PINSTATE_DISABLED = 3,
 185   PINSTATE_ENABLED_BLOCKED = 4,
 186   PINSTATE_ENABLED_PERM_BLOCKED = 5
 187 };
 188 bool RilPinState_IsValid(int value);
 189 const RilPinState RilPinState_MIN = PINSTATE_UNKNOWN;
 190 const RilPinState RilPinState_MAX = PINSTATE_ENABLED_PERM_BLOCKED;
 191 const int RilPinState_ARRAYSIZE = RilPinState_MAX + 1;
 192
 193 const ::google::protobuf::EnumDescriptor* RilPinState_descriptor();
 194 inline const ::std::string& RilPinState_Name(RilPinState value) {
 195   return ::google::protobuf::internal::NameOfEnum(
 196     RilPinState_descriptor(), value);
 197 }
 198 inline bool RilPinState_Parse(
 199     const ::std::string& name, RilPinState* value) {
 200   return ::google::protobuf::internal::ParseNamedEnum<RilPinState>(
 201     RilPinState_descriptor(), name, value);
 202 }
 203 enum RilAppType {
 204   APPTYPE_UNKNOWN = 0,
 205   APPTYPE_SIM = 1,
 206   APPTYPE_USIM = 2,
 207   APPTYPE_RUIM = 3,
 208   APPTYPE_CSIM = 4
 209 };
 210 bool RilAppType_IsValid(int value);
 211 const RilAppType RilAppType_MIN = APPTYPE_UNKNOWN;
 212 const RilAppType RilAppType_MAX = APPTYPE_CSIM;
 213 const int RilAppType_ARRAYSIZE = RilAppType_MAX + 1;
 214
 215 const ::google::protobuf::EnumDescriptor* RilAppType_descriptor();
 216 inline const ::std::string& RilAppType_Name(RilAppType value) {
 217   return ::google::protobuf::internal::NameOfEnum(
 218     RilAppType_descriptor(), value);
 219 }
 220 inline bool RilAppType_Parse(
 221     const ::std::string& name, RilAppType* value) {
 222   return ::google::protobuf::internal::ParseNamedEnum<RilAppType>(
 223     RilAppType_descriptor(), name, value);
 224 }
 225 // ===================================================================
 226
 227 class RilAppStatus : public ::google::protobuf::Message {
 228  public:
 229   RilAppStatus();
 230   virtual ~RilAppStatus();
 231
 232   RilAppStatus(const RilAppStatus& from);
 233
 234   inline RilAppStatus& operator=(const RilAppStatus& from) {
 235     CopyFrom(from);
 236     return *this;
 237   }
 238
 239   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 240     return _unknown_fields_;
 241   }
 242
 243   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 244     return &_unknown_fields_;
 245   }
 246
 247   static const ::google::protobuf::Descriptor* descriptor();
 248   static const RilAppStatus& default_instance();
 249
 250   void Swap(RilAppStatus* other);
 251
 252   // implements Message ----------------------------------------------
 253
 254   RilAppStatus* New() const;
 255   void CopyFrom(const ::google::protobuf::Message& from);
 256   void MergeFrom(const ::google::protobuf::Message& from);
 257   void CopyFrom(const RilAppStatus& from);
 258   void MergeFrom(const RilAppStatus& from);
 259   void Clear();
 260   bool IsInitialized() const;
 261
 262   int ByteSize() const;
 263   bool MergePartialFromCodedStream(
 264       ::google::protobuf::io::CodedInputStream* input);
 265   void SerializeWithCachedSizes(
 266       ::google::protobuf::io::CodedOutputStream* output) const;
 267   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 268   int GetCachedSize() const { return _cached_size_; }
 269   private:
 270   void SharedCtor();
 271   void SharedDtor();
 272   void SetCachedSize(int size) const;
 273   public:
 274
 275   ::google::protobuf::Metadata GetMetadata() const;
 276
 277   // nested types ----------------------------------------------------
 278
 279   // accessors -------------------------------------------------------
 280
 281   // optional .ril_proto.RilAppType app_type = 1;
 282   inline bool has_app_type() const;
 283   inline void clear_app_type();
 284   static const int kAppTypeFieldNumber = 1;
 285   inline ril_proto::RilAppType app_type() const;
 286   inline void set_app_type(ril_proto::RilAppType value);
 287
 288   // optional .ril_proto.RilAppState app_state = 2;
 289   inline bool has_app_state() const;
 290   inline void clear_app_state();
 291   static const int kAppStateFieldNumber = 2;
 292   inline ril_proto::RilAppState app_state() const;
 293   inline void set_app_state(ril_proto::RilAppState value);
 294
 295   // optional .ril_proto.RilPersoSubstate perso_substate = 3;
 296   inline bool has_perso_substate() const;
 297   inline void clear_perso_substate();
 298   static const int kPersoSubstateFieldNumber = 3;
 299   inline ril_proto::RilPersoSubstate perso_substate() const;
 300   inline void set_perso_substate(ril_proto::RilPersoSubstate value);
 301
 302   // optional string aid = 4;
 303   inline bool has_aid() const;
 304   inline void clear_aid();
 305   static const int kAidFieldNumber = 4;
 306   inline const ::std::string& aid() const;
 307   inline void set_aid(const ::std::string& value);
 308   inline void set_aid(const char* value);
 309   inline void set_aid(const char* value, size_t size);
 310   inline ::std::string* mutable_aid();
 311
 312   // optional string app_label = 5;
 313   inline bool has_app_label() const;
 314   inline void clear_app_label();
 315   static const int kAppLabelFieldNumber = 5;
 316   inline const ::std::string& app_label() const;
 317   inline void set_app_label(const ::std::string& value);
 318   inline void set_app_label(const char* value);
 319   inline void set_app_label(const char* value, size_t size);
 320   inline ::std::string* mutable_app_label();
 321
 322   // optional int32 pin1_replaced = 6;
 323   inline bool has_pin1_replaced() const;
 324   inline void clear_pin1_replaced();
 325   static const int kPin1ReplacedFieldNumber = 6;
 326   inline ::google::protobuf::int32 pin1_replaced() const;
 327   inline void set_pin1_replaced(::google::protobuf::int32 value);
 328
 329   // optional .ril_proto.RilPinState pin1 = 7;
 330   inline bool has_pin1() const;
 331   inline void clear_pin1();
 332   static const int kPin1FieldNumber = 7;
 333   inline ril_proto::RilPinState pin1() const;
 334   inline void set_pin1(ril_proto::RilPinState value);
 335
 336   // optional .ril_proto.RilPinState pin2 = 8;
 337   inline bool has_pin2() const;
 338   inline void clear_pin2();
 339   static const int kPin2FieldNumber = 8;
 340   inline ril_proto::RilPinState pin2() const;
 341   inline void set_pin2(ril_proto::RilPinState value);
 342
 343   // @@protoc_insertion_point(class_scope:ril_proto.RilAppStatus)
 344  private:
 345   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 346   mutable int _cached_size_;
 347
 348   int app_type_;
 349   int app_state_;
 350   int perso_substate_;
 351   ::std::string* aid_;
 352   static const ::std::string _default_aid_;
 353   ::std::string* app_label_;
 354   static const ::std::string _default_app_label_;
 355   ::google::protobuf::int32 pin1_replaced_;
 356   int pin1_;
 357   int pin2_;
 358   friend void  protobuf_AddDesc_ril_2eproto();
 359   friend void protobuf_AssignDesc_ril_2eproto();
 360   friend void protobuf_ShutdownFile_ril_2eproto();
 361
 362   ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
 363
 364   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 365   inline bool _has_bit(int index) const {
 366     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 367   }
 368   inline void _set_bit(int index) {
 369     _has_bits_[index / 32] |= (1u << (index % 32));
 370   }
 371   inline void _clear_bit(int index) {
 372     _has_bits_[index / 32] &= ~(1u << (index % 32));
 373   }
 374
 375   void InitAsDefaultInstance();
 376   static RilAppStatus* default_instance_;
 377 };
 378 // -------------------------------------------------------------------
 379
 380 class RilCardStatus : public ::google::protobuf::Message {
 381  public:
 382   RilCardStatus();
 383   virtual ~RilCardStatus();
 384
 385   RilCardStatus(const RilCardStatus& from);
 386
 387   inline RilCardStatus& operator=(const RilCardStatus& from) {
 388     CopyFrom(from);
 389     return *this;
 390   }
 391
 392   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 393     return _unknown_fields_;
 394   }
 395
 396   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 397     return &_unknown_fields_;
 398   }
 399
 400   static const ::google::protobuf::Descriptor* descriptor();
 401   static const RilCardStatus& default_instance();
 402
 403   void Swap(RilCardStatus* other);
 404
 405   // implements Message ----------------------------------------------
 406
 407   RilCardStatus* New() const;
 408   void CopyFrom(const ::google::protobuf::Message& from);
 409   void MergeFrom(const ::google::protobuf::Message& from);
 410   void CopyFrom(const RilCardStatus& from);
 411   void MergeFrom(const RilCardStatus& from);
 412   void Clear();
 413   bool IsInitialized() const;
 414
 415   int ByteSize() const;
 416   bool MergePartialFromCodedStream(
 417       ::google::protobuf::io::CodedInputStream* input);
 418   void SerializeWithCachedSizes(
 419       ::google::protobuf::io::CodedOutputStream* output) const;
 420   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 421   int GetCachedSize() const { return _cached_size_; }
 422   private:
 423   void SharedCtor();
 424   void SharedDtor();
 425   void SetCachedSize(int size) const;
 426   public:
 427
 428   ::google::protobuf::Metadata GetMetadata() const;
 429
 430   // nested types ----------------------------------------------------
 431
 432   // accessors -------------------------------------------------------
 433
 434   // optional .ril_proto.RilCardState card_state = 1;
 435   inline bool has_card_state() const;
 436   inline void clear_card_state();
 437   static const int kCardStateFieldNumber = 1;
 438   inline ril_proto::RilCardState card_state() const;
 439   inline void set_card_state(ril_proto::RilCardState value);
 440
 441   // optional .ril_proto.RilPinState universal_pin_state = 2;
 442   inline bool has_universal_pin_state() const;
 443   inline void clear_universal_pin_state();
 444   static const int kUniversalPinStateFieldNumber = 2;
 445   inline ril_proto::RilPinState universal_pin_state() const;
 446   inline void set_universal_pin_state(ril_proto::RilPinState value);
 447
 448   // optional int32 gsm_umts_subscription_app_index = 3;
 449   inline bool has_gsm_umts_subscription_app_index() const;
 450   inline void clear_gsm_umts_subscription_app_index();
 451   static const int kGsmUmtsSubscriptionAppIndexFieldNumber = 3;
 452   inline ::google::protobuf::int32 gsm_umts_subscription_app_index() const;
 453   inline void set_gsm_umts_subscription_app_index(::google::protobuf::int32 value);
 454
 455   // optional int32 cdma_subscription_app_index = 4;
 456   inline bool has_cdma_subscription_app_index() const;
 457   inline void clear_cdma_subscription_app_index();
 458   static const int kCdmaSubscriptionAppIndexFieldNumber = 4;
 459   inline ::google::protobuf::int32 cdma_subscription_app_index() const;
 460   inline void set_cdma_subscription_app_index(::google::protobuf::int32 value);
 461
 462   // optional int32 num_applications = 5;
 463   inline bool has_num_applications() const;
 464   inline void clear_num_applications();
 465   static const int kNumApplicationsFieldNumber = 5;
 466   inline ::google::protobuf::int32 num_applications() const;
 467   inline void set_num_applications(::google::protobuf::int32 value);
 468
 469   // repeated .ril_proto.RilAppStatus applications = 6;
 470   inline int applications_size() const;
 471   inline void clear_applications();
 472   static const int kApplicationsFieldNumber = 6;
 473   inline const ::ril_proto::RilAppStatus& applications(int index) const;
 474   inline ::ril_proto::RilAppStatus* mutable_applications(int index);
 475   inline ::ril_proto::RilAppStatus* add_applications();
 476   inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >&
 477       applications() const;
 478   inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >*
 479       mutable_applications();
 480
 481   // @@protoc_insertion_point(class_scope:ril_proto.RilCardStatus)
 482  private:
 483   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 484   mutable int _cached_size_;
 485
 486   int card_state_;
 487   int universal_pin_state_;
 488   ::google::protobuf::int32 gsm_umts_subscription_app_index_;
 489   ::google::protobuf::int32 cdma_subscription_app_index_;
 490   ::google::protobuf::int32 num_applications_;
 491   ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus > applications_;
 492   friend void  protobuf_AddDesc_ril_2eproto();
 493   friend void protobuf_AssignDesc_ril_2eproto();
 494   friend void protobuf_ShutdownFile_ril_2eproto();
 495
 496   ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
 497
 498   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 499   inline bool _has_bit(int index) const {
 500     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 501   }
 502   inline void _set_bit(int index) {
 503     _has_bits_[index / 32] |= (1u << (index % 32));
 504   }
 505   inline void _clear_bit(int index) {
 506     _has_bits_[index / 32] &= ~(1u << (index % 32));
 507   }
 508
 509   void InitAsDefaultInstance();
 510   static RilCardStatus* default_instance_;
 511 };
 512 // -------------------------------------------------------------------
 513
 514 class RspStrings : public ::google::protobuf::Message {
 515  public:
 516   RspStrings();
 517   virtual ~RspStrings();
 518
 519   RspStrings(const RspStrings& from);
 520
 521   inline RspStrings& operator=(const RspStrings& from) {
 522     CopyFrom(from);
 523     return *this;
 524   }
 525
 526   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 527     return _unknown_fields_;
 528   }
 529
 530   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 531     return &_unknown_fields_;
 532   }
 533
 534   static const ::google::protobuf::Descriptor* descriptor();
 535   static const RspStrings& default_instance();
 536
 537   void Swap(RspStrings* other);
 538
 539   // implements Message ----------------------------------------------
 540
 541   RspStrings* New() const;
 542   void CopyFrom(const ::google::protobuf::Message& from);
 543   void MergeFrom(const ::google::protobuf::Message& from);
 544   void CopyFrom(const RspStrings& from);
 545   void MergeFrom(const RspStrings& from);
 546   void Clear();
 547   bool IsInitialized() const;
 548
 549   int ByteSize() const;
 550   bool MergePartialFromCodedStream(
 551       ::google::protobuf::io::CodedInputStream* input);
 552   void SerializeWithCachedSizes(
 553       ::google::protobuf::io::CodedOutputStream* output) const;
 554   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 555   int GetCachedSize() const { return _cached_size_; }
 556   private:
 557   void SharedCtor();
 558   void SharedDtor();
 559   void SetCachedSize(int size) const;
 560   public:
 561
 562   ::google::protobuf::Metadata GetMetadata() const;
 563
 564   // nested types ----------------------------------------------------
 565
 566   // accessors -------------------------------------------------------
 567
 568   // repeated string strings = 1;
 569   inline int strings_size() const;
 570   inline void clear_strings();
 571   static const int kStringsFieldNumber = 1;
 572   inline const ::std::string& strings(int index) const;
 573   inline ::std::string* mutable_strings(int index);
 574   inline void set_strings(int index, const ::std::string& value);
 575   inline void set_strings(int index, const char* value);
 576   inline void set_strings(int index, const char* value, size_t size);
 577   inline ::std::string* add_strings();
 578   inline void add_strings(const ::std::string& value);
 579   inline void add_strings(const char* value);
 580   inline void add_strings(const char* value, size_t size);
 581   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& strings() const;
 582   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_strings();
 583
 584   // @@protoc_insertion_point(class_scope:ril_proto.RspStrings)
 585  private:
 586   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 587   mutable int _cached_size_;
 588
 589   ::google::protobuf::RepeatedPtrField< ::std::string> strings_;
 590   friend void  protobuf_AddDesc_ril_2eproto();
 591   friend void protobuf_AssignDesc_ril_2eproto();
 592   friend void protobuf_ShutdownFile_ril_2eproto();
 593
 594   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 595
 596   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 597   inline bool _has_bit(int index) const {
 598     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 599   }
 600   inline void _set_bit(int index) {
 601     _has_bits_[index / 32] |= (1u << (index % 32));
 602   }
 603   inline void _clear_bit(int index) {
 604     _has_bits_[index / 32] &= ~(1u << (index % 32));
 605   }
 606
 607   void InitAsDefaultInstance();
 608   static RspStrings* default_instance_;
 609 };
 610 // -------------------------------------------------------------------
 611
 612 class RspIntegers : public ::google::protobuf::Message {
 613  public:
 614   RspIntegers();
 615   virtual ~RspIntegers();
 616
 617   RspIntegers(const RspIntegers& from);
 618
 619   inline RspIntegers& operator=(const RspIntegers& from) {
 620     CopyFrom(from);
 621     return *this;
 622   }
 623
 624   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 625     return _unknown_fields_;
 626   }
 627
 628   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 629     return &_unknown_fields_;
 630   }
 631
 632   static const ::google::protobuf::Descriptor* descriptor();
 633   static const RspIntegers& default_instance();
 634
 635   void Swap(RspIntegers* other);
 636
 637   // implements Message ----------------------------------------------
 638
 639   RspIntegers* New() const;
 640   void CopyFrom(const ::google::protobuf::Message& from);
 641   void MergeFrom(const ::google::protobuf::Message& from);
 642   void CopyFrom(const RspIntegers& from);
 643   void MergeFrom(const RspIntegers& from);
 644   void Clear();
 645   bool IsInitialized() const;
 646
 647   int ByteSize() const;
 648   bool MergePartialFromCodedStream(
 649       ::google::protobuf::io::CodedInputStream* input);
 650   void SerializeWithCachedSizes(
 651       ::google::protobuf::io::CodedOutputStream* output) const;
 652   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 653   int GetCachedSize() const { return _cached_size_; }
 654   private:
 655   void SharedCtor();
 656   void SharedDtor();
 657   void SetCachedSize(int size) const;
 658   public:
 659
 660   ::google::protobuf::Metadata GetMetadata() const;
 661
 662   // nested types ----------------------------------------------------
 663
 664   // accessors -------------------------------------------------------
 665
 666   // repeated int32 integers = 1;
 667   inline int integers_size() const;
 668   inline void clear_integers();
 669   static const int kIntegersFieldNumber = 1;
 670   inline ::google::protobuf::int32 integers(int index) const;
 671   inline void set_integers(int index, ::google::protobuf::int32 value);
 672   inline void add_integers(::google::protobuf::int32 value);
 673   inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
 674       integers() const;
 675   inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
 676       mutable_integers();
 677
 678   // @@protoc_insertion_point(class_scope:ril_proto.RspIntegers)
 679  private:
 680   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 681   mutable int _cached_size_;
 682
 683   ::google::protobuf::RepeatedField< ::google::protobuf::int32 > integers_;
 684   friend void  protobuf_AddDesc_ril_2eproto();
 685   friend void protobuf_AssignDesc_ril_2eproto();
 686   friend void protobuf_ShutdownFile_ril_2eproto();
 687
 688   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 689
 690   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 691   inline bool _has_bit(int index) const {
 692     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 693   }
 694   inline void _set_bit(int index) {
 695     _has_bits_[index / 32] |= (1u << (index % 32));
 696   }
 697   inline void _clear_bit(int index) {
 698     _has_bits_[index / 32] &= ~(1u << (index % 32));
 699   }
 700
 701   void InitAsDefaultInstance();
 702   static RspIntegers* default_instance_;
 703 };
 704 // -------------------------------------------------------------------
 705
 706 class ReqGetSimStatus : public ::google::protobuf::Message {
 707  public:
 708   ReqGetSimStatus();
 709   virtual ~ReqGetSimStatus();
 710
 711   ReqGetSimStatus(const ReqGetSimStatus& from);
 712
 713   inline ReqGetSimStatus& operator=(const ReqGetSimStatus& from) {
 714     CopyFrom(from);
 715     return *this;
 716   }
 717
 718   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 719     return _unknown_fields_;
 720   }
 721
 722   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 723     return &_unknown_fields_;
 724   }
 725
 726   static const ::google::protobuf::Descriptor* descriptor();
 727   static const ReqGetSimStatus& default_instance();
 728
 729   void Swap(ReqGetSimStatus* other);
 730
 731   // implements Message ----------------------------------------------
 732
 733   ReqGetSimStatus* New() const;
 734   void CopyFrom(const ::google::protobuf::Message& from);
 735   void MergeFrom(const ::google::protobuf::Message& from);
 736   void CopyFrom(const ReqGetSimStatus& from);
 737   void MergeFrom(const ReqGetSimStatus& from);
 738   void Clear();
 739   bool IsInitialized() const;
 740
 741   int ByteSize() const;
 742   bool MergePartialFromCodedStream(
 743       ::google::protobuf::io::CodedInputStream* input);
 744   void SerializeWithCachedSizes(
 745       ::google::protobuf::io::CodedOutputStream* output) const;
 746   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 747   int GetCachedSize() const { return _cached_size_; }
 748   private:
 749   void SharedCtor();
 750   void SharedDtor();
 751   void SetCachedSize(int size) const;
 752   public:
 753
 754   ::google::protobuf::Metadata GetMetadata() const;
 755
 756   // nested types ----------------------------------------------------
 757
 758   // accessors -------------------------------------------------------
 759
 760   // @@protoc_insertion_point(class_scope:ril_proto.ReqGetSimStatus)
 761  private:
 762   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 763   mutable int _cached_size_;
 764
 765   friend void  protobuf_AddDesc_ril_2eproto();
 766   friend void protobuf_AssignDesc_ril_2eproto();
 767   friend void protobuf_ShutdownFile_ril_2eproto();
 768
 769   ::google::protobuf::uint32 _has_bits_[1];
 770
 771   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 772   inline bool _has_bit(int index) const {
 773     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 774   }
 775   inline void _set_bit(int index) {
 776     _has_bits_[index / 32] |= (1u << (index % 32));
 777   }
 778   inline void _clear_bit(int index) {
 779     _has_bits_[index / 32] &= ~(1u << (index % 32));
 780   }
 781
 782   void InitAsDefaultInstance();
 783   static ReqGetSimStatus* default_instance_;
 784 };
 785 // -------------------------------------------------------------------
 786
 787 class RspGetSimStatus : public ::google::protobuf::Message {
 788  public:
 789   RspGetSimStatus();
 790   virtual ~RspGetSimStatus();
 791
 792   RspGetSimStatus(const RspGetSimStatus& from);
 793
 794   inline RspGetSimStatus& operator=(const RspGetSimStatus& from) {
 795     CopyFrom(from);
 796     return *this;
 797   }
 798
 799   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 800     return _unknown_fields_;
 801   }
 802
 803   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 804     return &_unknown_fields_;
 805   }
 806
 807   static const ::google::protobuf::Descriptor* descriptor();
 808   static const RspGetSimStatus& default_instance();
 809
 810   void Swap(RspGetSimStatus* other);
 811
 812   // implements Message ----------------------------------------------
 813
 814   RspGetSimStatus* New() const;
 815   void CopyFrom(const ::google::protobuf::Message& from);
 816   void MergeFrom(const ::google::protobuf::Message& from);
 817   void CopyFrom(const RspGetSimStatus& from);
 818   void MergeFrom(const RspGetSimStatus& from);
 819   void Clear();
 820   bool IsInitialized() const;
 821
 822   int ByteSize() const;
 823   bool MergePartialFromCodedStream(
 824       ::google::protobuf::io::CodedInputStream* input);
 825   void SerializeWithCachedSizes(
 826       ::google::protobuf::io::CodedOutputStream* output) const;
 827   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 828   int GetCachedSize() const { return _cached_size_; }
 829   private:
 830   void SharedCtor();
 831   void SharedDtor();
 832   void SetCachedSize(int size) const;
 833   public:
 834
 835   ::google::protobuf::Metadata GetMetadata() const;
 836
 837   // nested types ----------------------------------------------------
 838
 839   // accessors -------------------------------------------------------
 840
 841   // required .ril_proto.RilCardStatus card_status = 1;
 842   inline bool has_card_status() const;
 843   inline void clear_card_status();
 844   static const int kCardStatusFieldNumber = 1;
 845   inline const ::ril_proto::RilCardStatus& card_status() const;
 846   inline ::ril_proto::RilCardStatus* mutable_card_status();
 847
 848   // @@protoc_insertion_point(class_scope:ril_proto.RspGetSimStatus)
 849  private:
 850   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 851   mutable int _cached_size_;
 852
 853   ::ril_proto::RilCardStatus* card_status_;
 854   friend void  protobuf_AddDesc_ril_2eproto();
 855   friend void protobuf_AssignDesc_ril_2eproto();
 856   friend void protobuf_ShutdownFile_ril_2eproto();
 857
 858   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 859
 860   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 861   inline bool _has_bit(int index) const {
 862     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 863   }
 864   inline void _set_bit(int index) {
 865     _has_bits_[index / 32] |= (1u << (index % 32));
 866   }
 867   inline void _clear_bit(int index) {
 868     _has_bits_[index / 32] &= ~(1u << (index % 32));
 869   }
 870
 871   void InitAsDefaultInstance();
 872   static RspGetSimStatus* default_instance_;
 873 };
 874 // -------------------------------------------------------------------
 875
 876 class ReqEnterSimPin : public ::google::protobuf::Message {
 877  public:
 878   ReqEnterSimPin();
 879   virtual ~ReqEnterSimPin();
 880
 881   ReqEnterSimPin(const ReqEnterSimPin& from);
 882
 883   inline ReqEnterSimPin& operator=(const ReqEnterSimPin& from) {
 884     CopyFrom(from);
 885     return *this;
 886   }
 887
 888   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 889     return _unknown_fields_;
 890   }
 891
 892   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 893     return &_unknown_fields_;
 894   }
 895
 896   static const ::google::protobuf::Descriptor* descriptor();
 897   static const ReqEnterSimPin& default_instance();
 898
 899   void Swap(ReqEnterSimPin* other);
 900
 901   // implements Message ----------------------------------------------
 902
 903   ReqEnterSimPin* New() const;
 904   void CopyFrom(const ::google::protobuf::Message& from);
 905   void MergeFrom(const ::google::protobuf::Message& from);
 906   void CopyFrom(const ReqEnterSimPin& from);
 907   void MergeFrom(const ReqEnterSimPin& from);
 908   void Clear();
 909   bool IsInitialized() const;
 910
 911   int ByteSize() const;
 912   bool MergePartialFromCodedStream(
 913       ::google::protobuf::io::CodedInputStream* input);
 914   void SerializeWithCachedSizes(
 915       ::google::protobuf::io::CodedOutputStream* output) const;
 916   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 917   int GetCachedSize() const { return _cached_size_; }
 918   private:
 919   void SharedCtor();
 920   void SharedDtor();
 921   void SetCachedSize(int size) const;
 922   public:
 923
 924   ::google::protobuf::Metadata GetMetadata() const;
 925
 926   // nested types ----------------------------------------------------
 927
 928   // accessors -------------------------------------------------------
 929
 930   // required string pin = 1;
 931   inline bool has_pin() const;
 932   inline void clear_pin();
 933   static const int kPinFieldNumber = 1;
 934   inline const ::std::string& pin() const;
 935   inline void set_pin(const ::std::string& value);
 936   inline void set_pin(const char* value);
 937   inline void set_pin(const char* value, size_t size);
 938   inline ::std::string* mutable_pin();
 939
 940   // @@protoc_insertion_point(class_scope:ril_proto.ReqEnterSimPin)
 941  private:
 942   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 943   mutable int _cached_size_;
 944
 945   ::std::string* pin_;
 946   static const ::std::string _default_pin_;
 947   friend void  protobuf_AddDesc_ril_2eproto();
 948   friend void protobuf_AssignDesc_ril_2eproto();
 949   friend void protobuf_ShutdownFile_ril_2eproto();
 950
 951   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
 952
 953   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
 954   inline bool _has_bit(int index) const {
 955     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
 956   }
 957   inline void _set_bit(int index) {
 958     _has_bits_[index / 32] |= (1u << (index % 32));
 959   }
 960   inline void _clear_bit(int index) {
 961     _has_bits_[index / 32] &= ~(1u << (index % 32));
 962   }
 963
 964   void InitAsDefaultInstance();
 965   static ReqEnterSimPin* default_instance_;
 966 };
 967 // -------------------------------------------------------------------
 968
 969 class RspEnterSimPin : public ::google::protobuf::Message {
 970  public:
 971   RspEnterSimPin();
 972   virtual ~RspEnterSimPin();
 973
 974   RspEnterSimPin(const RspEnterSimPin& from);
 975
 976   inline RspEnterSimPin& operator=(const RspEnterSimPin& from) {
 977     CopyFrom(from);
 978     return *this;
 979   }
 980
 981   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 982     return _unknown_fields_;
 983   }
 984
 985   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 986     return &_unknown_fields_;
 987   }
 988
 989   static const ::google::protobuf::Descriptor* descriptor();
 990   static const RspEnterSimPin& default_instance();
 991
 992   void Swap(RspEnterSimPin* other);
 993
 994   // implements Message ----------------------------------------------
 995
 996   RspEnterSimPin* New() const;
 997   void CopyFrom(const ::google::protobuf::Message& from);
 998   void MergeFrom(const ::google::protobuf::Message& from);
 999   void CopyFrom(const RspEnterSimPin& from);
1000   void MergeFrom(const RspEnterSimPin& from);
1001   void Clear();
1002   bool IsInitialized() const;
1003
1004   int ByteSize() const;
1005   bool MergePartialFromCodedStream(
1006       ::google::protobuf::io::CodedInputStream* input);
1007   void SerializeWithCachedSizes(
1008       ::google::protobuf::io::CodedOutputStream* output) const;
1009   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1010   int GetCachedSize() const { return _cached_size_; }
1011   private:
1012   void SharedCtor();
1013   void SharedDtor();
1014   void SetCachedSize(int size) const;
1015   public:
1016
1017   ::google::protobuf::Metadata GetMetadata() const;
1018
1019   // nested types ----------------------------------------------------
1020
1021   // accessors -------------------------------------------------------
1022
1023   // required int32 retries_remaining = 1;
1024   inline bool has_retries_remaining() const;
1025   inline void clear_retries_remaining();
1026   static const int kRetriesRemainingFieldNumber = 1;
1027   inline ::google::protobuf::int32 retries_remaining() const;
1028   inline void set_retries_remaining(::google::protobuf::int32 value);
1029
1030   // @@protoc_insertion_point(class_scope:ril_proto.RspEnterSimPin)
1031  private:
1032   ::google::protobuf::UnknownFieldSet _unknown_fields_;
1033   mutable int _cached_size_;
1034
1035   ::google::protobuf::int32 retries_remaining_;
1036   friend void  protobuf_AddDesc_ril_2eproto();
1037   friend void protobuf_AssignDesc_ril_2eproto();
1038   friend void protobuf_ShutdownFile_ril_2eproto();
1039
1040   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1041
1042   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
1043   inline bool _has_bit(int index) const {
1044     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
1045   }
1046   inline void _set_bit(int index) {
1047     _has_bits_[index / 32] |= (1u << (index % 32));
1048   }
1049   inline void _clear_bit(int index) {
1050     _has_bits_[index / 32] &= ~(1u << (index % 32));
1051   }
1052
1053   void InitAsDefaultInstance();
1054   static RspEnterSimPin* default_instance_;
1055 };
1056 // -------------------------------------------------------------------
1057
1058 class ReqHangUp : public ::google::protobuf::Message {
1059  public:
1060   ReqHangUp();
1061   virtual ~ReqHangUp();
1062
1063   ReqHangUp(const ReqHangUp& from);
1064
1065   inline ReqHangUp& operator=(const ReqHangUp& from) {
1066     CopyFrom(from);
1067     return *this;
1068   }
1069
1070   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1071     return _unknown_fields_;
1072   }
1073
1074   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1075     return &_unknown_fields_;
1076   }
1077
1078   static const ::google::protobuf::Descriptor* descriptor();
1079   static const ReqHangUp& default_instance();
1080
1081   void Swap(ReqHangUp* other);
1082
1083   // implements Message ----------------------------------------------
1084
1085   ReqHangUp* New() const;
1086   void CopyFrom(const ::google::protobuf::Message& from);
1087   void MergeFrom(const ::google::protobuf::Message& from);
1088   void CopyFrom(const ReqHangUp& from);
1089   void MergeFrom(const ReqHangUp& from);
1090   void Clear();
1091   bool IsInitialized() const;
1092
1093   int ByteSize() const;
1094   bool MergePartialFromCodedStream(
1095       ::google::protobuf::io::CodedInputStream* input);
1096   void SerializeWithCachedSizes(
1097       ::google::protobuf::io::CodedOutputStream* output) const;
1098   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1099   int GetCachedSize() const { return _cached_size_; }
1100   private:
1101   void SharedCtor();
1102   void SharedDtor();
1103   void SetCachedSize(int size) const;
1104   public:
1105
1106   ::google::protobuf::Metadata GetMetadata() const;
1107
1108   // nested types ----------------------------------------------------
1109
1110   // accessors -------------------------------------------------------
1111
1112   // required int32 connection_index = 1;
1113   inline bool has_connection_index() const;
1114   inline void clear_connection_index();
1115   static const int kConnectionIndexFieldNumber = 1;
1116   inline ::google::protobuf::int32 connection_index() const;
1117   inline void set_connection_index(::google::protobuf::int32 value);
1118
1119   // @@protoc_insertion_point(class_scope:ril_proto.ReqHangUp)
1120  private:
1121   ::google::protobuf::UnknownFieldSet _unknown_fields_;
1122   mutable int _cached_size_;
1123
1124   ::google::protobuf::int32 connection_index_;
1125   friend void  protobuf_AddDesc_ril_2eproto();
1126   friend void protobuf_AssignDesc_ril_2eproto();
1127   friend void protobuf_ShutdownFile_ril_2eproto();
1128
1129   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1130
1131   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
1132   inline bool _has_bit(int index) const {
1133     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
1134   }
1135   inline void _set_bit(int index) {
1136     _has_bits_[index / 32] |= (1u << (index % 32));
1137   }
1138   inline void _clear_bit(int index) {
1139     _has_bits_[index / 32] &= ~(1u << (index % 32));
1140   }
1141
1142   void InitAsDefaultInstance();
1143   static ReqHangUp* default_instance_;
1144 };
1145 // -------------------------------------------------------------------
1146
1147 class ReqScreenState : public ::google::protobuf::Message {
1148  public:
1149   ReqScreenState();
1150   virtual ~ReqScreenState();
1151
1152   ReqScreenState(const ReqScreenState& from);
1153
1154   inline ReqScreenState& operator=(const ReqScreenState& from) {
1155     CopyFrom(from);
1156     return *this;
1157   }
1158
1159   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1160     return _unknown_fields_;
1161   }
1162
1163   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1164     return &_unknown_fields_;
1165   }
1166
1167   static const ::google::protobuf::Descriptor* descriptor();
1168   static const ReqScreenState& default_instance();
1169
1170   void Swap(ReqScreenState* other);
1171
1172   // implements Message ----------------------------------------------
1173
1174   ReqScreenState* New() const;
1175   void CopyFrom(const ::google::protobuf::Message& from);
1176   void MergeFrom(const ::google::protobuf::Message& from);
1177   void CopyFrom(const ReqScreenState& from);
1178   void MergeFrom(const ReqScreenState& from);
1179   void Clear();
1180   bool IsInitialized() const;
1181
1182   int ByteSize() const;
1183   bool MergePartialFromCodedStream(
1184       ::google::protobuf::io::CodedInputStream* input);
1185   void SerializeWithCachedSizes(
1186       ::google::protobuf::io::CodedOutputStream* output) const;
1187   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1188   int GetCachedSize() const { return _cached_size_; }
1189   private:
1190   void SharedCtor();
1191   void SharedDtor();
1192   void SetCachedSize(int size) const;
1193   public:
1194
1195   ::google::protobuf::Metadata GetMetadata() const;
1196
1197   // nested types ----------------------------------------------------
1198
1199   // accessors -------------------------------------------------------
1200
1201   // required bool state = 1;
1202   inline bool has_state() const;
1203   inline void clear_state();
1204   static const int kStateFieldNumber = 1;
1205   inline bool state() const;
1206   inline void set_state(bool value);
1207
1208   // @@protoc_insertion_point(class_scope:ril_proto.ReqScreenState)
1209  private:
1210   ::google::protobuf::UnknownFieldSet _unknown_fields_;
1211   mutable int _cached_size_;
1212
1213   bool state_;
1214   friend void  protobuf_AddDesc_ril_2eproto();
1215   friend void protobuf_AssignDesc_ril_2eproto();
1216   friend void protobuf_ShutdownFile_ril_2eproto();
1217
1218   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1219
1220   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
1221   inline bool _has_bit(int index) const {
1222     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
1223   }
1224   inline void _set_bit(int index) {
1225     _has_bits_[index / 32] |= (1u << (index % 32));
1226   }
1227   inline void _clear_bit(int index) {
1228     _has_bits_[index / 32] &= ~(1u << (index % 32));
1229   }
1230
1231   void InitAsDefaultInstance();
1232   static ReqScreenState* default_instance_;
1233 };
1234 // -------------------------------------------------------------------
1235
1236 class RspOperator : public ::google::protobuf::Message {
1237  public:
1238   RspOperator();
1239   virtual ~RspOperator();
1240
1241   RspOperator(const RspOperator& from);
1242
1243   inline RspOperator& operator=(const RspOperator& from) {
1244     CopyFrom(from);
1245     return *this;
1246   }
1247
1248   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1249     return _unknown_fields_;
1250   }
1251
1252   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1253     return &_unknown_fields_;
1254   }
1255
1256   static const ::google::protobuf::Descriptor* descriptor();
1257   static const RspOperator& default_instance();
1258
1259   void Swap(RspOperator* other);
1260
1261   // implements Message ----------------------------------------------
1262
1263   RspOperator* New() const;
1264   void CopyFrom(const ::google::protobuf::Message& from);
1265   void MergeFrom(const ::google::protobuf::Message& from);
1266   void CopyFrom(const RspOperator& from);
1267   void MergeFrom(const RspOperator& from);
1268   void Clear();
1269   bool IsInitialized() const;
1270
1271   int ByteSize() const;
1272   bool MergePartialFromCodedStream(
1273       ::google::protobuf::io::CodedInputStream* input);
1274   void SerializeWithCachedSizes(
1275       ::google::protobuf::io::CodedOutputStream* output) const;
1276   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1277   int GetCachedSize() const { return _cached_size_; }
1278   private:
1279   void SharedCtor();
1280   void SharedDtor();
1281   void SetCachedSize(int size) const;
1282   public:
1283
1284   ::google::protobuf::Metadata GetMetadata() const;
1285
1286   // nested types ----------------------------------------------------
1287
1288   // accessors -------------------------------------------------------
1289
1290   // optional string long_alpha_ons = 1;
1291   inline bool has_long_alpha_ons() const;
1292   inline void clear_long_alpha_ons();
1293   static const int kLongAlphaOnsFieldNumber = 1;
1294   inline const ::std::string& long_alpha_ons() const;
1295   inline void set_long_alpha_ons(const ::std::string& value);
1296   inline void set_long_alpha_ons(const char* value);
1297   inline void set_long_alpha_ons(const char* value, size_t size);
1298   inline ::std::string* mutable_long_alpha_ons();
1299
1300   // optional string short_alpha_ons = 2;
1301   inline bool has_short_alpha_ons() const;
1302   inline void clear_short_alpha_ons();
1303   static const int kShortAlphaOnsFieldNumber = 2;
1304   inline const ::std::string& short_alpha_ons() const;
1305   inline void set_short_alpha_ons(const ::std::string& value);
1306   inline void set_short_alpha_ons(const char* value);
1307   inline void set_short_alpha_ons(const char* value, size_t size);
1308   inline ::std::string* mutable_short_alpha_ons();
1309
1310   // optional string mcc_mnc = 3;
1311   inline bool has_mcc_mnc() const;
1312   inline void clear_mcc_mnc();
1313   static const int kMccMncFieldNumber = 3;
1314   inline const ::std::string& mcc_mnc() const;
1315   inline void set_mcc_mnc(const ::std::string& value);
1316   inline void set_mcc_mnc(const char* value);
1317   inline void set_mcc_mnc(const char* value, size_t size);
1318   inline ::std::string* mutable_mcc_mnc();
1319
1320   // @@protoc_insertion_point(class_scope:ril_proto.RspOperator)
1321  private:
1322   ::google::protobuf::UnknownFieldSet _unknown_fields_;
1323   mutable int _cached_size_;
1324
1325   ::std::string* long_alpha_ons_;
1326   static const ::std::string _default_long_alpha_ons_;
1327   ::std::string* short_alpha_ons_;
1328   static const ::std::string _default_short_alpha_ons_;
1329   ::std::string* mcc_mnc_;
1330   static const ::std::string _default_mcc_mnc_;
1331   friend void  protobuf_AddDesc_ril_2eproto();
1332   friend void protobuf_AssignDesc_ril_2eproto();
1333   friend void protobuf_ShutdownFile_ril_2eproto();
1334
1335   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1336
1337   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
1338   inline bool _has_bit(int index) const {
1339     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
1340   }
1341   inline void _set_bit(int index) {
1342     _has_bits_[index / 32] |= (1u << (index % 32));
1343   }
1344   inline void _clear_bit(int index) {
1345     _has_bits_[index / 32] &= ~(1u << (index % 32));
1346   }
1347
1348   void InitAsDefaultInstance();
1349   static RspOperator* default_instance_;
1350 };
1351 // ===================================================================
1352
1353
1354 // ===================================================================
1355
1356 // RilAppStatus
1357
1358 // optional .ril_proto.RilAppType app_type = 1;
1359 inline bool RilAppStatus::has_app_type() const {
1360   return _has_bit(0);
1361 }
1362 inline void RilAppStatus::clear_app_type() {
1363   app_type_ = 0;
1364   _clear_bit(0);
1365 }
1366 inline ril_proto::RilAppType RilAppStatus::app_type() const {
1367   return static_cast< ril_proto::RilAppType >(app_type_);
1368 }
1369 inline void RilAppStatus::set_app_type(ril_proto::RilAppType value) {
1370   GOOGLE_DCHECK(ril_proto::RilAppType_IsValid(value));
1371   _set_bit(0);
1372   app_type_ = value;
1373 }
1374
1375 // optional .ril_proto.RilAppState app_state = 2;
1376 inline bool RilAppStatus::has_app_state() const {
1377   return _has_bit(1);
1378 }
1379 inline void RilAppStatus::clear_app_state() {
1380   app_state_ = 0;
1381   _clear_bit(1);
1382 }
1383 inline ril_proto::RilAppState RilAppStatus::app_state() const {
1384   return static_cast< ril_proto::RilAppState >(app_state_);
1385 }
1386 inline void RilAppStatus::set_app_state(ril_proto::RilAppState value) {
1387   GOOGLE_DCHECK(ril_proto::RilAppState_IsValid(value));
1388   _set_bit(1);
1389   app_state_ = value;
1390 }
1391
1392 // optional .ril_proto.RilPersoSubstate perso_substate = 3;
1393 inline bool RilAppStatus::has_perso_substate() const {
1394   return _has_bit(2);
1395 }
1396 inline void RilAppStatus::clear_perso_substate() {
1397   perso_substate_ = 0;
1398   _clear_bit(2);
1399 }
1400 inline ril_proto::RilPersoSubstate RilAppStatus::perso_substate() const {
1401   return static_cast< ril_proto::RilPersoSubstate >(perso_substate_);
1402 }
1403 inline void RilAppStatus::set_perso_substate(ril_proto::RilPersoSubstate value) {
1404   GOOGLE_DCHECK(ril_proto::RilPersoSubstate_IsValid(value));
1405   _set_bit(2);
1406   perso_substate_ = value;
1407 }
1408
1409 // optional string aid = 4;
1410 inline bool RilAppStatus::has_aid() const {
1411   return _has_bit(3);
1412 }
1413 inline void RilAppStatus::clear_aid() {
1414   if (aid_ != &_default_aid_) {
1415     aid_->clear();
1416   }
1417   _clear_bit(3);
1418 }
1419 inline const ::std::string& RilAppStatus::aid() const {
1420   return *aid_;
1421 }
1422 inline void RilAppStatus::set_aid(const ::std::string& value) {
1423   _set_bit(3);
1424   if (aid_ == &_default_aid_) {
1425     aid_ = new ::std::string;
1426   }
1427   aid_->assign(value);
1428 }
1429 inline void RilAppStatus::set_aid(const char* value) {
1430   _set_bit(3);
1431   if (aid_ == &_default_aid_) {
1432     aid_ = new ::std::string;
1433   }
1434   aid_->assign(value);
1435 }
1436 inline void RilAppStatus::set_aid(const char* value, size_t size) {
1437   _set_bit(3);
1438   if (aid_ == &_default_aid_) {
1439     aid_ = new ::std::string;
1440   }
1441   aid_->assign(reinterpret_cast<const char*>(value), size);
1442 }
1443 inline ::std::string* RilAppStatus::mutable_aid() {
1444   _set_bit(3);
1445   if (aid_ == &_default_aid_) {
1446     aid_ = new ::std::string;
1447   }
1448   return aid_;
1449 }
1450
1451 // optional string app_label = 5;
1452 inline bool RilAppStatus::has_app_label() const {
1453   return _has_bit(4);
1454 }
1455 inline void RilAppStatus::clear_app_label() {
1456   if (app_label_ != &_default_app_label_) {
1457     app_label_->clear();
1458   }
1459   _clear_bit(4);
1460 }
1461 inline const ::std::string& RilAppStatus::app_label() const {
1462   return *app_label_;
1463 }
1464 inline void RilAppStatus::set_app_label(const ::std::string& value) {
1465   _set_bit(4);
1466   if (app_label_ == &_default_app_label_) {
1467     app_label_ = new ::std::string;
1468   }
1469   app_label_->assign(value);
1470 }
1471 inline void RilAppStatus::set_app_label(const char* value) {
1472   _set_bit(4);
1473   if (app_label_ == &_default_app_label_) {
1474     app_label_ = new ::std::string;
1475   }
1476   app_label_->assign(value);
1477 }
1478 inline void RilAppStatus::set_app_label(const char* value, size_t size) {
1479   _set_bit(4);
1480   if (app_label_ == &_default_app_label_) {
1481     app_label_ = new ::std::string;
1482   }
1483   app_label_->assign(reinterpret_cast<const char*>(value), size);
1484 }
1485 inline ::std::string* RilAppStatus::mutable_app_label() {
1486   _set_bit(4);
1487   if (app_label_ == &_default_app_label_) {
1488     app_label_ = new ::std::string;
1489   }
1490   return app_label_;
1491 }
1492
1493 // optional int32 pin1_replaced = 6;
1494 inline bool RilAppStatus::has_pin1_replaced() const {
1495   return _has_bit(5);
1496 }
1497 inline void RilAppStatus::clear_pin1_replaced() {
1498   pin1_replaced_ = 0;
1499   _clear_bit(5);
1500 }
1501 inline ::google::protobuf::int32 RilAppStatus::pin1_replaced() const {
1502   return pin1_replaced_;
1503 }
1504 inline void RilAppStatus::set_pin1_replaced(::google::protobuf::int32 value) {
1505   _set_bit(5);
1506   pin1_replaced_ = value;
1507 }
1508
1509 // optional .ril_proto.RilPinState pin1 = 7;
1510 inline bool RilAppStatus::has_pin1() const {
1511   return _has_bit(6);
1512 }
1513 inline void RilAppStatus::clear_pin1() {
1514   pin1_ = 0;
1515   _clear_bit(6);
1516 }
1517 inline ril_proto::RilPinState RilAppStatus::pin1() const {
1518   return static_cast< ril_proto::RilPinState >(pin1_);
1519 }
1520 inline void RilAppStatus::set_pin1(ril_proto::RilPinState value) {
1521   GOOGLE_DCHECK(ril_proto::RilPinState_IsValid(value));
1522   _set_bit(6);
1523   pin1_ = value;
1524 }
1525
1526 // optional .ril_proto.RilPinState pin2 = 8;
1527 inline bool RilAppStatus::has_pin2() const {
1528   return _has_bit(7);
1529 }
1530 inline void RilAppStatus::clear_pin2() {
1531   pin2_ = 0;
1532   _clear_bit(7);
1533 }
1534 inline ril_proto::RilPinState RilAppStatus::pin2() const {
1535   return static_cast< ril_proto::RilPinState >(pin2_);
1536 }
1537 inline void RilAppStatus::set_pin2(ril_proto::RilPinState value) {
1538   GOOGLE_DCHECK(ril_proto::RilPinState_IsValid(value));
1539   _set_bit(7);
1540   pin2_ = value;
1541 }
1542
1543 // -------------------------------------------------------------------
1544
1545 // RilCardStatus
1546
1547 // optional .ril_proto.RilCardState card_state = 1;
1548 inline bool RilCardStatus::has_card_state() const {
1549   return _has_bit(0);
1550 }
1551 inline void RilCardStatus::clear_card_state() {
1552   card_state_ = 0;
1553   _clear_bit(0);
1554 }
1555 inline ril_proto::RilCardState RilCardStatus::card_state() const {
1556   return static_cast< ril_proto::RilCardState >(card_state_);
1557 }
1558 inline void RilCardStatus::set_card_state(ril_proto::RilCardState value) {
1559   GOOGLE_DCHECK(ril_proto::RilCardState_IsValid(value));
1560   _set_bit(0);
1561   card_state_ = value;
1562 }
1563
1564 // optional .ril_proto.RilPinState universal_pin_state = 2;
1565 inline bool RilCardStatus::has_universal_pin_state() const {
1566   return _has_bit(1);
1567 }
1568 inline void RilCardStatus::clear_universal_pin_state() {
1569   universal_pin_state_ = 0;
1570   _clear_bit(1);
1571 }
1572 inline ril_proto::RilPinState RilCardStatus::universal_pin_state() const {
1573   return static_cast< ril_proto::RilPinState >(universal_pin_state_);
1574 }
1575 inline void RilCardStatus::set_universal_pin_state(ril_proto::RilPinState value) {
1576   GOOGLE_DCHECK(ril_proto::RilPinState_IsValid(value));
1577   _set_bit(1);
1578   universal_pin_state_ = value;
1579 }
1580
1581 // optional int32 gsm_umts_subscription_app_index = 3;
1582 inline bool RilCardStatus::has_gsm_umts_subscription_app_index() const {
1583   return _has_bit(2);
1584 }
1585 inline void RilCardStatus::clear_gsm_umts_subscription_app_index() {
1586   gsm_umts_subscription_app_index_ = 0;
1587   _clear_bit(2);
1588 }
1589 inline ::google::protobuf::int32 RilCardStatus::gsm_umts_subscription_app_index() const {
1590   return gsm_umts_subscription_app_index_;
1591 }
1592 inline void RilCardStatus::set_gsm_umts_subscription_app_index(::google::protobuf::int32 value) {
1593   _set_bit(2);
1594   gsm_umts_subscription_app_index_ = value;
1595 }
1596
1597 // optional int32 cdma_subscription_app_index = 4;
1598 inline bool RilCardStatus::has_cdma_subscription_app_index() const {
1599   return _has_bit(3);
1600 }
1601 inline void RilCardStatus::clear_cdma_subscription_app_index() {
1602   cdma_subscription_app_index_ = 0;
1603   _clear_bit(3);
1604 }
1605 inline ::google::protobuf::int32 RilCardStatus::cdma_subscription_app_index() const {
1606   return cdma_subscription_app_index_;
1607 }
1608 inline void RilCardStatus::set_cdma_subscription_app_index(::google::protobuf::int32 value) {
1609   _set_bit(3);
1610   cdma_subscription_app_index_ = value;
1611 }
1612
1613 // optional int32 num_applications = 5;
1614 inline bool RilCardStatus::has_num_applications() const {
1615   return _has_bit(4);
1616 }
1617 inline void RilCardStatus::clear_num_applications() {
1618   num_applications_ = 0;
1619   _clear_bit(4);
1620 }
1621 inline ::google::protobuf::int32 RilCardStatus::num_applications() const {
1622   return num_applications_;
1623 }
1624 inline void RilCardStatus::set_num_applications(::google::protobuf::int32 value) {
1625   _set_bit(4);
1626   num_applications_ = value;
1627 }
1628
1629 // repeated .ril_proto.RilAppStatus applications = 6;
1630 inline int RilCardStatus::applications_size() const {
1631   return applications_.size();
1632 }
1633 inline void RilCardStatus::clear_applications() {
1634   applications_.Clear();
1635 }
1636 inline const ::ril_proto::RilAppStatus& RilCardStatus::applications(int index) const {
1637   return applications_.Get(index);
1638 }
1639 inline ::ril_proto::RilAppStatus* RilCardStatus::mutable_applications(int index) {
1640   return applications_.Mutable(index);
1641 }
1642 inline ::ril_proto::RilAppStatus* RilCardStatus::add_applications() {
1643   return applications_.Add();
1644 }
1645 inline const ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >&
1646 RilCardStatus::applications() const {
1647   return applications_;
1648 }
1649 inline ::google::protobuf::RepeatedPtrField< ::ril_proto::RilAppStatus >*
1650 RilCardStatus::mutable_applications() {
1651   return &applications_;
1652 }
1653
1654 // -------------------------------------------------------------------
1655
1656 // RspStrings
1657
1658 // repeated string strings = 1;
1659 inline int RspStrings::strings_size() const {
1660   return strings_.size();
1661 }
1662 inline void RspStrings::clear_strings() {
1663   strings_.Clear();
1664 }
1665 inline const ::std::string& RspStrings::strings(int index) const {
1666   return strings_.Get(index);
1667 }
1668 inline ::std::string* RspStrings::mutable_strings(int index) {
1669   return strings_.Mutable(index);
1670 }
1671 inline void RspStrings::set_strings(int index, const ::std::string& value) {
1672   strings_.Mutable(index)->assign(value);
1673 }
1674 inline void RspStrings::set_strings(int index, const char* value) {
1675   strings_.Mutable(index)->assign(value);
1676 }
1677 inline void RspStrings::set_strings(int index, const char* value, size_t size) {
1678   strings_.Mutable(index)->assign(
1679     reinterpret_cast<const char*>(value), size);
1680 }
1681 inline ::std::string* RspStrings::add_strings() {
1682   return strings_.Add();
1683 }
1684 inline void RspStrings::add_strings(const ::std::string& value) {
1685   strings_.Add()->assign(value);
1686 }
1687 inline void RspStrings::add_strings(const char* value) {
1688   strings_.Add()->assign(value);
1689 }
1690 inline void RspStrings::add_strings(const char* value, size_t size) {
1691   strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
1692 }
1693 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
1694 RspStrings::strings() const {
1695   return strings_;
1696 }
1697 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
1698 RspStrings::mutable_strings() {
1699   return &strings_;
1700 }
1701
1702 // -------------------------------------------------------------------
1703
1704 // RspIntegers
1705
1706 // repeated int32 integers = 1;
1707 inline int RspIntegers::integers_size() const {
1708   return integers_.size();
1709 }
1710 inline void RspIntegers::clear_integers() {
1711   integers_.Clear();
1712 }
1713 inline ::google::protobuf::int32 RspIntegers::integers(int index) const {
1714   return integers_.Get(index);
1715 }
1716 inline void RspIntegers::set_integers(int index, ::google::protobuf::int32 value) {
1717   integers_.Set(index, value);
1718 }
1719 inline void RspIntegers::add_integers(::google::protobuf::int32 value) {
1720   integers_.Add(value);
1721 }
1722 inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1723 RspIntegers::integers() const {
1724   return integers_;
1725 }
1726 inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1727 RspIntegers::mutable_integers() {
1728   return &integers_;
1729 }
1730
1731 // -------------------------------------------------------------------
1732
1733 // ReqGetSimStatus
1734
1735 // -------------------------------------------------------------------
1736
1737 // RspGetSimStatus
1738
1739 // required .ril_proto.RilCardStatus card_status = 1;
1740 inline bool RspGetSimStatus::has_card_status() const {
1741   return _has_bit(0);
1742 }
1743 inline void RspGetSimStatus::clear_card_status() {
1744   if (card_status_ != NULL) card_status_->::ril_proto::RilCardStatus::Clear();
1745   _clear_bit(0);
1746 }
1747 inline const ::ril_proto::RilCardStatus& RspGetSimStatus::card_status() const {
1748   return card_status_ != NULL ? *card_status_ : *default_instance_->card_status_;
1749 }
1750 inline ::ril_proto::RilCardStatus* RspGetSimStatus::mutable_card_status() {
1751   _set_bit(0);
1752   if (card_status_ == NULL) card_status_ = new ::ril_proto::RilCardStatus;
1753   return card_status_;
1754 }
1755
1756 // -------------------------------------------------------------------
1757
1758 // ReqEnterSimPin
1759
1760 // required string pin = 1;
1761 inline bool ReqEnterSimPin::has_pin() const {
1762   return _has_bit(0);
1763 }
1764 inline void ReqEnterSimPin::clear_pin() {
1765   if (pin_ != &_default_pin_) {
1766     pin_->clear();
1767   }
1768   _clear_bit(0);
1769 }
1770 inline const ::std::string& ReqEnterSimPin::pin() const {
1771   return *pin_;
1772 }
1773 inline void ReqEnterSimPin::set_pin(const ::std::string& value) {
1774   _set_bit(0);
1775   if (pin_ == &_default_pin_) {
1776     pin_ = new ::std::string;
1777   }
1778   pin_->assign(value);
1779 }
1780 inline void ReqEnterSimPin::set_pin(const char* value) {
1781   _set_bit(0);
1782   if (pin_ == &_default_pin_) {
1783     pin_ = new ::std::string;
1784   }
1785   pin_->assign(value);
1786 }
1787 inline void ReqEnterSimPin::set_pin(const char* value, size_t size) {
1788   _set_bit(0);
1789   if (pin_ == &_default_pin_) {
1790     pin_ = new ::std::string;
1791   }
1792   pin_->assign(reinterpret_cast<const char*>(value), size);
1793 }
1794 inline ::std::string* ReqEnterSimPin::mutable_pin() {
1795   _set_bit(0);
1796   if (pin_ == &_default_pin_) {
1797     pin_ = new ::std::string;
1798   }
1799   return pin_;
1800 }
1801
1802 // -------------------------------------------------------------------
1803
1804 // RspEnterSimPin
1805
1806 // required int32 retries_remaining = 1;
1807 inline bool RspEnterSimPin::has_retries_remaining() const {
1808   return _has_bit(0);
1809 }
1810 inline void RspEnterSimPin::clear_retries_remaining() {
1811   retries_remaining_ = 0;
1812   _clear_bit(0);
1813 }
1814 inline ::google::protobuf::int32 RspEnterSimPin::retries_remaining() const {
1815   return retries_remaining_;
1816 }
1817 inline void RspEnterSimPin::set_retries_remaining(::google::protobuf::int32 value) {
1818   _set_bit(0);
1819   retries_remaining_ = value;
1820 }
1821
1822 // -------------------------------------------------------------------
1823
1824 // ReqHangUp
1825
1826 // required int32 connection_index = 1;
1827 inline bool ReqHangUp::has_connection_index() const {
1828   return _has_bit(0);
1829 }
1830 inline void ReqHangUp::clear_connection_index() {
1831   connection_index_ = 0;
1832   _clear_bit(0);
1833 }
1834 inline ::google::protobuf::int32 ReqHangUp::connection_index() const {
1835   return connection_index_;
1836 }
1837 inline void ReqHangUp::set_connection_index(::google::protobuf::int32 value) {
1838   _set_bit(0);
1839   connection_index_ = value;
1840 }
1841
1842 // -------------------------------------------------------------------
1843
1844 // ReqScreenState
1845
1846 // required bool state = 1;
1847 inline bool ReqScreenState::has_state() const {
1848   return _has_bit(0);
1849 }
1850 inline void ReqScreenState::clear_state() {
1851   state_ = false;
1852   _clear_bit(0);
1853 }
1854 inline bool ReqScreenState::state() const {
1855   return state_;
1856 }
1857 inline void ReqScreenState::set_state(bool value) {
1858   _set_bit(0);
1859   state_ = value;
1860 }
1861
1862 // -------------------------------------------------------------------
1863
1864 // RspOperator
1865
1866 // optional string long_alpha_ons = 1;
1867 inline bool RspOperator::has_long_alpha_ons() const {
1868   return _has_bit(0);
1869 }
1870 inline void RspOperator::clear_long_alpha_ons() {
1871   if (long_alpha_ons_ != &_default_long_alpha_ons_) {
1872     long_alpha_ons_->clear();
1873   }
1874   _clear_bit(0);
1875 }
1876 inline const ::std::string& RspOperator::long_alpha_ons() const {
1877   return *long_alpha_ons_;
1878 }
1879 inline void RspOperator::set_long_alpha_ons(const ::std::string& value) {
1880   _set_bit(0);
1881   if (long_alpha_ons_ == &_default_long_alpha_ons_) {
1882     long_alpha_ons_ = new ::std::string;
1883   }
1884   long_alpha_ons_->assign(value);
1885 }
1886 inline void RspOperator::set_long_alpha_ons(const char* value) {
1887   _set_bit(0);
1888   if (long_alpha_ons_ == &_default_long_alpha_ons_) {
1889     long_alpha_ons_ = new ::std::string;
1890   }
1891   long_alpha_ons_->assign(value);
1892 }
1893 inline void RspOperator::set_long_alpha_ons(const char* value, size_t size) {
1894   _set_bit(0);
1895   if (long_alpha_ons_ == &_default_long_alpha_ons_) {
1896     long_alpha_ons_ = new ::std::string;
1897   }
1898   long_alpha_ons_->assign(reinterpret_cast<const char*>(value), size);
1899 }
1900 inline ::std::string* RspOperator::mutable_long_alpha_ons() {
1901   _set_bit(0);
1902   if (long_alpha_ons_ == &_default_long_alpha_ons_) {
1903     long_alpha_ons_ = new ::std::string;
1904   }
1905   return long_alpha_ons_;
1906 }
1907
1908 // optional string short_alpha_ons = 2;
1909 inline bool RspOperator::has_short_alpha_ons() const {
1910   return _has_bit(1);
1911 }
1912 inline void RspOperator::clear_short_alpha_ons() {
1913   if (short_alpha_ons_ != &_default_short_alpha_ons_) {
1914     short_alpha_ons_->clear();
1915   }
1916   _clear_bit(1);
1917 }
1918 inline const ::std::string& RspOperator::short_alpha_ons() const {
1919   return *short_alpha_ons_;
1920 }
1921 inline void RspOperator::set_short_alpha_ons(const ::std::string& value) {
1922   _set_bit(1);
1923   if (short_alpha_ons_ == &_default_short_alpha_ons_) {
1924     short_alpha_ons_ = new ::std::string;
1925   }
1926   short_alpha_ons_->assign(value);
1927 }
1928 inline void RspOperator::set_short_alpha_ons(const char* value) {
1929   _set_bit(1);
1930   if (short_alpha_ons_ == &_default_short_alpha_ons_) {
1931     short_alpha_ons_ = new ::std::string;
1932   }
1933   short_alpha_ons_->assign(value);
1934 }
1935 inline void RspOperator::set_short_alpha_ons(const char* value, size_t size) {
1936   _set_bit(1);
1937   if (short_alpha_ons_ == &_default_short_alpha_ons_) {
1938     short_alpha_ons_ = new ::std::string;
1939   }
1940   short_alpha_ons_->assign(reinterpret_cast<const char*>(value), size);
1941 }
1942 inline ::std::string* RspOperator::mutable_short_alpha_ons() {
1943   _set_bit(1);
1944   if (short_alpha_ons_ == &_default_short_alpha_ons_) {
1945     short_alpha_ons_ = new ::std::string;
1946   }
1947   return short_alpha_ons_;
1948 }
1949
1950 // optional string mcc_mnc = 3;
1951 inline bool RspOperator::has_mcc_mnc() const {
1952   return _has_bit(2);
1953 }
1954 inline void RspOperator::clear_mcc_mnc() {
1955   if (mcc_mnc_ != &_default_mcc_mnc_) {
1956     mcc_mnc_->clear();
1957   }
1958   _clear_bit(2);
1959 }
1960 inline const ::std::string& RspOperator::mcc_mnc() const {
1961   return *mcc_mnc_;
1962 }
1963 inline void RspOperator::set_mcc_mnc(const ::std::string& value) {
1964   _set_bit(2);
1965   if (mcc_mnc_ == &_default_mcc_mnc_) {
1966     mcc_mnc_ = new ::std::string;
1967   }
1968   mcc_mnc_->assign(value);
1969 }
1970 inline void RspOperator::set_mcc_mnc(const char* value) {
1971   _set_bit(2);
1972   if (mcc_mnc_ == &_default_mcc_mnc_) {
1973     mcc_mnc_ = new ::std::string;
1974   }
1975   mcc_mnc_->assign(value);
1976 }
1977 inline void RspOperator::set_mcc_mnc(const char* value, size_t size) {
1978   _set_bit(2);
1979   if (mcc_mnc_ == &_default_mcc_mnc_) {
1980     mcc_mnc_ = new ::std::string;
1981   }
1982   mcc_mnc_->assign(reinterpret_cast<const char*>(value), size);
1983 }
1984 inline ::std::string* RspOperator::mutable_mcc_mnc() {
1985   _set_bit(2);
1986   if (mcc_mnc_ == &_default_mcc_mnc_) {
1987     mcc_mnc_ = new ::std::string;
1988   }
1989   return mcc_mnc_;
1990 }
1991
1992
1993 // @@protoc_insertion_point(namespace_scope)
1994
1995 }  // namespace ril_proto
1996
1997 #ifndef SWIG
1998 namespace google {
1999 namespace protobuf {
2000
2001 template <>
2002 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilCommand>() {
2003   return ril_proto::RilCommand_descriptor();
2004 }
2005 template <>
2006 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RadioState>() {
2007   return ril_proto::RadioState_descriptor();
2008 }
2009 template <>
2010 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilCardState>() {
2011   return ril_proto::RilCardState_descriptor();
2012 }
2013 template <>
2014 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilPersoSubstate>() {
2015   return ril_proto::RilPersoSubstate_descriptor();
2016 }
2017 template <>
2018 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilAppState>() {
2019   return ril_proto::RilAppState_descriptor();
2020 }
2021 template <>
2022 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilPinState>() {
2023   return ril_proto::RilPinState_descriptor();
2024 }
2025 template <>
2026 inline const EnumDescriptor* GetEnumDescriptor< ril_proto::RilAppType>() {
2027   return ril_proto::RilAppType_descriptor();
2028 }
2029
2030 }  // namespace google
2031 }  // namespace protobuf
2032 #endif  // SWIG
2033
2034 // @@protoc_insertion_point(global_scope)
2035
2036 #endif  // PROTOBUF_ril_2eproto__INCLUDED