hardware/ril/mock-ril/src/generated/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 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